Reorganize Integer system.

- Integrate `Fixnum` and `Integer`
- Remove `Integral`
- `int / int -> int`
- Replace `mrb_fixnum()` to `mrb_int()`
- Replace `mrb_fixnum_value()` to `mrb_int_value()`.
- Use `mrb_integer_p()` instead of `mrb_fixnum_p()`

include/mruby.h

@@ -1329,7 +1329,7 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj);
 MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj);
 
 MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
-#define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
+#define mrb_int(mrb, val) mrb_integer(mrb_to_int(mrb, val))
 /* string type checking (contrary to the name, it doesn't convert) */
 MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val);
 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);

include/mruby/boxing_nan.h

@@ -104,7 +104,8 @@ mrb_val_union(mrb_value v)
 #define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1)
 #define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1)
 #define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1)
-#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_INT_VALUE(mrb, r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_FIXNUM_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
 #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v))
 #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
 #ifdef MRB_64BIT

include/mruby/boxing_no.h

@@ -30,6 +30,7 @@ typedef struct mrb_value {
 #define mrb_float(o)    (o).value.f
 #endif
 #define mrb_fixnum(o)   (o).value.i
+#define mrb_integer(o)  mrb_fixnum(o)
 #define mrb_symbol(o)   (o).value.sym
 #define mrb_type(o)     (o).tt
 
@@ -42,7 +43,8 @@ typedef struct mrb_value {
 #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
 #ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
 #endif

include/mruby/boxing_word.h

@@ -18,6 +18,11 @@ struct RFloat {
 };
 #endif
 
+struct RInteger {
+  MRB_OBJECT_HEADER;
+  mrb_int i;
+};
+
 enum mrb_special_consts {
   MRB_Qnil    =  0,
   MRB_Qfalse  =  4,
@@ -82,6 +87,7 @@ union mrb_value_ {
 #ifndef MRB_NO_FLOAT
   struct RFloat *fp;
 #endif
+  struct RInteger *ip;
   struct RCptr *vp;
   uintptr_t w;
 };
@@ -98,6 +104,9 @@ MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
 #ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #endif
+MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int);
+
+#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
 
 #define mrb_ptr(o)     mrb_val_union(o).p
 #define mrb_cptr(o)    mrb_val_union(o).vp->p
@@ -105,6 +114,12 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #define mrb_float(o)   mrb_val_union(o).fp->f
 #endif
 #define mrb_fixnum(o)  BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int)
+MRB_INLINE mrb_int
+mrb_integer_func(mrb_value o) {
+  if (mrb_immediate_p(o)) return mrb_fixnum(o);
+  return mrb_val_union(o).ip->i;
+}
+#define mrb_integer(o) mrb_integer_func(o)
 #ifdef MRB_64BIT
 #define mrb_symbol(o)  mrb_val_union(o).sym
 #else
@@ -112,8 +127,8 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #endif
 #define mrb_bool(o)    (((o) & ~(unsigned long)MRB_Qfalse) != 0)
 
-#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
 #define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM)
+#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER))
 #ifdef MRB_64BIT
 #define mrb_symbol_p(o) (mrb_val_union(o).sym_flag == BOXWORD_SYMBOL_FLAG)
 #else
@@ -154,7 +169,8 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 #define SET_FALSE_VALUE(r) ((r) = MRB_Qfalse)
 #define SET_TRUE_VALUE(r) ((r) = MRB_Qtrue)
 #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
-#define SET_INT_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n))
+#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
 #ifdef MRB_64BIT
 #define SET_SYM_VALUE(r,v) do {\
   union mrb_value_ mrb_value_union_variable;\

include/mruby/numeric.h

@@ -16,8 +16,8 @@
  */
 MRB_BEGIN_DECL
 
-#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
-#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
 #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
@@ -39,7 +39,6 @@ MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
 MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f);
 MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
-MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f);
 #endif
 
 MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);

include/mruby/value.h

@@ -54,16 +54,20 @@ struct mrb_state;
 #if defined(MRB_INT64)
   typedef int64_t mrb_int;
 # define MRB_INT_BIT 64
-# define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT64_MIN
+# define MRB_INT_MAX INT64_MAX
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo64
 # define MRB_PRId PRId64
 # define MRB_PRIx PRIx64
 #else
   typedef int32_t mrb_int;
 # define MRB_INT_BIT 32
-# define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT32_MIN
+# define MRB_INT_MAX INT32_MAX
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo32
 # define MRB_PRId PRId32
 # define MRB_PRIx PRIx32
@@ -180,8 +184,11 @@ struct RCptr {
 #ifndef mrb_immediate_p
 #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE)
 #endif
+#ifndef mrb_integer_p
+#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#endif
 #ifndef mrb_fixnum_p
-#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#define mrb_fixnum_p(o) mrb_integer_p(o)
 #endif
 #ifndef mrb_symbol_p
 #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
@@ -287,14 +294,19 @@ mrb_cptr_value(struct mrb_state *mrb, void *p)
 }
 
 /**
- * Returns a fixnum in Ruby.
- *
- * Takes an integer and boxes it into an mrb_value
+ * Returns an integer in Ruby.
  */
+MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i)
+{
+  mrb_value v;
+  SET_INT_VALUE(mrb, v, i);
+  return v;
+}
+
 MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
 {
   mrb_value v;
-  SET_INT_VALUE(v, i);
+  SET_FIXNUM_VALUE(v, i);
   return v;
 }
 

mrbgems/mruby-compiler/core/codegen.c

@@ -545,7 +545,7 @@ new_lit(codegen_scope *s, mrb_value val)
 #endif
   case MRB_TT_INTEGER:
     for (i=0; i<s->irep->plen; i++) {
-      mrb_int v = mrb_fixnum(val);
+      mrb_int v = mrb_integer(val);
       pv = &s->pool[i];
       if (pv->tt == IREP_TT_INT32) {
         if (v == pv->u.i32) return i;
@@ -597,10 +597,10 @@ new_lit(codegen_scope *s, mrb_value val)
   case MRB_TT_INTEGER:
 #ifdef MRB_INT64
     pv->tt = IREP_TT_INT64;
-    pv->u.i64 = mrb_fixnum(val);
+    pv->u.i64 = mrb_integer(val);
 #else
     pv->tt = IREP_TT_INT32;
-    pv->u.i32 = mrb_fixnum(val);
+    pv->u.i32 = mrb_integer(val);
 #endif
     break;
 

mrbgems/mruby-enumerator/test/enumerator.rb

@@ -445,7 +445,7 @@ assert 'modifying existing methods' do
   }
 end
 
-assert 'Integral#times' do
+assert 'Integer#times' do
   a = 3
   b = a.times
   c = []

mrbgems/mruby-inline-struct/test/inline.c

@@ -10,7 +10,7 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self)
   mrb_int size = mrb_istruct_size();
   mrb_value object = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(object)) {
+  if (mrb_integer_p(object)) {
     strncpy(string, "fixnum", size-1);
   }
 #ifndef MRB_NO_FLOAT

mrbgems/mruby-io/src/io.c

@@ -339,7 +339,7 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
     case MRB_TT_DATA: /* IO */
       return mrb_io_fileno(mrb, opt);
     case MRB_TT_INTEGER:
-      return (int)mrb_fixnum(opt);
+      return (int)mrb_integer(opt);
     default:
       mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
       break;
@@ -1077,7 +1077,7 @@ time2timeval(mrb_state *mrb, mrb_value time)
 
   switch (mrb_type(time)) {
     case MRB_TT_INTEGER:
-      t.tv_sec = (ftime_t)mrb_fixnum(time);
+      t.tv_sec = (ftime_t)mrb_integer(time);
       t.tv_usec = 0;
       break;
 

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

@@ -53,7 +53,7 @@ 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));

mrbgems/mruby-pack/src/pack.c

@@ -143,7 +143,7 @@ static int
 pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
 {
   str = str_len_ensure(mrb, str, sidx + 1);
-  RSTRING_PTR(str)[sidx] = (char)mrb_fixnum(o);
+  RSTRING_PTR(str)[sidx] = (char)mrb_integer(o);
   return 1;
 }
 
@@ -163,7 +163,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint16_t n;
 
   str = str_len_ensure(mrb, str, sidx + 2);
-  n = (uint16_t)mrb_fixnum(o);
+  n = (uint16_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = n % 256;
     RSTRING_PTR(str)[sidx+1] = n / 256;
@@ -197,7 +197,7 @@ pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint32_t n;
 
   str = str_len_ensure(mrb, str, sidx + 4);
-  n = (uint32_t)mrb_fixnum(o);
+  n = (uint32_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -313,7 +313,7 @@ pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint64_t n;
 
   str = str_len_ensure(mrb, str, sidx + 8);
-  n = (uint64_t)mrb_fixnum(o);
+  n = (uint64_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -560,7 +560,7 @@ pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count,
   int len = 0;
   uint32_t c = 0;
 
-  c = (uint32_t)mrb_fixnum(o);
+  c = (uint32_t)mrb_integer(o);
 
   /* Unicode character */
   /* from mruby-compiler gem */

mrbgems/mruby-random/src/random.c

@@ -93,7 +93,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 {
   mrb_value value;
 
-  if (mrb_fixnum(max) == 0) {
+  if (mrb_integer(max) == 0) {
 #ifndef MRB_NO_FLOAT
     value = mrb_float_value(mrb, rand_real(t));
 #else
@@ -101,7 +101,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 #endif
   }
   else {
-    value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max));
+    value = mrb_fixnum_value(rand_uint32(t) % mrb_integer(max));
   }
 
   return value;
@@ -119,7 +119,7 @@ get_opt(mrb_state* mrb)
     mrb_int i;
 
     arg = mrb_to_int(mrb, arg);
-    i = mrb_fixnum(arg);
+    i = mrb_integer(arg);
     if (i < 0) {
       arg = mrb_fixnum_value(0 - i);
     }
@@ -161,7 +161,7 @@ random_m_init(mrb_state *mrb, mrb_value self)
     rand_init(t);
   }
   else {
-    rand_seed(t, (uint32_t)mrb_fixnum(seed));
+    rand_seed(t, (uint32_t)mrb_integer(seed));
   }
 
   return self;
@@ -190,7 +190,7 @@ random_m_srand(mrb_state *mrb, mrb_value self)
     seed = (uint32_t)time(NULL) + rand_uint32(t);
   }
   else {
-    seed = (uint32_t)mrb_fixnum(sv);
+    seed = (uint32_t)mrb_integer(sv);
   }
   old_seed = rand_seed(t, seed);
 
@@ -257,7 +257,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
 
-      j = mrb_fixnum(random_rand(mrb, random, max));
+      j = mrb_integer(random_rand(mrb, random, max));
 
       tmp = ptr[i];
       ptr[i] = ptr[j];
@@ -342,7 +342,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
         r = (mrb_int)(rand_uint32(random) % len);
 
         for (j=0; j<i; j++) {
-          if (mrb_fixnum(RARRAY_PTR(result)[j]) == r) {
+          if (mrb_integer(RARRAY_PTR(result)[j]) == r) {
             goto retry;         /* retry if duplicate */
           }
         }
@@ -351,7 +351,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
       mrb_ary_push(mrb, result, mrb_fixnum_value(r));
     }
     for (i=0; i<n; i++) {
-      mrb_int idx = mrb_fixnum(RARRAY_PTR(result)[i]);
+      mrb_int idx = mrb_integer(RARRAY_PTR(result)[i]);
       mrb_value elem = RARRAY_PTR(ary)[idx];
       mrb_ary_set(mrb, result, i, elem);
     }

mrbgems/mruby-range-ext/src/range.c

@@ -109,8 +109,8 @@ range_size(mrb_state *mrb, mrb_value range)
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
   excl = RANGE_EXCL(r);
-  if (mrb_fixnum_p(beg)) {
-    beg_f = (mrb_float)mrb_fixnum(beg);
+  if (mrb_integer_p(beg)) {
+    beg_f = (mrb_float)mrb_integer(beg);
   }
   else if (mrb_float_p(beg)) {
     beg_f = mrb_float(beg);
@@ -118,8 +118,8 @@ range_size(mrb_state *mrb, mrb_value range)
   else {
     num_p = FALSE;
   }
-  if (mrb_fixnum_p(end)) {
-    end_f = (mrb_float)mrb_fixnum(end);
+  if (mrb_integer_p(end)) {
+    end_f = (mrb_float)mrb_integer(end);
   }
   else if (mrb_float_p(end)) {
     end_f = mrb_float(end);
@@ -161,9 +161,9 @@ range_size(mrb_state *mrb, mrb_value range)
   end = RANGE_END(r);
   excl = RANGE_EXCL(r) ? 0 : 1;
 
-  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
-    mrb_int a = mrb_fixnum(beg);
-    mrb_int b = mrb_fixnum(end);
+  if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+    mrb_int a = mrb_integer(beg);
+    mrb_int b = mrb_integer(end);
     mrb_int c = b - a + excl;
 
     return mrb_fixnum_value(c);

mrbgems/mruby-rational/mrblib/rational.rb

@@ -48,11 +48,11 @@ class Rational < Numeric
   end
 
   def <=>(rhs)
-    if rhs.is_a?(Integral)
+    case rhs
+    when Integer, Float
       return numerator <=> rhs if denominator == 1
       rhs = Rational(rhs)
     end
-
     case rhs
     when Rational
       (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
@@ -65,14 +65,13 @@ class Rational < Numeric
 
   def ==(rhs)
     return true if self.equal?(rhs)
-    if rhs.is_a?(Integral) && denominator == 1
-      return numerator == rhs
-    end
-    if rhs.is_a?(Rational)
-      numerator * rhs.denominator == denominator * rhs.numerator
-    else
-      rhs == self
+    case rhs
+    when Integer, Float
+      return numerator == rhs if denominator == 1
+    when Rational
+      return numerator * rhs.denominator == denominator * rhs.numerator
     end
+    rhs == self
   end
 end
 

mrbgems/mruby-rational/src/rational.c

@@ -102,11 +102,11 @@ rational_s_new(mrb_state *mrb, mrb_value self)
   mrb_value numv, denomv;
 
   mrb_get_args(mrb, "oo", &numv, &denomv);
-  if (mrb_fixnum_p(numv)) {
-    numerator = mrb_fixnum(numv);
+  if (mrb_integer_p(numv)) {
+    numerator = mrb_integer(numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
       mrb_float denomf = mrb_to_flo(mrb, denomv);
@@ -118,8 +118,8 @@ rational_s_new(mrb_state *mrb, mrb_value self)
   else {
     mrb_float numf = mrb_to_flo(mrb, numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
       mrb_float denomf = mrb_to_flo(mrb, denomv);
@@ -176,7 +176,7 @@ rational_negative_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 fix_to_r(mrb_state *mrb, mrb_value self)
 {
-  return rational_new(mrb, mrb_fixnum(self), 1);
+  return rational_new(mrb, mrb_integer(self), 1);
 }
 
 void mrb_mruby_rational_gem_init(mrb_state *mrb)

mrbgems/mruby-socket/src/socket.c

@@ -140,7 +140,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
 
   if (mrb_string_p(service)) {
     servname = RSTRING_CSTR(mrb, service);
-  } else if (mrb_fixnum_p(service)) {
+  } else if (mrb_integer_p(service)) {
     servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10));
   } else if (mrb_nil_p(service)) {
     servname = NULL;
@@ -151,16 +151,16 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
   memset(&hints, 0, sizeof(hints));
   hints.ai_flags = (int)flags;
 
-  if (mrb_fixnum_p(family)) {
-    hints.ai_family = (int)mrb_fixnum(family);
+  if (mrb_integer_p(family)) {
+    hints.ai_family = (int)mrb_integer(family);
   }
 
-  if (mrb_fixnum_p(socktype)) {
-    hints.ai_socktype = (int)mrb_fixnum(socktype);
+  if (mrb_integer_p(socktype)) {
+    hints.ai_socktype = (int)mrb_integer(socktype);
   }
 
-  if (mrb_fixnum_p(protocol)) {
-    hints.ai_protocol = (int)mrb_fixnum(protocol);
+  if (mrb_integer_p(protocol)) {
+    hints.ai_protocol = (int)mrb_integer(protocol);
   }
 
   lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai));
@@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
 static int
 socket_fd(mrb_state *mrb, mrb_value sock)
 {
-  return (int)mrb_fixnum(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
+  return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
 }
 
 static int
@@ -449,21 +449,21 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
 
   argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
   if (argc == 3) {
-    if (!mrb_fixnum_p(so)) {
+    if (!mrb_integer_p(so)) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
     }
-    level = mrb_fixnum(so);
+    level = mrb_integer(so);
     if (mrb_string_p(optval)) {
       /* that's good */
     } else if (mrb_true_p(optval) || mrb_false_p(optval)) {
       mrb_int i = mrb_test(optval) ? 1 : 0;
       optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
-    } else if (mrb_fixnum_p(optval)) {
+    } else if (mrb_integer_p(optval)) {
       if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
-        char uc = (char)mrb_fixnum(optval);
+        char uc = (char)mrb_integer(optval);
         optval = mrb_str_new(mrb, &uc, sizeof(uc));
       } else {
-        mrb_int i = mrb_fixnum(optval);
+        mrb_int i = mrb_integer(optval);
         optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
       }
     } else {
@@ -472,8 +472,8 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
   } else if (argc == 1) {
     if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
       mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
-    level = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
-    optname = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
+    level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
+    optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
     optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0);
   } else {
     mrb_argnum_error(mrb, argc, 3, 3);

mrbgems/mruby-sprintf/src/sprintf.c

@@ -74,7 +74,7 @@ static mrb_value
 mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 {
   char buf[66], *b = buf + sizeof buf;
-  mrb_int num = mrb_fixnum(x);
+  mrb_int num = mrb_integer(x);
   uint64_t val = (uint64_t)num;
   char d;
 
@@ -764,8 +764,8 @@ retry:
             mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
           }
         }
-        else if (mrb_fixnum_p(val)) {
-          mrb_int n = mrb_fixnum(val);
+        else if (mrb_integer_p(val)) {
+          mrb_int n = mrb_integer(val);
 #ifndef MRB_UTF8_STRING
           char buf[1];
 
@@ -882,14 +882,14 @@ retry:
 #ifndef MRB_NO_FLOAT
           case MRB_TT_FLOAT:
             val = mrb_flo_to_fixnum(mrb, val);
-            if (mrb_fixnum_p(val)) goto bin_retry;
+            if (mrb_integer_p(val)) goto bin_retry;
             break;
 #endif
           case MRB_TT_STRING:
             val = mrb_str_to_inum(mrb, val, 0, TRUE);
             goto bin_retry;
           case MRB_TT_INTEGER:
-            v = mrb_fixnum(val);
+            v = mrb_integer(val);
             break;
           default:
             val = mrb_Integer(mrb, val);

mrbgems/mruby-string-ext/src/string.c

@@ -166,7 +166,7 @@ mrb_str_concat_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value str = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(str) || mrb_float_p(str))
+  if (mrb_integer_p(str) || mrb_float_p(str))
 #ifdef MRB_UTF8_STRING
     str = int_chr_utf8(mrb, str);
 #else
@@ -1231,7 +1231,7 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, s, "__lines",         mrb_str_lines,           MRB_ARGS_NONE());
 
-  mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, mrb_class_get(mrb, "Integer"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
 }
 
 void

mrbgems/mruby-struct/src/struct.c

@@ -113,7 +113,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_struct_ref(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr = RSTRUCT_PTR(obj);
 
   if (!ptr) return mrb_nil_value();
@@ -152,7 +152,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
 static mrb_value
 mrb_struct_set_m(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr;
   mrb_value val = mrb_get_arg1(mrb);
 

mrbgems/mruby-test/driver.c

@@ -252,9 +252,9 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
 #define TEST_COUNT_PASS(name)                                           \
   do {                                                                  \
     res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name));  \
-    if (mrb_fixnum_p(res_src)) {                                        \
+    if (mrb_integer_p(res_src)) {                                       \
       mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \
-      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \
+      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_integer(res_dst) + mrb_integer(res_src))); \
     }                                                                   \
   } while (FALSE)                                                       \
 

mrbgems/mruby-time/src/time.c

@@ -218,11 +218,15 @@ typedef mrb_int mrb_sec;
                     (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
 )
 
+/* return true if time_t is fit in mrb_int */
 static mrb_bool
 fixable_time_t_p(time_t v)
 {
   if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE;
-  return FIXABLE(v);
+  if (v > (time_t)MRB_INT_MAX) return FALSE;
+  if (MRB_TIME_T_UINT) return TRUE;
+  if (MRB_INT_MIN > (mrb_int)v) return FALSE;
+  return TRUE;
 }
 
 static time_t
@@ -880,11 +884,6 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   tm = time_get_ptr(mrb, self);
-#ifndef MRB_NO_FLOAT
-  if (!fixable_time_t_p(tm->usec)) {
-    return mrb_float_value(mrb, (mrb_float)tm->usec);
-  }
-#endif
   return mrb_fixnum_value((mrb_int)tm->usec);
 }
 

mrblib/numeric.rb

@@ -34,11 +34,11 @@ class Numeric
 end
 
 ##
-# Integral
+# Integer
 #
-# mruby special - module to share methods between Floats and Integers
-#                 to make them compatible
-module Integral
+# ISO 15.2.8
+##
+class Integer
   ##
   # Calls the given block once for each Integer
   # from +self+ downto +num+.
@@ -125,14 +125,7 @@ module Integral
     end
     self
   end
-end
 
-##
-# Integer
-#
-# ISO 15.2.8
-class Integer
-  include Integral
   ##
   # Returns the receiver simply.
   #
@@ -161,3 +154,35 @@ class Integer
   # ISO 15.2.8.3.26
   alias truncate floor
 end
+
+class Float
+  ##
+  # Calls the given block from +self+ to +num+
+  # incremented by +step+ (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = self
+    if num == self || step.infinite?
+      block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+    elsif num == nil
+      while true
+        block.call(i)
+        i += step
+      end
+    elsif step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end

src/array.c

@@ -822,8 +822,8 @@ mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len)
 static mrb_int
 aget_index(mrb_state *mrb, mrb_value index)
 {
-  if (mrb_fixnum_p(index)) {
-    return mrb_fixnum(index);
+  if (mrb_integer_p(index)) {
+    return mrb_integer(index);
   }
 #ifndef MRB_NO_FLOAT
   else if (mrb_float_p(index)) {
@@ -886,7 +886,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
         return mrb_nil_value();
       }
     case MRB_TT_INTEGER:
-      return mrb_ary_ref(mrb, self, mrb_fixnum(index));
+      return mrb_ary_ref(mrb, self, mrb_integer(index));
     default:
       return mrb_ary_ref(mrb, self, aget_index(mrb, index));
     }

src/class.c

@@ -913,7 +913,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_int*);
         if (i < argc) {
-          *p = mrb_fixnum(mrb_to_int(mrb, argv[i++]));
+          *p = mrb_integer(mrb_to_int(mrb, argv[i++]));
         }
       }
       break;

src/etc.c

@@ -8,6 +8,7 @@
 #include <mruby/string.h>
 #include <mruby/data.h>
 #include <mruby/class.h>
+#include <mruby/numeric.h>
 
 MRB_API struct RData*
 mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb_data_type *type)
@@ -69,21 +70,11 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name)
   return 0;  /* not reached */
 }
 
-MRB_API mrb_int
-#ifdef MRB_NO_FLOAT
-mrb_fixnum_id(mrb_int f)
-#else
-mrb_float_id(mrb_float f)
-#endif
+static mrb_int
+make_num_id(const char *p, size_t len)
 {
-  const char *p = (const char*)&f;
-  int len = sizeof(f);
   uint32_t id = 0;
 
-#ifndef MRB_NO_FLOAT
-  /* normalize -0.0 to 0.0 */
-  if (f == 0) f = 0.0;
-#endif
   while (len--) {
     id = id*65599 + *p;
     p++;
@@ -93,6 +84,22 @@ mrb_float_id(mrb_float f)
   return (mrb_int)id;
 }
 
+MRB_API mrb_int
+mrb_int_id(mrb_int n)
+{
+  return make_num_id((const char*)&n, sizeof(n));
+}
+
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_int
+mrb_float_id(mrb_float f)
+{
+  /* normalize -0.0 to 0.0 */
+  if (f == 0) f = 0.0;
+  return make_num_id((const char*)&f, sizeof(f));
+}
+#endif
+
 MRB_API mrb_int
 mrb_obj_id(mrb_value obj)
 {
@@ -115,10 +122,8 @@ mrb_obj_id(mrb_value obj)
   case MRB_TT_SYMBOL:
     return MakeID(mrb_symbol(obj));
   case MRB_TT_INTEGER:
+    return MakeID(mrb_int_id(mrb_integer(obj)));
 #ifdef MRB_NO_FLOAT
-    return MakeID(mrb_fixnum_id(mrb_fixnum(obj)));
-#else
-    return MakeID2(mrb_float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT);
   case MRB_TT_FLOAT:
     return MakeID(mrb_float_id(mrb_float(obj)));
 #endif
@@ -159,6 +164,20 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f)
   return v.w;
 }
 #endif  /* MRB_NO_FLOAT */
+
+MRB_API mrb_value
+mrb_word_boxing_int_value(mrb_state *mrb, mrb_int n)
+{
+  if (FIXABLE(n)) return mrb_fixnum_value(n);
+  else {
+    union mrb_value_ v;
+
+    v.p = mrb_obj_alloc(mrb, MRB_TT_INTEGER, mrb->integer_class);
+    v.ip->i = n;
+    MRB_SET_FROZEN_FLAG(v.ip);
+    return v.w;
+  }
+}
 #endif  /* MRB_WORD_BOXING */
 
 #if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT))

src/hash.c

@@ -73,7 +73,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key)
 
   default:
     hv = mrb_funcall_id(mrb, key, MRB_SYM(hash), 0);
-    h = (size_t)tt ^ (size_t)mrb_fixnum(hv);
+    h = (size_t)tt ^ (size_t)mrb_integer(hv);
     break;
   }
   if (index && (index != t->index || capa != index->capa)) {
@@ -96,8 +96,8 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b)
     return mrb_symbol(a) == mrb_symbol(b);
 
   case MRB_TT_INTEGER:
-    if (!mrb_fixnum_p(b)) return FALSE;
-    return mrb_fixnum(a) == mrb_fixnum(b);
+    if (!mrb_integer_p(b)) return FALSE;
+    return mrb_integer(a) == mrb_integer(b);
 
 #ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:

src/numeric.c

@@ -36,7 +36,7 @@ mrb_to_flo(mrb_state *mrb, mrb_value val)
 {
   switch (mrb_type(val)) {
   case MRB_TT_INTEGER:
-    return (mrb_float)mrb_fixnum(val);
+    return (mrb_float)mrb_integer(val);
   case MRB_TT_FLOAT:
     break;
   default:
@@ -44,15 +44,6 @@ mrb_to_flo(mrb_state *mrb, mrb_value val)
   }
   return mrb_float(val);
 }
-
-MRB_API mrb_value
-mrb_int_value(mrb_state *mrb, mrb_float f)
-{
-  if (FIXABLE_FLOAT(f)) {
-    return mrb_fixnum_value((mrb_int)f);
-  }
-  return mrb_float_value(mrb, f);
-}
 #endif
 
 /*
@@ -65,67 +56,48 @@ mrb_int_value(mrb_state *mrb, mrb_float f)
  *    2.0**3      #=> 8.0
  */
 static mrb_value
-integral_pow(mrb_state *mrb, mrb_value x)
+int_pow(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y = mrb_get_arg1(mrb);
+  mrb_int base = mrb_int(mrb, x);
+  mrb_int exp;
 #ifndef MRB_NO_FLOAT
-  mrb_float d;
-#endif
+  mrb_value y;
+  mrb_float z;
 
-  if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
-    /* try ipow() */
-    mrb_int base = mrb_fixnum(x);
-    mrb_int exp = mrb_fixnum(y);
-    mrb_int result = 1;
-
-    if (exp < 0)
-#ifdef MRB_NO_FLOAT
-      return mrb_fixnum_value(0);
+  mrb_get_args(mrb, "o", &y);
+  if (!mrb_integer_p(y)) {
+    mrb_get_args(mrb, "f", &z);
+    z = pow((mrb_float)base, z);
+    return mrb_float_value(mrb, z);
+  }
+  else {
+    mrb_get_args(mrb, "i", &exp);
+    z = pow((double)base, (double)exp);
+    if (exp < 0 || z < (mrb_float)MRB_INT_MIN || (mrb_float)MRB_INT_MAX < z) {
+      return mrb_float_value(mrb, z);
+    }
+  }
+  return mrb_int_value(mrb, (mrb_int)z);
 #else
-      goto float_pow;
-#endif
-    for (;;) {
-      if (exp & 1) {
-        if (mrb_int_mul_overflow(result, base, &result)) {
-#ifndef MRB_NO_FLOAT
-          goto float_pow;
-#endif
-        }
-      }
-      exp >>= 1;
-      if (exp == 0) break;
-      if (mrb_int_mul_overflow(base, base, &base)) {
-#ifndef MRB_NO_FLOAT
-        goto float_pow;
-#endif
+  mrb_int result = 1;
+
+  mrb_get_args(mrb, "i", &exp);
+  if (exp < 0) {
+    return mrb_fixnum_value(0);
+  }
+  for (;;) {
+    if (exp & 1) {
+      if (mrb_int_mul_overflow(result, base, &result)) {
+        mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
       }
     }
-    return mrb_fixnum_value(result);
+    exp >>= 1;
+    if (exp == 0) break;
+    if (mrb_int_mul_overflow(base, base, &base)) {
+      mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
+    }
   }
-#ifdef MRB_NO_FLOAT
-  mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
-#else
- float_pow:
-  d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
-  return mrb_float_value(mrb, d);
-#endif
-}
-
-static mrb_value
-integral_idiv(mrb_state *mrb, mrb_value x)
-{
-#ifdef MRB_NO_FLOAT
-  mrb_value y = mrb_get_arg1(mrb);
-
-  if (!mrb_fixnum_p(y)) {
-    mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
-  }
-  return mrb_fixnum_value(mrb_fixnum(x) / mrb_fixnum(y));
-#else
-  mrb_float y;
-
-  mrb_get_args(mrb, "f", &y);
-  return mrb_int_value(mrb, mrb_to_flo(mrb, x) / y);
+  return mrb_int_value(mrb, result);
 #endif
 }
 
@@ -133,13 +105,36 @@ integral_idiv(mrb_state *mrb, mrb_value x)
 /* 15.2.9.3.4  */
 /*
  * call-seq:
- *   num / other  ->  num
+ *   int / other  ->  int
  *
  * Performs division: the class of the resulting object depends on
  * the class of <code>num</code> and on the magnitude of the
  * result.
  */
 
+static mrb_value
+int_div(mrb_state *mrb, mrb_value xv)
+{
+#ifndef MRB_NO_FLOAT
+  mrb_value yv;
+
+  mrb_get_args(mrb, "o", &yv);
+  if (mrb_float_p(yv)) {
+    return mrb_fixnum_value((mrb_int)((mrb_float)mrb_integer(xv)/mrb_float(yv)));
+  }
+  else
+#endif
+  {
+    mrb_int y;
+
+    mrb_get_args(mrb, "i", &y);
+    if (y == 0) {
+      mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero");
+    }
+    return mrb_fixnum_value(mrb_integer(xv) / y);
+  }
+}
+
 /* 15.2.9.3.19(x) */
 /*
  *  call-seq:
@@ -149,7 +144,7 @@ integral_idiv(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-integral_div(mrb_state *mrb, mrb_value xv)
+int_quo(mrb_state *mrb, mrb_value xv)
 {
 #ifdef MRB_NO_FLOAT
   mrb_int y;
@@ -160,25 +155,15 @@ integral_div(mrb_state *mrb, mrb_value xv)
   }
   return mrb_fixnum_value(mrb_fixnum(xv) / y);
 #else
-  mrb_float x, y;
+  mrb_float y;
 
   mrb_get_args(mrb, "f", &y);
-  x = mrb_to_flo(mrb, xv);
-  if (y == 0) {
-    if (x < 0)
-      y = -INFINITY;
-    else if (x > 0)
-      y = INFINITY;
-    else /* if (x == 0) */
-      y = NAN;
-    return mrb_float_value(mrb, y);
-  }
-  return mrb_float_value(mrb, x / y);
+  return mrb_float_value(mrb, (mrb_float)mrb_integer(xv) / y);
 #endif
 }
 
 static mrb_value
-integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
+coerce_step_counter(mrb_state *mrb, mrb_value self)
 {
   mrb_value num, step;
 
@@ -203,6 +188,42 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
  *  representation.
  */
 
+static mrb_value
+flo_pow(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  mrb_float d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
+  return mrb_float_value(mrb, d);
+}
+
+static mrb_value
+flo_idiv(mrb_state *mrb, mrb_value x)
+{
+  mrb_float y;
+
+  mrb_get_args(mrb, "f", &y);
+  return mrb_int_value(mrb, (mrb_int)(mrb_to_flo(mrb, x) / y));
+}
+
+static mrb_value
+flo_div(mrb_state *mrb, mrb_value xv)
+{
+  mrb_float x, y;
+
+  mrb_get_args(mrb, "f", &y);
+  x = mrb_float(xv);
+  if (y == 0) {
+    if (x < 0)
+      y = -INFINITY;
+    else if (x > 0)
+      y = INFINITY;
+    else /* if (x == 0) */
+      y = NAN;
+    return mrb_float_value(mrb, y);
+  }
+  return mrb_float_value(mrb, x / y);
+}
+
 static mrb_value
 flo_to_str(mrb_state *mrb, mrb_value flt, mrb_bool add_dot_zero)
 {
@@ -417,8 +438,8 @@ int_eql(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
-  if (!mrb_fixnum_p(y)) return mrb_false_value();
-  return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
+  if (!mrb_integer_p(y)) return mrb_false_value();
+  return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
 }
 
 #ifndef MRB_NO_FLOAT
@@ -451,7 +472,7 @@ flo_eq(mrb_state *mrb, mrb_value x)
 
   switch (mrb_type(y)) {
   case MRB_TT_INTEGER:
-    return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y));
+    return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
   case MRB_TT_FLOAT:
     return mrb_bool_value(mrb_float(x) == mrb_float(y));
   default:
@@ -464,7 +485,7 @@ value_int64(mrb_state *mrb, mrb_value x)
 {
   switch (mrb_type(x)) {
   case MRB_TT_INTEGER:
-    return (int64_t)mrb_fixnum(x);
+    return (int64_t)mrb_integer(x);
   case MRB_TT_FLOAT:
     return (int64_t)mrb_float(x);
   default:
@@ -560,7 +581,7 @@ flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
       val *= 2;
     }
   }
-  return mrb_int_value(mrb, val);
+  return mrb_int_value(mrb, (mrb_int)val);
 }
 
 static mrb_value
@@ -666,7 +687,7 @@ flo_floor(mrb_state *mrb, mrb_value num)
   mrb_float f = floor(mrb_float(num));
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 /* 15.2.9.3.8  */
@@ -689,7 +710,7 @@ flo_ceil(mrb_state *mrb, mrb_value num)
   mrb_float f = ceil(mrb_float(num));
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 /* 15.2.9.3.12 */
@@ -771,7 +792,7 @@ flo_round(mrb_state *mrb, mrb_value num)
     if (!isfinite(number)) return num;
     return mrb_float_value(mrb, number);
   }
-  return mrb_int_value(mrb, number);
+  return mrb_int_value(mrb, (mrb_int)number);
 }
 
 /* 15.2.9.3.14 */
@@ -793,7 +814,7 @@ flo_truncate(mrb_state *mrb, mrb_value num)
   if (f < 0.0) f = ceil(f);
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 static mrb_value
@@ -830,12 +851,12 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
     if (a == 0) return x;
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_mul_overflow(a, b, &c)) {
 #ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b);
@@ -853,7 +874,7 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_mul(mrb, x, y);
   }
 #ifndef MRB_NO_FLOAT
@@ -927,8 +948,8 @@ int_mod(mrb_state *mrb, mrb_value x)
   mrb_value y = mrb_get_arg1(mrb);
   mrb_int a, b;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y) && a != MRB_INT_MIN && (b=mrb_fixnum(y)) != MRB_INT_MIN) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y) && a != MRB_INT_MIN && (b=mrb_integer(y)) != MRB_INT_MIN) {
     mrb_int mod;
 
     if (b == 0) {
@@ -960,13 +981,13 @@ int_divmod(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(y)) {
+  if (mrb_integer_p(y)) {
     mrb_int div, mod;
 
-    if (mrb_fixnum(y) == 0) {
+    if (mrb_integer(y) == 0) {
       mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
     }
-    fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod);
+    fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod);
     return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod));
   }
 #ifdef MRB_NO_FLOAT
@@ -976,8 +997,8 @@ int_divmod(mrb_state *mrb, mrb_value x)
     mrb_float div, mod;
     mrb_value a, b;
 
-    flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod);
-    a = mrb_int_value(mrb, div);
+    flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_to_flo(mrb, y), &div, &mod);
+    a = mrb_int_value(mrb, (mrb_int)div);
     b = mrb_float_value(mrb, mod);
     return mrb_assoc_new(mrb, a, b);
   }
@@ -993,7 +1014,7 @@ flo_divmod(mrb_state *mrb, mrb_value x)
   mrb_value a, b;
 
   flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
-  a = mrb_int_value(mrb, div);
+  a = mrb_int_value(mrb, (mrb_int)div);
   b = mrb_float_value(mrb, mod);
   return mrb_assoc_new(mrb, a, b);
 }
@@ -1018,10 +1039,10 @@ int_equal(mrb_state *mrb, mrb_value x)
 
   switch (mrb_type(y)) {
   case MRB_TT_INTEGER:
-    return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
+    return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
 #ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
-    return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y));
+    return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
 #endif
   default:
     return mrb_false_value();
@@ -1042,22 +1063,22 @@ int_equal(mrb_state *mrb, mrb_value x)
 static mrb_value
 int_rev(mrb_state *mrb, mrb_value num)
 {
-  mrb_int val = mrb_fixnum(num);
+  mrb_int val = mrb_integer(num);
 
   return mrb_fixnum_value(~val);
 }
 
 #ifdef MRB_NO_FLOAT
 #define bit_op(x,y,op1,op2) do {\
-  return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
+  return mrb_fixnum_value(mrb_integer(x) op2 mrb_integer(y));\
 } while(0)
 #else
 static mrb_value flo_and(mrb_state *mrb, mrb_value x);
 static mrb_value flo_or(mrb_state *mrb, mrb_value x);
 static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
 #define bit_op(x,y,op1,op2) do {\
-  if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
-  return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_fixnum(x)));\
+  if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
+  return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_integer(x)));\
 } while(0)
 #endif
 
@@ -1188,7 +1209,7 @@ int_lshift(mrb_state *mrb, mrb_value x)
   if (width == 0) {
     return x;
   }
-  val = mrb_fixnum(x);
+  val = mrb_integer(x);
   if (val == 0) return x;
   if (width < 0) {
     return rshift(val, -width);
@@ -1213,7 +1234,7 @@ int_rshift(mrb_state *mrb, mrb_value x)
   if (width == 0) {
     return x;
   }
-  val = mrb_fixnum(x);
+  val = mrb_integer(x);
   if (val == 0) return x;
   if (width < 0) {
     return lshift(mrb, val, -width);
@@ -1234,7 +1255,7 @@ int_rshift(mrb_state *mrb, mrb_value x)
 static mrb_value
 int_to_f(mrb_state *mrb, mrb_value num)
 {
-  return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num));
+  return mrb_float_value(mrb, (mrb_float)mrb_integer(num));
 }
 
 /*
@@ -1280,12 +1301,12 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
     if (a == 0) return y;
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_add_overflow(a, b, &c)) {
 #ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b);
@@ -1303,7 +1324,7 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_plus(mrb, x, y);
   }
 #ifndef MRB_NO_FLOAT
@@ -1337,11 +1358,11 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_sub_overflow(a, b, &c)) {
 #ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b);
@@ -1359,7 +1380,7 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_minus(mrb, x, y);
   }
 #ifndef MRB_NO_FLOAT
@@ -1395,7 +1416,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
 {
   char buf[MRB_INT_BIT+1];
   char *b = buf + sizeof buf;
-  mrb_int val = mrb_fixnum(x);
+  mrb_int val = mrb_integer(x);
   mrb_value str;
 
   if (base < 2 || 36 < base) {
@@ -1458,16 +1479,16 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
 #endif
 
 #ifdef MRB_NO_FLOAT
-  x = mrb_fixnum(v1);
+  x = mrb_integer(v1);
 #else
   x = mrb_to_flo(mrb, v1);
 #endif
   switch (mrb_type(v2)) {
   case MRB_TT_INTEGER:
 #ifdef MRB_NO_FLOAT
-    y = mrb_fixnum(v2);
+    y = mrb_integer(v2);
 #else
-    y = (mrb_float)mrb_fixnum(v2);
+    y = (mrb_float)mrb_integer(v2);
 #endif
     break;
 #ifndef MRB_NO_FLOAT
@@ -1500,7 +1521,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
  *  not comparable, it returns nil instead of raising an exception.
  */
 static mrb_value
-integral_cmp(mrb_state *mrb, mrb_value self)
+num_cmp(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1517,7 +1538,7 @@ cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2)
 }
 
 static mrb_value
-integral_lt(mrb_state *mrb, mrb_value self)
+num_lt(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1529,7 +1550,7 @@ integral_lt(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_le(mrb_state *mrb, mrb_value self)
+num_le(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1541,7 +1562,7 @@ integral_le(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_gt(mrb_state *mrb, mrb_value self)
+num_gt(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1553,7 +1574,7 @@ integral_gt(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_ge(mrb_state *mrb, mrb_value self)
+num_ge(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1579,9 +1600,9 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
     return mrb_str_cmp(mrb, obj1, obj2);
   default:
     v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2);
-    if (mrb_nil_p(v) || !mrb_fixnum_p(v))
+    if (mrb_nil_p(v) || !mrb_integer_p(v))
       return -2;
-    return mrb_fixnum(v);
+    return mrb_integer(v);
   }
 }
 
@@ -1619,23 +1640,11 @@ flo_plus(mrb_state *mrb, mrb_value x)
 void
 mrb_init_numeric(mrb_state *mrb)
 {
-  struct RClass *numeric, *integer, *integral;
+  struct RClass *numeric, *integer;
 #ifndef MRB_NO_FLOAT
   struct RClass *fl;
 #endif
 
-  integral = mrb_define_module(mrb, "Integral");
-  mrb_define_method(mrb, integral,"**",       integral_pow,    MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"/",        integral_div,    MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.6  */
-  mrb_define_method(mrb, integral,"quo",      integral_div,    MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
-  mrb_define_method(mrb, integral,"div",      integral_idiv,   MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"<=>",      integral_cmp,    MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.1  */
-  mrb_define_method(mrb, integral,"<",        integral_lt,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"<=",       integral_le,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,">",        integral_gt,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,">=",       integral_ge,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"__coerce_step_counter", integral_coerce_step_counter, MRB_ARGS_REQ(2));
-
   /* Numeric Class */
   numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);                /* 15.2.7 */
   mrb_define_method(mrb, numeric, "finite?",  num_finite_p,    MRB_ARGS_NONE());
@@ -1645,13 +1654,23 @@ mrb_init_numeric(mrb_state *mrb)
   mrb->integer_class = integer = mrb_define_class(mrb, "Integer",  numeric);     /* 15.2.8 */
   MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER);
   mrb_undef_class_method(mrb, integer, "new");
+  mrb_define_method(mrb, integer, "**",       int_pow,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "/",        int_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.6  */
+  mrb_define_method(mrb, integer, "quo",      int_quo,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+  mrb_define_method(mrb, integer, "div",      int_div,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "<=>",      num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
+  mrb_define_method(mrb, integer, "<",        num_lt,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "<=",       num_le,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, ">",        num_gt,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, ">=",       num_ge,          MRB_ARGS_REQ(1));
+
   mrb_define_method(mrb, integer, "to_i",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.24 */
   mrb_define_method(mrb, integer, "to_int",   int_to_i,        MRB_ARGS_NONE());
 #ifndef MRB_NO_FLOAT
-  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.8 (x) */
-  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.10 (x) */
-  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.12 (x) */
-  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.15 (x) */
+  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.14 */
+  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.17 */
+  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.20 */
+  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.26 */
 #endif
 
   mrb_define_method(mrb, integer, "+",        int_plus,        MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
@@ -1672,6 +1691,7 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, integer, "to_s",     int_to_s,        MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
   mrb_define_method(mrb, integer, "inspect",  int_to_s,        MRB_ARGS_OPT(1));
   mrb_define_method(mrb, integer, "divmod",   int_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
+  mrb_define_method(mrb, integer, "__coerce_step_counter", coerce_step_counter, MRB_ARGS_REQ(2));
 
   /* Fixnum Class for compatibility */
   mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer));
@@ -1681,11 +1701,20 @@ mrb_init_numeric(mrb_state *mrb)
   mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric);                 /* 15.2.9 */
   MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
   mrb_undef_class_method(mrb,  fl, "new");
-  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
-  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
-  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
-  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
-  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
+  mrb_define_method(mrb, fl,      "**",        flo_pow,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "/",         flo_div,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
+  mrb_define_method(mrb, fl,      "quo",       flo_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+  mrb_define_method(mrb, fl,      "div",       flo_idiv,       MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
+  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.4  */
+  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
+  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
+  mrb_define_method(mrb, fl,      "<=>",       num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
+  mrb_define_method(mrb, fl,      "<",         num_lt,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "<=",        num_le,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      ">",         num_gt,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      ">=",        num_ge,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
   mrb_define_method(mrb, fl,      "~",         flo_rev,        MRB_ARGS_NONE());
   mrb_define_method(mrb, fl,      "&",         flo_and,        MRB_ARGS_REQ(1));
   mrb_define_method(mrb, fl,      "|",         flo_or,         MRB_ARGS_REQ(1));
@@ -1714,7 +1743,5 @@ mrb_init_numeric(mrb_state *mrb)
 #ifdef NAN
   mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN));
 #endif
-
-  mrb_include_module(mrb, fl, integral);
 #endif
 }

src/object.c

@@ -20,7 +20,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 
   case MRB_TT_FALSE:
   case MRB_TT_INTEGER:
-    return (mrb_fixnum(v1) == mrb_fixnum(v2));
+    return (mrb_integer(v1) == mrb_integer(v2));
   case MRB_TT_SYMBOL:
     return (mrb_symbol(v1) == mrb_symbol(v2));
 
@@ -49,12 +49,12 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
 #ifndef MRB_NO_FLOAT
   /* value mixing with integer and float */
-  if (mrb_fixnum_p(obj1)) {
-    if (mrb_float_p(obj2) && (mrb_float)mrb_fixnum(obj1) == mrb_float(obj2))
+  if (mrb_integer_p(obj1)) {
+    if (mrb_float_p(obj2) && (mrb_float)mrb_integer(obj1) == mrb_float(obj2))
       return TRUE;
   }
   else if (mrb_float_p(obj1)) {
-    if (mrb_fixnum_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_fixnum(obj2))
+    if (mrb_integer_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
       return TRUE;
   }
 #endif
@@ -407,7 +407,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
   if (mrb_nil_p(x)) {
     ename = "nil";
   }
-  else if (mrb_fixnum_p(x)) {
+  else if (mrb_integer_p(x)) {
     ename = "Fixnum";
   }
   else if (mrb_symbol_p(x)) {
@@ -509,7 +509,7 @@ MRB_API mrb_value
 mrb_to_int(mrb_state *mrb, mrb_value val)
 {
 
-  if (!mrb_fixnum_p(val)) {
+  if (!mrb_integer_p(val)) {
 #ifndef MRB_NO_FLOAT
     if (mrb_float_p(val)) {
       return mrb_flo_to_fixnum(mrb, val);
@@ -575,7 +575,7 @@ mrb_Float(mrb_state *mrb, mrb_value val)
   }
   switch (mrb_type(val)) {
     case MRB_TT_INTEGER:
-      return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val));
+      return mrb_float_value(mrb, (mrb_float)mrb_integer(val));
 
     case MRB_TT_FLOAT:
       return val;

src/range.c

@@ -328,8 +328,8 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
   result = mrb_ary_new(mrb);
 
   for (i = 0; i < argc; ++i) {
-    if (mrb_fixnum_p(argv[i])) {
-      mrb_ary_push(mrb, result, func(mrb, obj, mrb_fixnum(argv[i])));
+    if (mrb_integer_p(argv[i])) {
+      mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i])));
     }
     else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) {
       mrb_int const end = olen < beg + len ? olen : beg + len;

src/string.c

@@ -1155,7 +1155,7 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
   else {
     switch (mrb_type(indx)) {
       case MRB_TT_INTEGER:
-        *beg = mrb_fixnum(indx);
+        *beg = mrb_integer(indx);
         *len = 1;
         return STR_CHAR_RANGE;
 
@@ -1170,8 +1170,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
 
       default:
         indx = mrb_to_int(mrb, indx);
-        if (mrb_fixnum_p(indx)) {
-          *beg = mrb_fixnum(indx);
+        if (mrb_integer_p(indx)) {
+          *beg = mrb_integer(indx);
           *len = 1;
           return STR_CHAR_RANGE;
         }
@@ -2498,8 +2498,8 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
 
     if (!badcheck) return 0.0;
     x = mrb_str_len_to_inum(mrb, p, pend-p, 0, badcheck);
-    if (mrb_fixnum_p(x))
-      d = (double)mrb_fixnum(x);
+    if (mrb_integer_p(x))
+      d = (double)mrb_integer(x);
     else /* if (mrb_float_p(x)) */
       d = mrb_float(x);
     return d;
@@ -2874,7 +2874,7 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str)
       }
     }
     else {
-      beg = mrb_fixnum(mrb_to_int(mrb, a1));
+      beg = mrb_integer(mrb_to_int(mrb, a1));
       len = 1;
       empty = FALSE;
     }

src/vm.c

@@ -1115,12 +1115,12 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_LOADI, BB) {
-      SET_INT_VALUE(regs[a], b);
+      SET_FIXNUM_VALUE(regs[a], b);
       NEXT;
     }
 
     CASE(OP_LOADINEG, BB) {
-      SET_INT_VALUE(regs[a], -b);
+      SET_FIXNUM_VALUE(regs[a], -b);
       NEXT;
     }
 
@@ -1134,12 +1134,12 @@ RETRY_TRY_BLOCK:
     CASE(OP_LOADI_6,B) goto L_LOADI;
     CASE(OP_LOADI_7, B) {
     L_LOADI:
-      SET_INT_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
+      SET_FIXNUM_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
       NEXT;
     }
 
     CASE(OP_LOADI16, BS) {
-      SET_INT_VALUE(regs[a], (mrb_int)(int16_t)b);
+      SET_FIXNUM_VALUE(regs[a], (mrb_int)(int16_t)b);
       NEXT;
     }
 
@@ -1302,8 +1302,8 @@ RETRY_TRY_BLOCK:
       CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) {
         struct RBreak *brk = (struct RBreak*)mrb->exc;
         mrb_value target = mrb_break_value_get(brk);
-        mrb_assert(mrb_fixnum_p(target));
-        a = mrb_fixnum(target);
+        mrb_assert(mrb_integer_p(target));
+        a = mrb_integer(target);
         mrb_assert(a >= 0 && a < irep->ilen);
       }
       CHECKPOINT_MAIN(RBREAK_TAG_JUMP) {
@@ -2251,23 +2251,23 @@ RETRY_TRY_BLOCK:
     OP_MATH_CASE_STRING_##op_name();                                        \
     default:                                                                \
       c = 1;                                                                \
-      mid = MRB_QSYM(op_name);                                             \
+      mid = MRB_QSYM(op_name);                                              \
       goto L_SEND_SYM;                                                      \
   }                                                                         \
   NEXT;
 #define OP_MATH_CASE_FIXNUM(op_name)                                        \
-  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                                \
+  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
     {                                                                       \
-      mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z;        \
+      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
       if (mrb_int_##op_name##_overflow(x, y, &z))                           \
         OP_MATH_OVERFLOW_INT(op_name, x, y, z);                             \
       else                                                                  \
-        SET_INT_VALUE(regs[a], z);                                          \
+        SET_INT_VALUE(mrb,regs[a], z);                                      \
     }                                                                       \
     break
 #ifdef MRB_NO_FLOAT
 #define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0
-#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(regs[a], z)
+#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(mrb,regs[a], z)
 #else
 #define OP_MATH_CASE_FLOAT(op_name, t1, t2)                                     \
   case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
@@ -2313,8 +2313,8 @@ RETRY_TRY_BLOCK:
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
       case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):
         {
-          mrb_int x = mrb_fixnum(regs[a]);
-          mrb_int y = mrb_fixnum(regs[a+1]);
+          mrb_int x = mrb_integer(regs[a]);
+          mrb_int y = mrb_integer(regs[a+1]);
 
           
           if (y == 0) {
@@ -2341,18 +2341,18 @@ RETRY_TRY_BLOCK:
             if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
               div -= 1;
             }
-            SET_INT_VALUE(regs[a], div);
+            SET_INT_VALUE(mrb, regs[a], div);
           }
         }
         NEXT;
 #ifndef MRB_NO_FLOAT
       case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):
-        x = (mrb_float)mrb_fixnum(regs[a]);
+        x = (mrb_float)mrb_integer(regs[a]);
         y = mrb_float(regs[a+1]);
         break;
       case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):
         x = mrb_float(regs[a]);
-        y = (mrb_float)mrb_fixnum(regs[a+1]);
+        y = (mrb_float)mrb_integer(regs[a+1]);
         break;
       case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
         x = mrb_float(regs[a]);
@@ -2385,7 +2385,7 @@ RETRY_TRY_BLOCK:
     OP_MATHI_CASE_FIXNUM(op_name);                                          \
     OP_MATHI_CASE_FLOAT(op_name);                                           \
     default:                                                                \
-      SET_INT_VALUE(regs[a+1], b);                                          \
+      SET_INT_VALUE(mrb,regs[a+1], b);                                      \
       c = 1;                                                                \
       mid = MRB_QSYM(op_name);                                              \
       goto L_SEND_SYM;                                                      \
@@ -2394,11 +2394,11 @@ RETRY_TRY_BLOCK:
 #define OP_MATHI_CASE_FIXNUM(op_name)                                       \
   case MRB_TT_INTEGER:                                                      \
     {                                                                       \
-      mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z;                   \
+      mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z;                  \
       if (mrb_int_##op_name##_overflow(x, y, &z))                           \
         OP_MATH_OVERFLOW_INT(op_name, x, y, z);                             \
       else                                                                  \
-        SET_INT_VALUE(regs[a], z);                                          \
+        SET_INT_VALUE(mrb,regs[a], z);                                      \
     }                                                                       \
     break
 #ifdef MRB_NO_FLOAT

target/boxing.rb

@@ -1,14 +1,10 @@
-MRuby::Build.new do |conf|
-  toolchain :gcc
-end
-
-MRuby::Build.new('no_boxing') do |conf|
+MRuby::Build.new('no-boxing') do |conf|
   toolchain :gcc
 
+  conf.gembox 'default'
   conf.compilers.each do |c|
     c.defines += %w(MRB_NO_BOXING)
   end
-  conf.gembox 'default'
   conf.enable_test
 end
 
@@ -22,13 +18,13 @@ MRuby::Build.new('word_boxing') do |conf|
   conf.enable_test
 end
 
-MRuby::Build.new('nan_boxing') do |conf|
-  toolchain :gcc
+# MRuby::Build.new('nan_boxing') do |conf|
+#   toolchain :gcc
 
-  conf.gembox 'default'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_NAN_BOXING)
-  end
-  conf.enable_test
-end
+#   conf.gembox 'default'
+#   conf.compilers.each do |c|
+#     c.defines += %w(MRB_NAN_BOXING)
+#   end
+#   conf.enable_test
+# end
 

test/t/array.rb

@@ -372,8 +372,7 @@ end
 assert('Array#hash', '15.2.12.5.35') do
   a = [ 1, 2, 3 ]
 
-  #assert_true(a.hash.is_a? Integer)
-  assert_true(a.hash.is_a? Integral)  # mruby special
+  assert_true(a.hash.is_a? Integer)
   assert_equal([1,2].hash, [1,2].hash)
 end
 

test/t/integer.rb

@@ -14,16 +14,6 @@ assert('Integer#+', '15.2.8.3.1') do
 
   assert_raise(TypeError){ 0+nil }
   assert_raise(TypeError){ 1+nil }
-
-  c = Mrbtest::FIXNUM_MAX + 1
-  d = Mrbtest::FIXNUM_MAX.__send__(:+, 1)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MAX + 1.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#-', '15.2.8.3.2') do
@@ -32,37 +22,17 @@ assert('Integer#-', '15.2.8.3.2') do
 
   assert_equal 1, a
   assert_equal 1.0, b if Object.const_defined?(:Float)
-
-  c = Mrbtest::FIXNUM_MIN - 1
-  d = Mrbtest::FIXNUM_MIN.__send__(:-, 1)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MIN - 1.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#*', '15.2.8.3.3') do
   a = 1*1
-  b = 1*1.0 if Object.const_defined?(:Float)
-
   assert_equal 1, a
-  assert_equal 1.0, b if Object.const_defined?(:Float)
-
+  if Object.const_defined?(:Float)
+    b = 1*1.0 
+    assert_equal 1.0, b
+  end
   assert_raise(TypeError){ 0*nil }
   assert_raise(TypeError){ 1*nil }
-
-  c = Mrbtest::FIXNUM_MAX * 2
-  d = Mrbtest::FIXNUM_MAX.__send__(:*, 2)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MAX * 2.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#/', '15.2.8.3.4') do