feat: allow loading of Pluto standard libraries

Author: Sculas

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pluto-build"
-version = "0.1.0-0.10.4"
+version = "0.2.0-0.10.4"
 edition = "2021"
 authors = ["Sculas <[email protected]>"]
 repository = "https://github.com/Sculas/pluto-build-rs"
@@ -10,7 +10,7 @@ license = "MIT"
 description = "A Rust library for compiling and linking Pluto into your Rust project."
 
 [workspace]
-members = ["testcrate"]
+members = ["pluto-ffi", "testcrate"]
 
 [dependencies]
 cc = { version = "1.2", features = ["parallel"] }

Cargo.toml

@@ -9,10 +9,14 @@ A Rust library for compiling and linking [Pluto](https://pluto-lang.org/) into y
 Add the following to your `Cargo.toml`:
 
 ```toml
+[dependencies]
+# Add the `pluto-ffi` crate to your project if you want to use any of Pluto's standard libraries.
+pluto-ffi = "0.1.0"
+
 [build-dependencies]
 # pluto-build's version is suffixed with the Pluto version it was built against.
 # It's recommended to pin this to the exact version of Pluto you want to use.
-pluto-build = "=0.1.0-0.10.4"
+pluto-build = "=0.2.0-0.10.4"
 ```
 
 Then, in your `build.rs` file, add the following:
@@ -38,9 +42,19 @@ This will compile Pluto and link it statically into your project. You can then u
 mlua = { version = "0.10", features = ["lua54", "external"] }
 ```
 
-## Known Issues
+To be able to use Pluto's standard libraries, you must add the following after you've created your `Lua` instance:
+
+```rust
+let lua = mlua::Lua::new();
+pluto_ffi::load_libraries!(&lua)?;
+```
+
+Or, if you want to load only specific libraries:
 
-- The `mlua` crate doesn't call `luaL_openlibs` at the moment, which means none of Pluto's standard libraries are available. I'm working on a fix for this issue.
+```rust
+let lua = mlua::Lua::new();
+pluto_ffi::load_libraries!(&lua, &[pluto_ffi::PlutoLibrary::Base64])?;
+```
 
 ## Updating Pluto
 

README.md

@@ -1 +1,3 @@
+# Unfortunately, the Pluto author refused to change the hook ABIs to the C ABI (with a fair reason),
+# which means we'll have to patch it ourselves. See: https://github.com/PlutoLang/Pluto/issues/1107
 git apply --ignore-whitespace --whitespace=fix patches/hook_c_abi.patch

patch.ps1

@@ -0,0 +1,60 @@
+#include "lua.hpp"
+
+bool plutow_wants_lib(const char** libs, int num_libs, const char* lib) {
+    if (libs == nullptr || num_libs == 0) return true;
+    for (int i = 0; i < num_libs; ++i) {
+        if (strcmp(libs[i], lib) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Source: https://github.com/PlutoLang/Pluto/blob/main/src/linit.cpp#L64
+LUALIB_API void plutow_openlibs(lua_State* L, const char** libs, int num_libs) {
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
+    for (const Pluto::PreloadedLibrary* lib : Pluto::all_preloaded) {
+        if (!plutow_wants_lib(libs, num_libs, lib->name)) continue;
+        lua_pushcfunction(L, lib->init);
+        lua_setfield(L, -2, lib->name);
+    }
+    lua_pop(L, 1);
+
+#ifndef PLUTO_DONT_LOAD_ANY_STANDARD_LIBRARY_CODE_WRITTEN_IN_PLUTO
+    const auto startup_code = R"EOC(
+  pluto_use "0.6.0"
+  
+  class exception
+      __name = "pluto:exception"
+  
+      function __construct(public what)
+          local caller
+          local i = 2
+          while true do
+              caller = debug.getinfo(i)
+              if caller == nil then
+                  error("exception instances must be created with 'pluto_new'", 0)
+              end
+              ++i
+              if caller.name == "Pluto_operator_new" then
+                  caller = debug.getinfo(i)
+                  break
+              end
+          end
+          self.where = $"{caller.short_src}:{caller.currentline}"
+          error(self, 0)
+      end
+  
+      function __tostring()
+          return $"{self.where}: {tostring(self.what)}"
+      end
+  end
+  
+  function instanceof(a, b)
+    return a instanceof b
+  end
+  )EOC";
+    luaL_loadbuffer(L, startup_code, strlen(startup_code), "Pluto Standard Library");
+    lua_call(L, 0, 0);
+#endif
+}

patches/libwrapper.cpp

@@ -0,0 +1,4 @@
+[package]
+name = "pluto-ffi"
+version = "0.1.0"
+edition = "2021"

patches/libwrapper.hpp

@@ -0,0 +1,75 @@
+// Due to the way linking works in Rust (dependencies before build script),
+// we have to use a macro to do all of this inside of the crate itself.
+
+/// Load all or the specified Pluto libraries into the given Lua state.
+/// This should not be called more than once and is inherently unsafe.
+#[macro_export]
+macro_rules! load_libraries {
+    ($lua:expr, $libs:expr) => {unsafe {
+        $crate::load_libraries!(@ffi_import);
+        let libs: &[$crate::PlutoLibrary] = $libs;
+        let libs = libs.iter().map(|lib| lib.ffi_name()).collect::<Vec<_>>();
+        let libs = libs.iter().map(|lib| lib.as_ptr()).collect::<Vec<_>>();
+        $lua.exec_raw::<()>((), |state| plutow_openlibs(state, libs.as_ptr(), libs.len() as _))
+    }};
+    ($lua:expr) => {unsafe {
+        $crate::load_libraries!(@ffi_import);
+        $lua.exec_raw::<()>((), |state| plutow_openlibs(state, std::ptr::null(), 0))
+    }};
+    (@ffi_import) => {
+        extern "C" {
+            #[allow(non_camel_case_types, non_snake_case)]
+            pub fn plutow_openlibs(
+                L: *mut mlua::ffi::lua_State,
+                libs: *const *const std::os::raw::c_char,
+                num_libs: std::os::raw::c_int,
+            );
+        }
+    };
+}
+
+/// PlutoLibrary defines the available Pluto libraries that can be loaded.
+pub enum PlutoLibrary {
+    Crypto,
+    Json,
+    Base32,
+    Base64,
+    Assert,
+    Vector3,
+    Url,
+    Star,
+    Cat,
+    Http,
+    Scheduler,
+    Socket,
+    BigInt,
+    Xml,
+    Regex,
+    FFI,
+    Canvas,
+}
+
+impl PlutoLibrary {
+    pub fn ffi_name(&self) -> std::ffi::CString {
+        std::ffi::CString::new(match self {
+            Self::Crypto => "crypto",
+            Self::Json => "json",
+            Self::Base32 => "base32",
+            Self::Base64 => "base64",
+            Self::Assert => "assert",
+            Self::Vector3 => "vector3",
+            Self::Url => "url",
+            Self::Star => "*",
+            Self::Cat => "cat",
+            Self::Http => "http",
+            Self::Scheduler => "scheduler",
+            Self::Socket => "socket",
+            Self::BigInt => "bigint",
+            Self::Xml => "xml",
+            Self::Regex => "regex",
+            Self::FFI => "ffi",
+            Self::Canvas => "canvas",
+        })
+        .unwrap()
+    }
+}

pluto-ffi/Cargo.toml

@@ -79,8 +79,8 @@ impl Build {
 
         // update the package version in Cargo.toml to match the Pluto version!
         let (_, version) = env!("CARGO_PKG_VERSION").split_once('-').unwrap();
-        let src_dir = std::path::PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap();
-        let src_dir = src_dir.join(format!("Pluto-{version}/src"));
+        let root_dir = std::path::PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap();
+        let src_dir = root_dir.join(format!("Pluto-{version}/src"));
 
         build_soup_dependencies(&build, &src_dir);
 
@@ -115,14 +115,14 @@ impl Build {
             build.file(src_dir.join(file).with_extension("cpp"));
         }
 
+        let patches_dir = root_dir.join("patches");
+        build.add_files_by_ext(&patches_dir, "cpp");
+
         Self(build)
     }
 
     pub fn compile(&mut self) {
         self.0.compile("plutostatic");
-        let out_dir = std::env::var("OUT_DIR").unwrap();
-        println!("cargo:rustc-link-search=native={out_dir}");
-        println!("cargo:rustc-link-lib=static=plutostatic");
     }
 }
 

pluto-ffi/src/lib.rs

@@ -5,6 +5,7 @@ edition = "2021"
 publish = false
 
 [dependencies]
+pluto-ffi = { path = "../pluto-ffi" }
 mlua = { version = "0.10", features = [
     "lua54",
     "macros",