2 files changed, 39 insertions, 39 deletions

diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
index 1b18bf23f..929a6180d 100644
--- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c
+++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
@@ -1,7 +1,16 @@
-#include "mruby.h"
-#include "mruby/gc.h"
-#include "mruby/hash.h"
-#include "mruby/class.h"
+#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>
+#include <mruby/presym.h>
 
 struct os_count_struct {
   mrb_int total;
@@ -9,7 +18,7 @@ struct os_count_struct {
   mrb_int counts[MRB_TT_MAXDEFINE+1];
 };
 
-static void
+static int
 os_count_object_type(mrb_state *mrb, struct RBasic *obj, void *data)
 {
   struct os_count_struct *obj_count;
@@ -17,12 +26,13 @@ os_count_object_type(mrb_state *mrb, struct RBasic *obj, void *data)
 
   obj_count->total++;
 
-  if (is_dead(mrb, obj)) {
+  if (mrb_object_dead_p(mrb, obj)) {
     obj_count->freed++;
   }
   else {
     obj_count->counts[obj->tt]++;
   }
+  return MRB_EACH_OBJ_OK;
 }
 
 /*
@@ -49,32 +59,27 @@ static mrb_value
 os_count_objects(mrb_state *mrb, mrb_value self)
 {
   struct os_count_struct obj_count = { 0 };
-  enum mrb_vtype i;
+  mrb_int i;
   mrb_value hash;
 
   if (mrb_get_args(mrb, "|H", &hash) == 0) {
     hash = mrb_hash_new(mrb);
   }
 
-  if (!mrb_test(mrb_hash_empty_p(mrb, hash))) {
+  if (!mrb_hash_empty_p(mrb, hash)) {
     mrb_hash_clear(mrb, hash);
   }
 
   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;
     switch (i) {
 #define COUNT_TYPE(t) case (MRB_T ## t): type = mrb_symbol_value(mrb_intern_lit(mrb, #t)); break;
-      COUNT_TYPE(T_FALSE);
-      COUNT_TYPE(T_FREE);
-      COUNT_TYPE(T_TRUE);
-      COUNT_TYPE(T_FIXNUM);
-      COUNT_TYPE(T_SYMBOL);
-      COUNT_TYPE(T_UNDEF);
+      COUNT_TYPE(T_INTEGER);
       COUNT_TYPE(T_FLOAT);
       COUNT_TYPE(T_CPTR);
       COUNT_TYPE(T_OBJECT);
@@ -88,10 +93,12 @@ 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);
+      COUNT_TYPE(T_COMPLEX);
+      COUNT_TYPE(T_RATIONAL);
 #undef COUNT_TYPE
     default:
       type = mrb_fixnum_value(i); break;
@@ -104,40 +111,41 @@ 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 void
+static int
 os_each_object_cb(mrb_state *mrb, struct RBasic *obj, void *ud)
 {
   struct os_each_object_data *d = (struct os_each_object_data*)ud;
 
   /* filter dead objects */
-  if (is_dead(mrb, obj)) {
-    return;
+  if (mrb_object_dead_p(mrb, obj)) {
+    return MRB_EACH_OBJ_OK;
   }
 
   /* filter internal objects */
   switch (obj->tt) {
-  case MRB_TT_ENV:
-  case MRB_TT_ICLASS:
-    return;
+  case MRB_TT_FREE: case MRB_TT_ENV:
+  case MRB_TT_BREAK: case MRB_TT_ICLASS:
+    return MRB_EACH_OBJ_OK;
   default:
     break;
   }
 
   /* filter half baked (or internal) objects */
-  if (!obj->c) return;
+  if (!obj->c) return MRB_EACH_OBJ_OK;
 
   /* filter class kind if target module defined */
   if (d->target_module && !mrb_obj_is_kind_of(mrb, mrb_obj_value(obj), d->target_module)) {
-    return;
+    return MRB_EACH_OBJ_OK;
   }
 
   mrb_yield(mrb, d->block, mrb_obj_value(obj));
   ++d->count;
+  return MRB_EACH_OBJ_OK;
 }
 
 /*
@@ -157,16 +165,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);
-
-  if (mrb_nil_p(d.block)) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "Expected block in ObjectSpace.each_object.");
-  }
-
-  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);
 }
diff --git a/mrbgems/mruby-objectspace/test/objectspace.rb b/mrbgems/mruby-objectspace/test/objectspace.rb
index 4731d53b5..9c44c2157 100644
--- a/mrbgems/mruby-objectspace/test/objectspace.rb
+++ b/mrbgems/mruby-objectspace/test/objectspace.rb
@@ -1,6 +1,6 @@
 assert('ObjectSpace.count_objects') do
   h = {}
-  f = Fiber.new {} if Object.const_defined? :Fiber
+  f = Fiber.new {} if Object.const_defined?(:Fiber)
   ObjectSpace.count_objects(h)
   assert_kind_of(Hash, h)
   assert_true(h.keys.all? {|x| x.is_a?(Symbol) || x.is_a?(Integer) })
@@ -31,8 +31,8 @@ assert('ObjectSpace.count_objects') do
   1000.times do
     objs << {}
   end
-  objs = nil
   ObjectSpace.count_objects(h)
+  objs = nil
   GC.start
   ObjectSpace.count_objects(h_after)
 
@@ -56,5 +56,5 @@ assert('ObjectSpace.each_object') do
 end
 
 assert 'Check class pointer of ObjectSpace.each_object.' do
-  ObjectSpace.each_object { |obj| !obj }
+  assert_nothing_raised { ObjectSpace.each_object { |obj| !obj } }
 end