script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-method/test/method.rb

@@ -77,7 +77,7 @@ def respond_to_missing?(m, b)
 
 assert 'instance' do
   assert_kind_of Method, 1.method(:+)
-  assert_kind_of UnboundMethod, Fixnum.instance_method(:+)
+  assert_kind_of UnboundMethod, Integer.instance_method(:+)
 end
 
 assert 'Method#call' do
@@ -404,9 +404,9 @@ def respond_to_missing?(m, b)
 end
 
 assert 'UnboundMethod#==' do
-  assert_false(Fixnum.instance_method(:+) == Fixnum.instance_method(:-))
-  assert_true(Fixnum.instance_method(:+) == Fixnum.instance_method(:+))
-  assert_false(Fixnum.instance_method(:+) == Float.instance_method(:+))
+  assert_false(Integer.instance_method(:+) == Integer.instance_method(:-))
+  assert_true(Integer.instance_method(:+) == Integer.instance_method(:+))
+  assert_false(Integer.instance_method(:+) == Float.instance_method(:+))
   assert_true(UnboundMethod.instance_method(:==) == UnboundMethod.instance_method(:eql?))
 end
 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-numeric-ext/src/numeric_ext.c

@@ -1,6 +1,7 @@
 #include <limits.h>
 #include <mruby.h>
 #include <mruby/numeric.h>
+#include <mruby/presym.h>
 
 /*
  *  call-seq:
@@ -53,24 +54,24 @@ mrb_int_nobits(mrb_state *mrb, mrb_value self)
 void
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
 {
-  struct RClass *i = mrb_module_get(mrb, "Integral");
+  struct RClass *i = mrb_class_get(mrb, "Integer");
 
   mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1));
 
-#ifndef MRB_WITHOUT_FLOAT
-  mrb_define_const(mrb, mrb->float_class, "RADIX",        mrb_fixnum_value(MRB_FLT_RADIX));
-  mrb_define_const(mrb, mrb->float_class, "MANT_DIG",     mrb_fixnum_value(MRB_FLT_MANT_DIG));
-  mrb_define_const(mrb, mrb->float_class, "EPSILON",      mrb_float_value(mrb, MRB_FLT_EPSILON));
-  mrb_define_const(mrb, mrb->float_class, "DIG",          mrb_fixnum_value(MRB_FLT_DIG));
-  mrb_define_const(mrb, mrb->float_class, "MIN_EXP",      mrb_fixnum_value(MRB_FLT_MIN_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MIN",          mrb_float_value(mrb, MRB_FLT_MIN));
-  mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP",   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MAX_EXP",      mrb_fixnum_value(MRB_FLT_MAX_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MAX",          mrb_float_value(mrb, MRB_FLT_MAX));
-  mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP",   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
-#endif /* MRB_WITHOUT_FLOAT */
+#ifndef MRB_NO_FLOAT
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX),        mrb_fixnum_value(MRB_FLT_RADIX));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG),     mrb_fixnum_value(MRB_FLT_MANT_DIG));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON),      mrb_float_value(mrb, MRB_FLT_EPSILON));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG),          mrb_fixnum_value(MRB_FLT_DIG));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP),      mrb_fixnum_value(MRB_FLT_MIN_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN),          mrb_float_value(mrb, MRB_FLT_MIN));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP),   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP),      mrb_fixnum_value(MRB_FLT_MAX_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX),          mrb_float_value(mrb, MRB_FLT_MAX));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP),   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
+#endif /* MRB_NO_FLOAT */
 }
 
 void

data/ext/enterprise_script_service/mruby/mrbgems/mruby-object-ext/src/object.c

@@ -3,6 +3,7 @@
 #include <mruby/class.h>
 #include <mruby/hash.h>
 #include <mruby/proc.h>
+#include <mruby/presym.h>
 
 /*
  *  call-seq:
@@ -17,7 +18,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj)
   return mrb_ary_new(mrb);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /*
  *  call-seq:
  *     nil.to_f    -> 0.0
@@ -101,20 +102,11 @@ mrb_obj_instance_exec(mrb_state *mrb, mrb_value self)
   struct RClass *c;
 
   mrb_get_args(mrb, "*&!", &argv, &argc, &blk);
-
-  switch (mrb_type(self)) {
-  case MRB_TT_SYMBOL:
-  case MRB_TT_FIXNUM:
-#ifndef MRB_WITHOUT_FLOAT
-  case MRB_TT_FLOAT:
-#endif
-    c = NULL;
-    break;
-  default:
-    c = mrb_class_ptr(mrb_singleton_class(mrb, self));
-    break;
+  c = mrb_singleton_class_ptr(mrb, self);
+  if (mrb->c->ci->acc < 0) {
+    return mrb_yield_with_class(mrb, blk, argc, argv, self, c);
   }
-  mrb->c->ci->target_class = c;
+  mrb_vm_ci_target_class_set(mrb->c->ci, c);
   return mrb_yield_cont(mrb, blk, self, argc, argv);
 }
 
@@ -124,7 +116,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
   struct RClass * n = mrb->nil_class;
 
   mrb_define_method(mrb, n, "to_a", nil_to_a,       MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, n, "to_f", nil_to_f,       MRB_ARGS_NONE());
 #endif
   mrb_define_method(mrb, n, "to_h", nil_to_h,       MRB_ARGS_NONE());
@@ -132,7 +124,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE());
 
-  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
 }
 
 void

data/ext/enterprise_script_service/mruby/mrbgems/mruby-objectspace/src/mruby_objectspace.c

@@ -2,6 +2,15 @@
 #include <mruby/gc.h>
 #include <mruby/hash.h>
 #include <mruby/class.h>
+#include <mruby/object.h>
+#include <mruby/numeric.h>
+#include <mruby/string.h>
+#include <mruby/array.h>
+#include <mruby/variable.h>
+#include <mruby/proc.h>
+#include <mruby/value.h>
+#include <mruby/range.h>
+#include <mruby/presym.h>
 
 struct os_count_struct {
   mrb_int total;
@@ -63,8 +72,8 @@ os_count_objects(mrb_state *mrb, mrb_value self)
 
   mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
 
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed));
 
   for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
     mrb_value type;
@@ -73,7 +82,7 @@ os_count_objects(mrb_state *mrb, mrb_value self)
       COUNT_TYPE(T_FALSE);
       COUNT_TYPE(T_FREE);
       COUNT_TYPE(T_TRUE);
-      COUNT_TYPE(T_FIXNUM);
+      COUNT_TYPE(T_INTEGER);
       COUNT_TYPE(T_SYMBOL);
       COUNT_TYPE(T_UNDEF);
       COUNT_TYPE(T_FLOAT);
@@ -89,10 +98,10 @@ os_count_objects(mrb_state *mrb, mrb_value self)
       COUNT_TYPE(T_STRING);
       COUNT_TYPE(T_RANGE);
       COUNT_TYPE(T_EXCEPTION);
-      COUNT_TYPE(T_FILE);
       COUNT_TYPE(T_ENV);
       COUNT_TYPE(T_DATA);
       COUNT_TYPE(T_FIBER);
+      COUNT_TYPE(T_ISTRUCT);
 #undef COUNT_TYPE
     default:
       type = mrb_fixnum_value(i); break;
@@ -105,9 +114,9 @@ os_count_objects(mrb_state *mrb, mrb_value self)
 }
 
 struct os_each_object_data {
-  mrb_value block;
   struct RClass *target_module;
   mrb_int count;
+  mrb_value block;
 };
 
 static int
@@ -122,8 +131,8 @@ os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
 
   /* filter internal objects */
   switch (obj->tt) {
-  case MRB_TT_ENV:
-  case MRB_TT_ICLASS:
+  case MRB_TT_FREE: case MRB_TT_ENV:
+  case MRB_TT_BREAK: case MRB_TT_ICLASS:
     return MRB_EACH_OBJ_OK;
   default:
     break;
@@ -159,12 +168,8 @@ os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
 static mrb_value
 os_each_object(mrb_state *mrb, mrb_value self)
 {
-  mrb_value cls = mrb_nil_value();
-  struct os_each_object_data d;
-  mrb_get_args(mrb, "&!|C", &d.block, &cls);
-
-  d.target_module = mrb_nil_p(cls) ? NULL : mrb_class_ptr(cls);
-  d.count = 0;
+  struct os_each_object_data d = {0};
+  mrb_get_args(mrb, "&!|c", &d.block, &d.target_module);
   mrb_objspace_each_objects(mrb, os_each_object_cb, &d);
   return mrb_fixnum_value(d.count);
 }

data/ext/enterprise_script_service/mruby/mrbgems/mruby-os-memsize/mrbgem.rake

@@ -0,0 +1,10 @@
+MRuby::Gem::Specification.new('mruby-os-memsize') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'ObjectSpace memsize_of method'
+
+  spec.add_dependency('mruby-objectspace')
+  spec.add_test_dependency('mruby-metaprog')
+  spec.add_test_dependency('mruby-method')
+  spec.add_test_dependency('mruby-fiber')
+end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-os-memsize/src/memsize.c

@@ -0,0 +1,231 @@
+#include <mruby.h>
+#include <mruby/gc.h>
+#include <mruby/hash.h>
+#include <mruby/class.h>
+#include <mruby/object.h>
+#include <mruby/numeric.h>
+#include <mruby/string.h>
+#include <mruby/array.h>
+#include <mruby/variable.h>
+#include <mruby/proc.h>
+#include <mruby/value.h>
+#include <mruby/range.h>
+
+static size_t
+os_memsize_of_irep(mrb_state* state, const struct mrb_irep *irep)
+{
+  size_t size;
+  int i;
+
+  size = (irep->slen * sizeof(mrb_sym)) +
+         (irep->plen * sizeof(mrb_code)) +
+         (irep->ilen * sizeof(mrb_code));
+
+  for(i = 0; i < irep->rlen; i++) {
+    size += os_memsize_of_irep(state, irep->reps[i]);
+  }
+  return size;
+}
+
+static size_t
+os_memsize_of_method(mrb_state* mrb, mrb_value method_obj)
+{
+  size_t size;
+  mrb_value proc_value = mrb_obj_iv_get(mrb, mrb_obj_ptr(method_obj),
+                                        mrb_intern_lit(mrb, "_proc"));
+  if (mrb_nil_p(proc_value)) return 0;
+  struct RProc *proc = mrb_proc_ptr(proc_value);
+
+  size = sizeof(struct RProc);
+  if (!MRB_PROC_CFUNC_P(proc)) size += os_memsize_of_irep(mrb, proc->body.irep);
+  return size;
+}
+
+static mrb_bool
+obj_is_kind_of_checked(mrb_state *mrb, mrb_value obj, const char *classname)
+{
+  mrb_value objclass = mrb_obj_value(mrb->object_class);
+
+  if (mrb_const_defined(mrb, objclass, mrb_intern_cstr(mrb, classname))) {
+    struct RClass *klass = mrb_class_get(mrb, classname);
+    return mrb_obj_is_kind_of(mrb, obj, klass);
+  }
+
+  return FALSE;
+}
+
+static size_t
+os_memsize_of_object(mrb_state* mrb, mrb_value obj)
+{
+  size_t size = 0;
+
+  switch(mrb_type(obj)) {
+    case MRB_TT_STRING:
+      size += mrb_objspace_page_slot_size();
+      if (!RSTR_EMBED_P(RSTRING(obj)) && !RSTR_SHARED_P(RSTRING(obj))) {
+        size += RSTRING_CAPA(obj);
+        size++; /* NUL terminator */
+      }
+      break;
+    case MRB_TT_CLASS:
+    case MRB_TT_MODULE:
+    case MRB_TT_SCLASS:
+    case MRB_TT_ICLASS:
+      size += mrb_gc_mark_mt_size(mrb, mrb_class_ptr(obj)) * sizeof(mrb_method_t);
+      /* fall through */
+    case MRB_TT_EXCEPTION:
+    case MRB_TT_OBJECT: {
+      size += mrb_objspace_page_slot_size();
+      size += mrb_obj_iv_tbl_memsize(obj);
+      if (obj_is_kind_of_checked(mrb, obj, "UnboundMethod") ||
+          obj_is_kind_of_checked(mrb, obj, "Method")) {
+        size += os_memsize_of_method(mrb, obj);
+      }
+      break;
+    }
+    case MRB_TT_HASH: {
+      size += mrb_objspace_page_slot_size() +
+              mrb_hash_memsize(obj);
+      break;
+    }
+    case MRB_TT_ARRAY: {
+      mrb_int len = RARRAY_LEN(obj);
+      /* Arrays that do not fit within an RArray perform a heap allocation
+      *  storing an array of pointers to the original objects*/
+      size += mrb_objspace_page_slot_size();
+      if(len > MRB_ARY_EMBED_LEN_MAX) size += sizeof(mrb_value *) * len;
+      break;
+    }
+    case MRB_TT_PROC: {
+      struct RProc* proc = mrb_proc_ptr(obj);
+      size += mrb_objspace_page_slot_size();
+      size += MRB_ENV_LEN(proc->e.env) * sizeof(mrb_value);
+      if(!MRB_PROC_CFUNC_P(proc)) size += os_memsize_of_irep(mrb, proc->body.irep);
+      break;
+    }
+    case MRB_TT_RANGE:
+#ifndef MRB_RANGE_EMBED
+      size += mrb_objspace_page_slot_size() +
+              sizeof(struct mrb_range_edges);
+#endif
+      break;
+    case MRB_TT_FIBER: {
+      struct RFiber* f = (struct RFiber *)mrb_ptr(obj);
+      ptrdiff_t stack_size = f->cxt->stend - f->cxt->stbase;
+      ptrdiff_t ci_size = f->cxt->ciend - f->cxt->cibase;
+
+      size += mrb_objspace_page_slot_size() +
+        sizeof(struct mrb_context) +
+        sizeof(mrb_value) * stack_size +
+        sizeof(mrb_callinfo) * ci_size;
+      break;
+    }
+#ifndef MRB_NO_FLOAT
+    case MRB_TT_FLOAT:
+#endif
+    case MRB_TT_INTEGER:
+      if (mrb_immediate_p(obj))
+        break;
+    case MRB_TT_DATA:
+  case MRB_TT_ISTRUCT:
+      size += mrb_objspace_page_slot_size();
+      break;
+    /*  zero heap size types.
+     *  immediate VM stack values, contained within mrb_state, or on C stack */
+    case MRB_TT_TRUE:
+    case MRB_TT_FALSE:
+    case MRB_TT_BREAK:
+    case MRB_TT_CPTR:
+    case MRB_TT_SYMBOL:
+    case MRB_TT_FREE:
+    case MRB_TT_UNDEF:
+    case MRB_TT_ENV:
+    /* never used, silences compiler warning
+     * not having a default: clause lets the compiler tell us when there is a new
+     * TT not accounted for */
+    case MRB_TT_MAXDEFINE:
+      break;
+  }
+  return size;
+}
+
+/*
+ *  call-seq:
+ *    ObjectSpace.memsize_of(obj) -> Numeric
+ *
+ *  Returns the amount of heap memory allocated for object in size_t units.
+ *
+ *  The return value depends on the definition of size_t on that platform,
+ *  therefore the value is not comparable across platform types.
+ *
+ *  Immediate values such as integers, booleans, symbols and unboxed float numbers
+ *  return 0. Additionally special objects which are small enough to fit inside an
+ *  object pointer, termed embedded objects, will return the size of the object pointer.
+ *  Strings and arrays below a compile-time defined size may be embedded.
+ */
+
+static mrb_value
+os_memsize_of(mrb_state *mrb, mrb_value self)
+{
+  size_t total;
+  mrb_value obj;
+
+  mrb_get_args(mrb, "o", &obj);
+
+  total = os_memsize_of_object(mrb, obj);
+  return mrb_fixnum_value((mrb_int)total);
+}
+
+struct os_memsize_of_all_cb_data {
+  size_t t;
+  struct RClass *type;
+};
+
+static int
+os_memsize_of_all_cb(mrb_state *mrb, struct RBasic *obj, void *d)
+{
+  struct os_memsize_of_all_cb_data *data = (struct os_memsize_of_all_cb_data *)d;
+  switch (obj->tt) {
+  case MRB_TT_FREE: case MRB_TT_ENV:
+  case MRB_TT_BREAK: case MRB_TT_ICLASS:
+    /* internal objects that should not be counted */
+    return MRB_EACH_OBJ_OK;
+  default:
+    break;
+  }
+  /* skip Proc objects for methods */
+  if (obj->c == NULL) return 0;
+  if (data->type == NULL || mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), data->type))
+    data->t += os_memsize_of_object(mrb, mrb_obj_value(obj));
+  return MRB_EACH_OBJ_OK;
+}
+
+/*
+ *  call-seq:
+ *    ObjectSpace.memsize_of_all([klass]) -> Numeric
+ *
+ *  Return consuming memory size of all living objects of type klass.
+ *
+ */
+
+static mrb_value
+os_memsize_of_all(mrb_state *mrb, mrb_value self)
+{
+  struct os_memsize_of_all_cb_data data = { 0 };
+  mrb_get_args(mrb, "|c", &data.type);
+  mrb_objspace_each_objects(mrb, os_memsize_of_all_cb, &data);
+  return mrb_fixnum_value((mrb_int)data.t);
+}
+
+void
+mrb_mruby_os_memsize_gem_init(mrb_state *mrb)
+{
+  struct RClass *os = mrb_module_get(mrb, "ObjectSpace");
+  mrb_define_class_method(mrb, os, "memsize_of", os_memsize_of, MRB_ARGS_REQ(1));
+  mrb_define_class_method(mrb, os, "memsize_of_all", os_memsize_of_all, MRB_ARGS_OPT(1));
+}
+
+void
+mrb_mruby_os_memsize_gem_final(mrb_state *mrb)
+{
+}