admin/mruby-mruby
1
0
Fork 0
mirror of https://github.com/mruby/mruby synced 2026-06-08 16:11:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reorganize Integer system.

Browse Source 
- 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()`
This commit is contained in:
Yukihiro "Matz" Matsumoto
2020-08-26 17:53:04 +09:00
parent 2bb84f1f1a
commit 2b188ed8a1
35 changed files with 426 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/array.c
+3 -3
View File
@@ -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
+1 -1
View File
@@ -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
+34 -15
View File
@@ -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
+3 -3
View File
@@ -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
+179 -152
View File
@@ -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
+7 -7
View File
@@ -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
+2 -2
View File
@@ -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
+6 -6
View File
@@ -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
+19 -19
View File
@@ -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