Merge pull request #2 from udzura/api-impl

Implement basic dump API

Author: udzura

.gitignore

@@ -1,3 +1,4 @@
 /target
 
 *.mrb
+examples/out.c

Cargo.lock

@@ -13,8 +13,14 @@ include = [
 ]
 
 [dependencies]
+libc = { version = "0.2.177", optional = true }
 
 [build-dependencies]
 bindgen = ">= 0"
 cc = ">= 1"
-glob = ">= 0"
+glob = ">= 0"
+
+[features]
+default = [ "std" ]
+std = [ "dep:libc" ]
+no-std = []

Cargo.toml

@@ -0,0 +1,9 @@
+# mruby-compiler2-sys
+Naive mruby-compiler2 binding for Rust
+
+See Rust doc [mruby-compiler2-sys](https://crates.io/crates/mruby-compiler2-sys) for details.
+
+## License
+See LICENSE file.
+
+NOTE: This crate includes code from mruby-compiler2 and prism, which are under the MIT License.

README.md

@@ -30,10 +30,8 @@ fn main() {
 
     println!("cargo:rustc-link-lib=mrubycompiler2");
     let bindings = bindgen::Builder::default()
-        .header("./vendor/mruby-compiler2/include/mrc_ccontext.h")
-        .header("./vendor/mruby-compiler2/include/mrc_irep.h")
-        .header("./vendor/mruby-compiler2/include/mrc_compile.h")
-        .header("./vendor/mruby-compiler2/include/mrc_dump.h")
+        .header("./vendor/mruby-compiler2/include/mruby_compiler.h")
+        .header("./vendor/mruby-compiler2/include/mrc_codedump.h")
         .clang_arg("-I./vendor/mruby-compiler2/include")
         .clang_arg("-I./vendor/mruby-compiler2/lib/prism/include")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))

build.rs

@@ -0,0 +1,15 @@
+extern crate mruby_compiler2_sys;
+use mruby_compiler2_sys::MRubyCompiler2Context;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    unsafe {
+        let mut cxt = MRubyCompiler2Context::new();
+        cxt.compile_to_c_function(
+            "puts \"Hello, mruby-compiler2!\"",
+            "init_test_func",
+            std::path::Path::new("examples/out.c"),
+        )?;
+    }
+    println!("Created examples/out.c");
+    Ok(())
+}

examples/cfunc.rs

@@ -1,13 +1,17 @@
 extern crate mruby_compiler2_sys;
 use mruby_compiler2_sys::MRubyCompiler2Context;
 
-fn main() {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     unsafe {
         let mut cxt = MRubyCompiler2Context::new();
-        let bin = cxt.compile("puts \"Hello, mruby-compiler2!\"");
-        println!("Compiled bytecode size: {}", bin.len());
+        cxt.dump_bytecode("puts \"Hello, mruby-compiler2!\"")?;
 
-        let out = std::fs::File::create("examples/out.mrb").unwrap();
-        std::io::Write::write_all(&mut &out, &bin).unwrap();
+        let bin = cxt.compile("puts \"Hello, mruby-compiler2!\"")?;
+
+        let out = std::fs::File::create("examples/out.mrb")?;
+        std::io::Write::write_all(&mut &out, &bin)?;
+
+        println!("Compiled bytecode file: examples/out.mrb, size: {}", bin.len());
     }
+    Ok(())
 }

examples/smoke.rs

@@ -17260,6 +17260,12 @@ const _: () = {
     ["Offset of field: rite_binary_footer::section_size"]
         [::std::mem::offset_of!(rite_binary_footer, section_size) - 4usize];
 };
+unsafe extern "C" {
+    pub fn mrc_codedump_all_file(c: *mut mrc_ccontext, irep: *mut mrc_irep, out: *mut FILE);
+}
+unsafe extern "C" {
+    pub fn mrc_codedump_all(c: *mut mrc_ccontext, irep: *mut mrc_irep);
+}
 pub type __builtin_va_list = *mut ::std::os::raw::c_char;
 pub type __uint128_t = u128;
 #[repr(C)]

src/bindings.rs

@@ -7,44 +7,74 @@ mod bindings {
     include!("./bindings.rs");
 }
 use bindings::{
-    mrc_ccontext,
-    mrc_ccontext_new,
-    mrc_load_string_cxt,
-    mrc_irep,
-    mrc_dump_irep,
-    MRC_DUMP_OK,
-    mrc_irep_free,
-    mrc_ccontext_free,
+    MRC_DUMP_OK, mrc_ccontext, mrc_ccontext_free, mrc_ccontext_new, mrc_dump_irep, mrc_irep,
+    mrc_irep_free, mrc_load_string_cxt,
 };
 
+#[cfg(feature = "std")]
+use std::os::unix::io::AsRawFd;
+
+#[cfg(feature = "std")]
+use bindings::{FILE, fdopen, mrc_codedump_all, mrc_dump_irep_cfunc};
+
+#[derive(Debug)]
+pub struct MRubyCompiler2Error {
+    details: String,
+}
+
+impl MRubyCompiler2Error {
+    fn new(msg: &str) -> MRubyCompiler2Error {
+        MRubyCompiler2Error {
+            details: msg.to_string(),
+        }
+    }
+
+    #[allow(unused)]
+    fn from_error<E: std::error::Error>(msg: &str, err: E) -> MRubyCompiler2Error {
+        MRubyCompiler2Error {
+            details: format!("{}: {}", msg, err.to_string()),
+        }
+    }
+}
+
+impl std::fmt::Display for MRubyCompiler2Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.details)
+    }
+}
+
+impl std::error::Error for MRubyCompiler2Error {}
+
 pub struct MRubyCompiler2Context {
     c: *mut mrc_ccontext,
 }
 
 impl MRubyCompiler2Context {
+    /// Creates a new MRubyCompiler2Context
     pub unsafe fn new() -> Self {
         unsafe {
             let ccontext = mrc_ccontext_new(null_mut());
             MRubyCompiler2Context { c: ccontext }
         }
     }
 
-    pub unsafe fn compile(&mut self, code: &str) -> Vec<u8> {
+    /// Compiles the given mruby code into mruby bytecode binary
+    /// Returns the bytecode as a Vec<u8>
+    pub unsafe fn compile(&mut self, code: &str) -> Result<Vec<u8>, MRubyCompiler2Error> {
         unsafe {
-            let c_code = std::ffi::CString::new(code).unwrap();
+            let c_code = std::ffi::CString::new(code)
+                .map_err(|_| MRubyCompiler2Error::new("Code includes null bytes"))?;
             let mut ptr = c_code.as_ptr() as *const u8;
-            let irep = mrc_load_string_cxt(
-                self.c,
-                &mut ptr as *mut *const u8,
-                c_code.as_bytes().len()
-            );
+            let irep =
+                mrc_load_string_cxt(self.c, &mut ptr as *mut *const u8, c_code.as_bytes().len());
 
             if irep.is_null() {
-                panic!("Failed to compile code");
+                return Err(MRubyCompiler2Error::new("Failed to compile code"));
             }
 
             // Set dummy capacity, deduced from code length
-            let mut bin: Vec<u8> = Vec::with_capacity(code.len() * 2);
+            // And leak for safety rather than memory efficiency
+            let bin: &'static mut [u8] = Vec::with_capacity(code.len() * 2).leak();
             let bin_ptr = bin.as_mut_ptr();
             let mut bin_size: usize = 0;
 
@@ -55,14 +85,84 @@ impl MRubyCompiler2Context {
                 &bin_ptr as *const *mut u8 as *mut *mut u8,
                 &mut bin_size as *mut usize,
             );
+            mrc_irep_free(self.c, irep as *mut mrc_irep);
             if result as u32 != MRC_DUMP_OK {
-                panic!("Failed to dump irep");
+                return Err(MRubyCompiler2Error::new("Failed to dump irep binary"));
             }
-            mrc_irep_free(self.c, irep as *mut mrc_irep);
 
-            dbg!(bin_size);
             let newvec = Vec::from_raw_parts(bin_ptr, bin_size, bin_size);
-            newvec
+            Ok(newvec)
+        }
+    }
+
+    /// Dumps the compiled bytecode of the given mruby code to stdout
+    #[cfg(feature = "std")]
+    pub unsafe fn dump_bytecode(&mut self, code: &str) -> Result<(), MRubyCompiler2Error> {
+        unsafe {
+            let c_code = std::ffi::CString::new(code)
+                .map_err(|_| MRubyCompiler2Error::new("Code includes null bytes"))?;
+            let mut ptr = c_code.as_ptr() as *const u8;
+            let irep =
+                mrc_load_string_cxt(self.c, &mut ptr as *mut *const u8, c_code.as_bytes().len());
+
+            if irep.is_null() {
+                return Err(MRubyCompiler2Error::new("Failed to compile code"));
+            }
+
+            mrc_codedump_all(self.c, irep as *mut mrc_irep);
+            mrc_irep_free(self.c, irep as *mut mrc_irep);
+            Ok(())
+        }
+    }
+
+    /// Compiles the given mruby code and writes the bytecode to the specified file path
+    #[cfg(feature = "std")]
+    pub unsafe fn compile_to_file(
+        &mut self,
+        code: &str,
+        path: &std::path::Path,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let bin = unsafe { self.compile(code) }?;
+        let mut out = std::fs::File::create(path)?;
+        std::io::Write::write_all(&mut out, &bin)?;
+        Ok(())
+    }
+
+    /// Compiles the given mruby code and writes the bytecode as a C function to the specified file path
+    #[cfg(feature = "std")]
+    pub unsafe fn compile_to_c_function(
+        &mut self,
+        code: &str,
+        initname: &str,
+        path: &std::path::Path,
+    ) -> Result<(), MRubyCompiler2Error> {
+        let out = std::fs::File::create(path)
+            .map_err(|e| MRubyCompiler2Error::from_error("Failed to create file", e))?;
+
+        unsafe {
+            let c_code = std::ffi::CString::new(code)
+                .map_err(|e| MRubyCompiler2Error::from_error("Code includes null bytes", e))?;
+            let mut ptr = c_code.as_ptr() as *const u8;
+            let irep =
+                mrc_load_string_cxt(self.c, &mut ptr as *mut *const u8, c_code.as_bytes().len());
+
+            if irep.is_null() {
+                return Err(MRubyCompiler2Error::new("Failed to compile code"));
+            }
+            let fd = out.as_raw_fd();
+            let mode_str = std::ffi::CString::new("w").unwrap();
+            let fp = fdopen(fd, mode_str.as_ptr());
+            std::mem::forget(out);
+
+            let initname = std::ffi::CString::new(initname)
+                .map_err(|e| MRubyCompiler2Error::from_error("Initname includes null bytes", e))?;
+
+            let result = mrc_dump_irep_cfunc(self.c, irep, 0, fp as *mut FILE, initname.as_ptr());
+            mrc_irep_free(self.c, irep as *mut mrc_irep);
+            if result as u32 != MRC_DUMP_OK {
+                return Err(MRubyCompiler2Error::new("Failed to dump irep binary"));
+            }
+            Ok(())
         }
     }
 }
@@ -73,4 +173,4 @@ impl Drop for MRubyCompiler2Context {
             mrc_ccontext_free(self.c);
         }
     }
-}
+}