Support mruby 2.1.0

Cargo.toml

@@ -11,7 +11,7 @@ keywords = ["mruby", "ruby", "bindings", "repl"]
 license = "MPL-2.0"
 
 [build-dependencies]
-gcc = "0.3.22"
+cc = "1.0"
 tar = "0.4.4"
 walkdir = "0.1.5"
 

build.rs

@@ -5,7 +5,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-extern crate gcc;
+extern crate cc;
 extern crate tar;
 extern crate walkdir;
 
@@ -25,7 +25,7 @@ fn main() {
     let mut archive = Archive::new(File::open("src/mruby/mruby-out.tar").unwrap());
     archive.unpack("target").unwrap();
 
-    let mut config = gcc::Config::new();
+    let mut config = cc::Build::new();
 
     for entry in WalkDir::new("target/mruby-out/src").into_iter().filter_entry(|e| e.file_type().is_dir() || is_c(e)) {
         let entry = entry.unwrap();
@@ -35,7 +35,7 @@ fn main() {
 
     config.include("target/mruby-out/include").compile("libmruby.a");
 
-    let mut config = gcc::Config::new();
+    let mut config = cc::Build::new();
 
     config.file("src/mrb_ext.c").include("target/mruby-out/include").compile("libmrbe.a");
 }

examples/container.rs

@@ -3,6 +3,7 @@
 extern crate mrusty;
 
 use mrusty::{Mruby, MrubyImpl};
+use mrusty::{MrInt};
 
 fn main() {
     let mruby = Mruby::new();

src/lib.rs

@@ -27,10 +27,12 @@ mod spec;
 
 /// Not meant to be called directly.
 #[doc(hidden)]
-pub use mruby_ffi::MrValue;
+pub use mruby_ffi::{MrValue, MrDataType, MrInt, MrFloat};
 /// Not meant to be called directly.
 #[doc(hidden)]
 pub use mruby_ffi::mrb_get_args;
+#[doc(hidden)]
+pub use mruby_ffi::{mrb_ext_value_sizeof, mrb_ext_data_type_sizeof, mrb_ext_int_sizeof, mrb_ext_float_sizeof};
 
 pub use mruby::Class;
 pub use mruby::ClassLike;

src/mrb_ext.c

@@ -6,6 +6,7 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <stdlib.h>
+#include <string.h>
 
 #include <mruby.h>
 #include <mruby/array.h>
@@ -15,6 +16,8 @@
 #include <mruby/proc.h>
 #include <mruby/value.h>
 #include <mruby/variable.h>
+#include <mruby/throw.h>
+#include <mruby/dump.h>
 
 void* mrb_ext_get_ud(struct mrb_state* mrb) {
   return mrb->ud;
@@ -24,14 +27,96 @@ void mrb_ext_set_ud(struct mrb_state* mrb, void* ud) {
   mrb->ud = ud;
 }
 
-int mrb_ext_fixnum_to_cint(mrb_value value) {
+mrb_value mrb_ext_load_nstring_cxt_nothrow(mrb_state *mrb, const char *s, size_t len, mrbc_context *cxt) {
+  mrb_value value;
+
+  struct mrb_jmpbuf c_jmp;
+  struct mrb_jmpbuf *pc_jmp_bak;
+  pc_jmp_bak = mrb->jmp;
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    value = mrb_load_nstring_cxt(mrb, s, len, cxt);
+  }
+  MRB_CATCH(&c_jmp) {
+    value = mrb_nil_value();
+  }
+  MRB_END_EXC(&c_jmp);
+
+  mrb->jmp = pc_jmp_bak;
+
+  return value;
+}
+
+// from) load.c:read_binary_header()
+static int
+read_binary_size(const uint8_t *bin, size_t *bin_size)
+{
+  const struct rite_binary_header *header = (const struct rite_binary_header *)bin;
+
+  if (memcmp(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident)) == 0) {
+	  // no-op
+  } else if (memcmp(header->binary_ident, RITE_BINARY_IDENT_LIL, sizeof(header->binary_ident)) == 0) {
+	  // no-op
+  } else {
+    return MRB_DUMP_INVALID_FILE_HEADER;
+  }
+
+  if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) {
+    return MRB_DUMP_INVALID_FILE_HEADER;
+  }
+
+  *bin_size = (size_t)bin_to_uint32(header->binary_size);
+
+  return MRB_DUMP_OK;
+}
+// from) load.c:irep_error()
+static void
+irep_error(mrb_state *mrb)
+{
+  mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
+}
+
+mrb_value mrb_ext_load_irep_cxt_suppress_alignment(mrb_state *mrb, const uint8_t *bin, mrbc_context *c) {
+  size_t bin_size = 0;
+  const size_t header_size = sizeof(struct rite_binary_header);
+
+  int result = read_binary_size(bin, &bin_size);
+  if (result != MRB_DUMP_OK || bin_size <= header_size) {
+    irep_error(mrb);
+    return mrb_nil_value();
+  }
+
+  // suppress alignment at run
+  const uint8_t *cpy_bin = (const uint8_t *)mrb_malloc(mrb, bin_size);
+
+  memcpy(cpy_bin, bin, bin_size);
+  mrb_value value = mrb_load_irep_cxt(mrb, cpy_bin, c);
+  mrb_free(mrb, cpy_bin);
+
+  return value;
+}
+
+mrb_int mrb_ext_fixnum_to_cint(mrb_value value) {
   return mrb_fixnum(value);
 }
 
-double mrb_ext_float_to_cdouble(mrb_value value) {
+mrb_float mrb_ext_float_to_cdouble(mrb_value value) {
   return mrb_float(value);
 }
 
+void* mrb_ext_ptr_to_ptr(mrb_value value) {
+  return mrb_ptr(value);
+}
+
+mrb_sym mrb_ext_symbol_to_cuint(mrb_value value) {
+ return mrb_symbol(value);
+}
+
+enum mrb_vtype mrb_ext_type(mrb_value value) {
+	return mrb_type(value);
+}
+
 void* mrb_ext_data_ptr(mrb_value value) {
   return DATA_PTR(value);
 }
@@ -48,22 +133,14 @@ mrb_value mrb_ext_true() {
   return mrb_true_value();
 }
 
-mrb_value mrb_ext_cint_to_fixnum(int value) {
+mrb_value mrb_ext_cint_to_fixnum(mrb_int value) {
   return mrb_fixnum_value(value);
 }
 
-mrb_value mrb_ext_cdouble_to_float(struct mrb_state* mrb, double value) {
+mrb_value mrb_ext_cdouble_to_float(struct mrb_state* mrb, mrb_float value) {
   return mrb_float_value(mrb, value);
 }
 
-mrb_value mrb_ext_proc_to_value(struct mrb_state* mrb, struct RProc* proc) {
-  mrb_value value = mrb_cptr_value(mrb, proc);
-
-  value.tt = MRB_TT_PROC;
-
-  return value;
-}
-
 const char* mrb_ext_sym2name(struct mrb_state* mrb, mrb_value value) {
   return mrb_sym2name(mrb, mrb_symbol(value));
 }
@@ -72,9 +149,7 @@ mrb_value mrb_ext_sym_new(struct mrb_state* mrb, const char* string,
                           size_t len) {
   mrb_value value;
 
-  mrb_symbol(value) = mrb_intern(mrb, string, len);
-
-  value.tt = MRB_TT_SYMBOL;
+  SET_SYM_VALUE(value, mrb_intern(mrb, string, len));
 
   return value;
 }
@@ -91,33 +166,42 @@ mrb_value mrb_ext_set_ptr(struct mrb_state* mrb, void* ptr) {
     return value;
 }
 
+mrb_data_type mrb_ext_data_type(const char* name, void (*dfree)(mrb_state *mrb, void*)) {
+	mrb_data_type data_type = {
+		.struct_name = name,
+		.dfree = dfree
+	};
+
+	return data_type;
+}
+
 void mrb_ext_data_init(mrb_value* value, void* ptr, const mrb_data_type* type) {
   mrb_data_init(*value, ptr, type);
 }
 
 mrb_value mrb_ext_class_value(struct RClass* klass) {
   mrb_value value;
 
-  value.value.p = klass;
-  value.tt = MRB_TT_CLASS;
+  mrb_ptr(value) = klass;
+  mrb_type(value) = MRB_TT_CLASS;
 
   return value;
 }
 
 mrb_value mrb_ext_module_value(struct RClass* module) {
   mrb_value value;
 
-  value.value.p = module;
-  value.tt = MRB_TT_MODULE;
+  mrb_ptr(value) = module;
+  mrb_type(value) = MRB_TT_MODULE;
 
   return value;
 }
 
 mrb_value mrb_ext_data_value(struct RData* data) {
   mrb_value value;
 
-  value.value.p = data;
-  value.tt = MRB_TT_DATA;
+  mrb_ptr(value) = data;
+  mrb_type(value) = MRB_TT_DATA;
 
   return value;
 }
@@ -126,12 +210,17 @@ void mrb_ext_set_instance_tt(struct RClass* class, enum mrb_vtype type) {
   MRB_SET_INSTANCE_TT(class, type);
 }
 
-int mrb_ext_ary_len(struct mrb_state* mrb, mrb_value array) {
-  return mrb_ary_len(mrb, array);
+mrb_int mrb_ext_ary_len(struct mrb_state* mrb, mrb_value array) {
+  return RARRAY_LEN(array);
 }
 
-unsigned int mrb_ext_get_mid(struct mrb_state* mrb) {
-  return mrb_get_mid(mrb);
+mrb_sym mrb_ext_get_mid(struct mrb_state* mrb) {
+  mrb_sym mid = mrb_get_mid(mrb);
+  if (mid == mrb_intern_lit(mrb, "new")) {
+    mid = mrb_intern_lit(mrb, "initialize");
+  }
+
+  return mid;
 }
 
 mrb_value mrb_ext_get_exc(struct mrb_state* mrb) {
@@ -159,9 +248,21 @@ mrb_value mrb_ext_exc_str(struct mrb_state* mrb, mrb_value exc) {
     return mrb_funcall(mrb, exc, "inspect", 0);
 }
 
-mrb_noreturn void mrb_ext_raise(struct mrb_state* mrb, const char* eclass,
+mrb_noreturn void mrb_ext_raise_nothrow(struct mrb_state* mrb, const char* eclass,
   const char* msg) {
-  mrb_raise(mrb, mrb_class_get(mrb, eclass), msg);
+
+  struct mrb_jmpbuf c_jmp;
+  struct mrb_jmpbuf *pc_jmp_bak;
+  pc_jmp_bak = mrb->jmp;
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    mrb_raise(mrb, mrb_class_get(mrb, eclass), msg);
+  }
+  MRB_CATCH(&c_jmp) {}
+  MRB_END_EXC(&c_jmp);
+
+  mrb->jmp = pc_jmp_bak;
 }
 
 mrb_bool mrb_ext_class_defined_under(struct mrb_state* mrb,
@@ -173,10 +274,26 @@ mrb_bool mrb_ext_class_defined_under(struct mrb_state* mrb,
   return mrb_const_defined(mrb, mrb_obj_value(outer), mrb_symbol(sym));
 }
 
-struct RClass* mrb_ext_get_class(mrb_value value) {
-  return (struct RClass*) value.value.p;
+struct RClass* mrb_ext_class_ptr(mrb_value value) {
+  return mrb_class_ptr(value);
 }
 
 struct RClass* mrb_ext_class(struct mrb_state* mrb, mrb_value value) {
   return mrb_class(mrb, value);
 }
+
+size_t mrb_ext_value_sizeof() {
+	return sizeof(mrb_value);
+}
+
+size_t mrb_ext_data_type_sizeof() {
+	return sizeof(mrb_data_type);
+}
+
+size_t mrb_ext_int_sizeof() {
+	return sizeof(mrb_int);
+}
+
+size_t mrb_ext_float_sizeof() {
+	return sizeof(mrb_float);
+}