From 00f5ddc9aeeab49d656044d14a03765bd6fdfc53 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 27 May 2020 23:24:31 +0900 Subject: Use `mrb_funcall_id()` extensively. Except for support files e.g. `mruby-test/driver.c`, which are not target of symbol collection via `rake gensym`. --- src/numeric.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index f4961928b..725960cf6 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1558,7 +1558,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) return -2; return mrb_str_cmp(mrb, obj1, obj2); default: - v = mrb_funcall(mrb, obj1, "<=>", 1, obj2); + v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2); if (mrb_nil_p(v) || !mrb_fixnum_p(v)) return -2; return mrb_fixnum(v); -- cgit v1.2.3 From 2a366ffba8397c6f848d659dce76e03e1bf05d17 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Mon, 1 Jun 2020 10:36:28 +0900 Subject: Use functions that take symbols to reduce string litrals in C. --- mrbgems/mruby-complex/src/complex.c | 4 +- mrbgems/mruby-eval/src/eval.c | 2 +- mrbgems/mruby-io/src/file.c | 58 ++++++++++++++--------------- mrbgems/mruby-io/src/io.c | 8 ++-- mrbgems/mruby-math/src/math.c | 14 +++---- mrbgems/mruby-method/src/method.c | 2 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 20 +++++----- mrbgems/mruby-object-ext/src/object.c | 2 +- mrbgems/mruby-random/src/random.c | 2 +- mrbgems/mruby-socket/src/socket.c | 8 ++-- mrbgems/mruby-struct/src/struct.c | 2 +- mrbgems/mruby-time/src/time.c | 2 +- src/class.c | 8 ++-- src/numeric.c | 4 +- 14 files changed, 68 insertions(+), 68 deletions(-) (limited to 'src/numeric.c') diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 0432da633..24dad4235 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -69,7 +69,7 @@ complex_ptr(mrb_state *mrb, mrb_value v) static mrb_value complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary) { - struct RClass *c = mrb_class_get(mrb, "Complex"); + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex)); struct mrb_complex *p; struct RBasic *comp = complex_alloc(mrb, c, &p); p->real = real; @@ -224,7 +224,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb) #ifdef COMPLEX_USE_ISTRUCT mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE); #endif - comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric")); + comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric))); #ifdef COMPLEX_USE_ISTRUCT MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT); #else diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c index af6837b81..4271954e5 100644 --- a/mrbgems/mruby-eval/src/eval.c +++ b/mrbgems/mruby-eval/src/eval.c @@ -179,7 +179,7 @@ void mrb_mruby_eval_gem_init(mrb_state* mrb) { mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3)); - mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); + mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK()); } void diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index 53ed4b69d..04dece910 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -614,36 +614,36 @@ mrb_init_file(mrb_state *mrb) mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE()); mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1)); - cnst = mrb_define_module_under(mrb, file, "Constants"); - mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH)); - mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX)); - mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN)); - mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB)); - mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR)); - mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR)); + cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN)); + mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR)); #if defined(_WIN32) || defined(_WIN64) - mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR)); #else - mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value()); + mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value()); #endif - mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE)); - - mrb_define_const(mrb, cnst, "RDONLY", mrb_fixnum_value(MRB_O_RDONLY)); - mrb_define_const(mrb, cnst, "WRONLY", mrb_fixnum_value(MRB_O_WRONLY)); - mrb_define_const(mrb, cnst, "RDWR", mrb_fixnum_value(MRB_O_RDWR)); - mrb_define_const(mrb, cnst, "APPEND", mrb_fixnum_value(MRB_O_APPEND)); - mrb_define_const(mrb, cnst, "CREAT", mrb_fixnum_value(MRB_O_CREAT)); - mrb_define_const(mrb, cnst, "EXCL", mrb_fixnum_value(MRB_O_EXCL)); - mrb_define_const(mrb, cnst, "TRUNC", mrb_fixnum_value(MRB_O_TRUNC)); - mrb_define_const(mrb, cnst, "NONBLOCK", mrb_fixnum_value(MRB_O_NONBLOCK)); - mrb_define_const(mrb, cnst, "NOCTTY", mrb_fixnum_value(MRB_O_NOCTTY)); - mrb_define_const(mrb, cnst, "BINARY", mrb_fixnum_value(MRB_O_BINARY)); - mrb_define_const(mrb, cnst, "SHARE_DELETE", mrb_fixnum_value(MRB_O_SHARE_DELETE)); - mrb_define_const(mrb, cnst, "SYNC", mrb_fixnum_value(MRB_O_SYNC)); - mrb_define_const(mrb, cnst, "DSYNC", mrb_fixnum_value(MRB_O_DSYNC)); - mrb_define_const(mrb, cnst, "RSYNC", mrb_fixnum_value(MRB_O_RSYNC)); - mrb_define_const(mrb, cnst, "NOFOLLOW", mrb_fixnum_value(MRB_O_NOFOLLOW)); - mrb_define_const(mrb, cnst, "NOATIME", mrb_fixnum_value(MRB_O_NOATIME)); - mrb_define_const(mrb, cnst, "DIRECT", mrb_fixnum_value(MRB_O_DIRECT)); - mrb_define_const(mrb, cnst, "TMPFILE", mrb_fixnum_value(MRB_O_TMPFILE)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE)); + + mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR)); + mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND)); + mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT)); + mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL)); + mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE)); + mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW)); + mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME)); + mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT)); + mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE)); } diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 608fc1623..988d19b02 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -102,10 +102,10 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int status) mrb_value v; c_status = NULL; - if (mrb_class_defined(mrb, "Process")) { - c_process = mrb_module_get(mrb, "Process"); - if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) { - c_status = mrb_class_get_under(mrb, c_process, "Status"); + if (mrb_class_defined_id(mrb, MRB_SYM(Process))) { + c_process = mrb_module_get_id(mrb, MRB_SYM(Process)); + if (mrb_const_defined(mrb, mrb_obj_value(c_process), MRB_SYM(Status))) { + c_status = mrb_class_get_under_id(mrb, c_process, MRB_SYM(Status)); } } if (c_status != NULL) { diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index 88b33771b..ff1e84684 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -16,8 +16,8 @@ static void domain_error(mrb_state *mrb, const char *func) { - struct RClass *math = mrb_module_get(mrb, "Math"); - struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError"); + struct RClass *math = mrb_module_get_id(mrb, MRB_SYM(Math)); + struct RClass *domainerror = mrb_class_get_under_id(mrb, math, MRB_SYM(DomainError)); mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func); } @@ -730,18 +730,18 @@ mrb_mruby_math_gem_init(mrb_state* mrb) struct RClass *mrb_math; mrb_math = mrb_define_module(mrb, "Math"); - mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class); + mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), mrb->eStandardError_class); #ifdef M_PI - mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI)); #else - mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0)); #endif #ifdef M_E - mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E)); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E)); #else - mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0))); + mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0))); #endif mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c index d7df381ea..c6de6a7bd 100644 --- a/mrbgems/mruby-method/src/method.c +++ b/mrbgems/mruby-method/src/method.c @@ -36,7 +36,7 @@ unbound_method_bind(mrb_state *mrb, mrb_value self) mrb_value recv = mrb_get_arg1(mrb); bind_check(mrb, recv, owner); - me = method_object_alloc(mrb, mrb_class_get(mrb, "Method")); + me = method_object_alloc(mrb, mrb_class_get_id(mrb, MRB_SYM(Method))); mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner); mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv); mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name); diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index f8aff54bc..fd7072ccd 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -60,16 +60,16 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1)); #ifndef MRB_WITHOUT_FLOAT - mrb_define_const(mrb, mrb->float_class, "RADIX", mrb_fixnum_value(MRB_FLT_RADIX)); - mrb_define_const(mrb, mrb->float_class, "MANT_DIG", mrb_fixnum_value(MRB_FLT_MANT_DIG)); - mrb_define_const(mrb, mrb->float_class, "EPSILON", mrb_float_value(mrb, MRB_FLT_EPSILON)); - mrb_define_const(mrb, mrb->float_class, "DIG", mrb_fixnum_value(MRB_FLT_DIG)); - mrb_define_const(mrb, mrb->float_class, "MIN_EXP", mrb_fixnum_value(MRB_FLT_MIN_EXP)); - mrb_define_const(mrb, mrb->float_class, "MIN", mrb_float_value(mrb, MRB_FLT_MIN)); - mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP", mrb_fixnum_value(MRB_FLT_MIN_10_EXP)); - mrb_define_const(mrb, mrb->float_class, "MAX_EXP", mrb_fixnum_value(MRB_FLT_MAX_EXP)); - mrb_define_const(mrb, mrb->float_class, "MAX", mrb_float_value(mrb, MRB_FLT_MAX)); - mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP", mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX), mrb_fixnum_value(MRB_FLT_RADIX)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG), mrb_fixnum_value(MRB_FLT_MANT_DIG)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON), mrb_float_value(mrb, MRB_FLT_EPSILON)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG), mrb_fixnum_value(MRB_FLT_DIG)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP), mrb_fixnum_value(MRB_FLT_MIN_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN), mrb_float_value(mrb, MRB_FLT_MIN)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP), mrb_fixnum_value(MRB_FLT_MIN_10_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP), mrb_fixnum_value(MRB_FLT_MAX_EXP)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX), mrb_float_value(mrb, MRB_FLT_MAX)); + mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP), mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); #endif /* MRB_WITHOUT_FLOAT */ } diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c index 31bb689f6..57361e8e2 100644 --- a/mrbgems/mruby-object-ext/src/object.c +++ b/mrbgems/mruby-object-ext/src/object.c @@ -123,7 +123,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE()); - mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK()); + mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK()); } void diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index c3a3f61b4..c91df35f3 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -135,7 +135,7 @@ get_opt(mrb_state* mrb) static void random_check(mrb_state *mrb, mrb_value random) { - struct RClass *c = mrb_class_get(mrb, "Random"); + struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random)); if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) { mrb_raise(mrb, E_TYPE_ERROR, "Random instance required"); } diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 63e2b665b..f158959a7 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -53,7 +53,7 @@ #endif #endif -#define E_SOCKET_ERROR (mrb_class_get(mrb, "SocketError")) +#define E_SOCKET_ERROR mrb_class_get_id(mrb, MRB_SYM(SocketError)) #if !defined(mrb_cptr) #define mrb_cptr_value(m,p) mrb_voidp_value((m),(p)) @@ -347,7 +347,7 @@ mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self) optlen = sizeof(opt); if (getsockopt(s, (int)level, (int)optname, opt, &optlen) == -1) mrb_sys_fail(mrb, "getsockopt"); - c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), MRB_SYM(Option)); + c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get_id(mrb, MRB_SYM(Socket))), MRB_SYM(Option)); family = socket_family(s); data = mrb_str_new(mrb, opt, optlen); return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data); @@ -869,7 +869,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE()); #endif - io = mrb_class_get(mrb, "IO"); + io = mrb_class_get_id(mrb, MRB_SYM(IO)); bsock = mrb_define_class(mrb, "BasicSocket", io); mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1)); @@ -948,7 +948,7 @@ void mrb_mruby_socket_gem_final(mrb_state* mrb) { mrb_value ai; - ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), MRB_SYM(_lastai)); + ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai)); if (mrb_cptr_p(ai)) { freeaddrinfo((struct addrinfo*)mrb_cptr(ai)); } diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index ee5ef85ae..4f50fe5dd 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -20,7 +20,7 @@ static struct RClass * struct_class(mrb_state *mrb) { - return mrb_class_get(mrb, "Struct"); + return mrb_class_get_id(mrb, MRB_SYM(Struct)); } static inline mrb_value diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 5fa700848..621fda42b 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -420,7 +420,7 @@ mrb_time_now(mrb_state *mrb, mrb_value self) MRB_API mrb_value mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone zone) { - return mrb_time_make_time(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone); + return mrb_time_make_time(mrb, mrb_class_get_id(mrb, MRB_SYM(Time)), sec, usec, zone); } /* 15.2.19.6.1 */ diff --git a/src/class.c b/src/class.c index 2bf26f659..2864fdda9 100644 --- a/src/class.c +++ b/src/class.c @@ -2353,10 +2353,10 @@ mrb_init_class(mrb_state *mrb) make_metaclass(mrb, cls); /* name basic classes */ - mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob)); - mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj)); - mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod)); - mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls)); + mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob)); + mrb_define_const_id(mrb, obj, MRB_SYM(Object), mrb_obj_value(obj)); + mrb_define_const_id(mrb, obj, MRB_SYM(Module), mrb_obj_value(mod)); + mrb_define_const_id(mrb, obj, MRB_SYM(Class), mrb_obj_value(cls)); /* name each classes */ mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject)); diff --git a/src/numeric.c b/src/numeric.c index 725960cf6..195bd40cf 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1688,10 +1688,10 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fl, "nan?", flo_nan_p, MRB_ARGS_NONE()); #ifdef INFINITY - mrb_define_const(mrb, fl, "INFINITY", mrb_float_value(mrb, INFINITY)); + mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY)); #endif #ifdef NAN - mrb_define_const(mrb, fl, "NAN", mrb_float_value(mrb, NAN)); + mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN)); #endif mrb_include_module(mrb, fl, integral); -- cgit v1.2.3 From 8a87549315d0c7fd984a8ad239ebe3dbab4d2855 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Fri, 14 Aug 2020 14:34:53 +0900 Subject: Rename float configuration option names. - `MRB_WITHOUT_FLOAT` => `MRB_NO_FLOAT` - `MRB_USE_FLOAT` => `MRB_USE_FLOAT32` The former is to use `USE_XXX` naming convention. The latter is to make sure `float` is 32bit float and not floating point number in general. --- doc/guides/mrbconf.md | 8 +-- doc/mruby3.md | 11 ++++ include/mrbconf.h | 22 ++++++-- include/mruby.h | 10 ++-- include/mruby/boxing_nan.h | 8 +-- include/mruby/boxing_no.h | 6 +- include/mruby/boxing_word.h | 12 ++-- include/mruby/class.h | 2 +- include/mruby/error.h | 4 +- include/mruby/numeric.h | 16 +++--- include/mruby/value.h | 10 ++-- mrbgems/mruby-compiler/core/codegen.c | 16 +++--- mrbgems/mruby-compiler/core/parse.y | 4 +- mrbgems/mruby-compiler/core/y.tab.c | 4 +- mrbgems/mruby-complex/src/complex.c | 8 +-- mrbgems/mruby-complex/test/complex.rb | 4 +- mrbgems/mruby-inline-struct/test/inline.c | 2 +- mrbgems/mruby-io/src/file.c | 4 +- mrbgems/mruby-io/src/io.c | 6 +- mrbgems/mruby-kernel-ext/src/kernel.c | 4 +- mrbgems/mruby-math/src/math.c | 4 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 4 +- mrbgems/mruby-object-ext/src/object.c | 4 +- mrbgems/mruby-os-memsize/src/memsize.c | 2 +- mrbgems/mruby-pack/src/pack.c | 8 +-- mrbgems/mruby-random/src/random.c | 4 +- mrbgems/mruby-range-ext/src/range.c | 4 +- mrbgems/mruby-rational/src/rational.c | 6 +- mrbgems/mruby-sleep/src/mrb_sleep.c | 2 +- mrbgems/mruby-sprintf/src/sprintf.c | 10 ++-- mrbgems/mruby-string-ext/src/string.c | 2 +- mrbgems/mruby-test/driver.c | 4 +- mrbgems/mruby-test/vformat.c | 4 +- mrbgems/mruby-time/src/time.c | 20 +++---- src/array.c | 2 +- src/class.c | 4 +- src/dump.c | 10 ++-- src/error.c | 2 +- src/etc.c | 10 ++-- src/fmt_fp.c | 2 +- src/gc.c | 6 +- src/hash.c | 8 +-- src/load.c | 6 +- src/numeric.c | 88 ++++++++++++++--------------- src/object.c | 12 ++-- src/range.c | 2 +- src/string.c | 10 ++-- src/vm.c | 16 +++--- target/RX630.rb | 2 +- tasks/gitlab.rake | 4 +- test/t/float.rb | 2 +- 51 files changed, 223 insertions(+), 202 deletions(-) (limited to 'src/numeric.c') diff --git a/doc/guides/mrbconf.md b/doc/guides/mrbconf.md index d662e05bf..c95634604 100644 --- a/doc/guides/mrbconf.md +++ b/doc/guides/mrbconf.md @@ -46,11 +46,11 @@ You can use mrbconfs with following ways: ## Primitive type configuration. -`MRB_USE_FLOAT` +`MRB_USE_FLOAT32` * When defined single precision floating point type(C type `float`) is used as `mrb_float`. -* Else double precision floating point type(C type `double`) is used as `mrb_float`. +* Otherwise double precision floating point type(C type `double`) is used as `mrb_float`. -`MRB_WITHOUT_FLOAT` +`MRB_NO_FLOAT` * When defined removes floating point numbers from mruby. * It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space". @@ -117,7 +117,7 @@ largest value of required alignment. `MRB_NAN_BOXING` * If defined represent `mrb_value` in boxed `double`. -* Conflicts with `MRB_USE_FLOAT` and `MRB_WITHOUT_FLOAT`. +* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`. `MRB_WORD_BOXING` * If defined represent `mrb_value` as a word. diff --git a/doc/mruby3.md b/doc/mruby3.md index 29da25cbc..02884f51b 100644 --- a/doc/mruby3.md +++ b/doc/mruby3.md @@ -57,6 +57,17 @@ pull-request. Some configuration macro names are changed for consistency +== `MRB_NO_FLOAT` + +Changed from `MRB_WITHOUT_FLOAT` to conform `USE_XXX` naming +convention. + +== `MRB_USE_FLOAT32` + +Changed from `MRB_USE_FLOAT` to make sure `float` here means +using single precision float, and not the opposite of +`MRB_NO_FLOAT`. + == `MRB_USE_METHOD_T_STRUCT` Changed from `MRB_METHOD_T_STRUCT`. diff --git a/include/mrbconf.h b/include/mrbconf.h index 734ec98e7..159aee48f 100644 --- a/include/mrbconf.h +++ b/include/mrbconf.h @@ -25,14 +25,24 @@ #endif /* configuration options: */ -/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */ -//#define MRB_USE_FLOAT +/* add -DMRB_USE_FLOAT32 to use float instead of double for floating point numbers */ +//#define MRB_USE_FLOAT32 /* exclude floating point numbers */ -//#define MRB_WITHOUT_FLOAT +//#define MRB_NO_FLOAT -#if defined(MRB_USE_FLOAT) && defined(MRB_WITHOUT_FLOAT) -#error Cannot define MRB_USE_FLOAT and MRB_WITHOUT_FLOAT at the same time +/* obsolete configuration */ +#if defined(MRB_USE_FLOAT) +# define MRB_USE_FLOAT32 +#endif + +/* obsolete configuration */ +#if defined(MRB_WITHOUT_FLOAT) +# define MRB_NO_FLOAT +#endif + +#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT) +#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time #endif /* stop inlining floating point numbers in mrb_value (effective only with MRB_WORD_BOXING)*/ @@ -65,7 +75,7 @@ # endif #endif -/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */ +/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */ //#define MRB_NAN_BOXING /* represent mrb_value as a word (natural unit of data for the processor) */ diff --git a/include/mruby.h b/include/mruby.h index dea0a9c88..485a94d70 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -92,7 +92,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #ifndef FLT_EPSILON #define FLT_EPSILON (1.19209290e-07f) @@ -104,7 +104,7 @@ #define LDBL_EPSILON (1.08420217248550443401e-19L) #endif -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 #define MRB_FLOAT_EPSILON FLT_EPSILON #else #define MRB_FLOAT_EPSILON DBL_EPSILON @@ -245,7 +245,7 @@ typedef struct mrb_state { struct RClass *hash_class; struct RClass *range_class; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RClass *float_class; #endif struct RClass *fixnum_class; @@ -1211,7 +1211,7 @@ MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b); MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2); MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base); MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val); #endif MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); @@ -1304,7 +1304,7 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap); #define E_FROZEN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FrozenError))) #define E_NOTIMP_ERROR (mrb_exc_get_id(mrb, MRB_SYM(NotImplementedError))) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define E_FLOATDOMAIN_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FloatDomainError))) #endif diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index a8655ca19..eb89ac1f9 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -7,12 +7,12 @@ #ifndef MRUBY_BOXING_NAN_H #define MRUBY_BOXING_NAN_H -#ifdef MRB_USE_FLOAT -# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<---- +#ifdef MRB_USE_FLOAT32 +# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<---- #endif -#ifdef MRB_WITHOUT_FLOAT -# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<---- +#ifdef MRB_NO_FLOAT +# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<---- #endif #ifdef MRB_INT64 diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index 23b48c6f8..345f6b35b 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -11,7 +11,7 @@ #define MRB_SYMBOL_SHIFT 0 union mrb_value_union { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float f; #endif void *p; @@ -26,7 +26,7 @@ typedef struct mrb_value { #define mrb_ptr(o) (o).value.p #define mrb_cptr(o) mrb_ptr(o) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float(o) (o).value.f #endif #define mrb_fixnum(o) (o).value.i @@ -43,7 +43,7 @@ typedef struct mrb_value { #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_FIXNUM, value.i, (n)) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v)) #endif #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v)) diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index a91d10421..b9b6a3fe9 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -11,7 +11,7 @@ #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode. #endif -#if !defined(MRB_WITHOUT_FLOAT) || defined(MRB_NO_FLOAT_INLINE) +#if !defined(MRB_NO_FLOAT) || defined(MRB_NO_FLOAT_INLINE) struct RFloat { MRB_OBJECT_HEADER; mrb_float f; @@ -80,7 +80,7 @@ union mrb_value_ { }; #endif struct RBasic *bp; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RFloat *fp; #endif struct RCptr *vp; @@ -96,13 +96,13 @@ mrb_val_union(mrb_value v) } MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #endif #define mrb_ptr(o) mrb_val_union(o).p #define mrb_cptr(o) mrb_val_union(o).vp->p -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float(o) mrb_val_union(o).fp->f #endif #define mrb_fixnum(o) BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int) @@ -124,7 +124,7 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define mrb_nil_p(o) ((o) == MRB_Qnil) #define mrb_false_p(o) ((o) == MRB_Qfalse) #define mrb_true_p(o) ((o) == MRB_Qtrue) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT) #endif #define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY) @@ -146,7 +146,7 @@ MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float); #define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT) #define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v)) #endif #define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v)) diff --git a/include/mruby/class.h b/include/mruby/class.h index 88e5915e5..a02c4ef17 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -37,7 +37,7 @@ mrb_class(mrb_state *mrb, mrb_value v) return mrb->symbol_class; case MRB_TT_FIXNUM: return mrb->fixnum_class; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return mrb->float_class; #endif diff --git a/include/mruby/error.h b/include/mruby/error.h index 67a0a539e..b607dd957 100644 --- a/include/mruby/error.h +++ b/include/mruby/error.h @@ -32,7 +32,7 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va /* declaration for `fail` method */ MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value); -#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING) +#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING) struct RBreak { MRB_OBJECT_HEADER; const struct RProc *proc; @@ -62,7 +62,7 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val) brk->flags &= ~RBREAK_VALUE_TT_MASK; brk->flags |= val.tt; } -#endif /* MRB_64BIT || MRB_USE_FLOAT || MRB_NAN_BOXING || MRB_WORD_BOXING */ +#endif /* MRB_64BIT || MRB_USE_FLOAT32 || MRB_NAN_BOXING || MRB_WORD_BOXING */ #define mrb_break_proc_get(brk) ((brk)->proc) #define mrb_break_proc_set(brk, p) ((brk)->proc = p) diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index 06a33cc6f..10b242688 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -22,7 +22,7 @@ MRB_BEGIN_DECL #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int) #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int) #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int) -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #ifdef MRB_INT64 #define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0) #else @@ -30,12 +30,12 @@ MRB_BEGIN_DECL #endif #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val); #endif MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base); /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT 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); @@ -161,13 +161,13 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT # include # include # define MRB_FLT_RADIX FLT_RADIX -# ifdef MRB_USE_FLOAT +# ifdef MRB_USE_FLOAT32 # define MRB_FLT_MANT_DIG FLT_MANT_DIG # define MRB_FLT_EPSILON FLT_EPSILON # define MRB_FLT_DIG FLT_DIG @@ -178,7 +178,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) # define MRB_FLT_MAX FLT_MAX # define MRB_FLT_MAX_10_EXP FLT_MAX_10_EXP -# else /* not MRB_USE_FLOAT */ +# else /* not MRB_USE_FLOAT32 */ # define MRB_FLT_MANT_DIG DBL_MANT_DIG # define MRB_FLT_EPSILON DBL_EPSILON # define MRB_FLT_DIG DBL_DIG @@ -188,8 +188,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product) # define MRB_FLT_MAX_EXP DBL_MAX_EXP # define MRB_FLT_MAX DBL_MAX # define MRB_FLT_MAX_10_EXP DBL_MAX_10_EXP -# endif /* MRB_USE_FLOAT */ -#endif /* MRB_WITHOUT_FLOAT */ +# endif /* MRB_USE_FLOAT32 */ +#endif /* MRB_NO_FLOAT */ MRB_END_DECL diff --git a/include/mruby/value.h b/include/mruby/value.h index 473774b00..88c8d4dba 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -75,9 +75,9 @@ struct mrb_state; # define MRB_ENDIAN_LOHI(a,b) b a #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API double mrb_float_read(const char*, char**); -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 typedef float mrb_float; #else typedef double mrb_float; @@ -90,7 +90,7 @@ MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list ar MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...); # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg) # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__) -# if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT +# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT # include # define isfinite(n) _finite(n) # define isnan _isnan @@ -195,7 +195,7 @@ struct RCptr { #ifndef mrb_true_p #define mrb_true_p(o) (mrb_type(o) == MRB_TT_TRUE) #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #ifndef mrb_float_p #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT) #endif @@ -264,7 +264,7 @@ struct RCptr { * * Takes a float and boxes it into an mrb_value */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f) { mrb_value v; diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index f60f1f077..372a2c5f7 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -530,7 +530,7 @@ new_lit(codegen_scope *s, mrb_value val) return i; } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: for (i=0; iirep->plen; i++) { mrb_float f1, f2; @@ -588,7 +588,7 @@ new_lit(codegen_scope *s, mrb_value val) } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: pv->tt = IREP_TT_FLOAT; pv->u.f = mrb_float(val); @@ -1330,7 +1330,7 @@ raise_error(codegen_scope *s, const char *msg) genop_1(s, OP_ERR, idx); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static double readint_float(codegen_scope *s, const char *p, int base) { @@ -2442,7 +2442,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_bool overflow; i = readint_mrb_int(s, p, base, FALSE, &overflow); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (overflow) { double f = readint_float(s, p, base); int off = new_lit(s, mrb_float_value(s->mrb, f)); @@ -2473,7 +2473,7 @@ codegen(codegen_scope *s, node *tree, int val) } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case NODE_FLOAT: if (val) { char *p = (char*)tree; @@ -2490,7 +2490,7 @@ codegen(codegen_scope *s, node *tree, int val) { nt = nint(tree->car); switch (nt) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case NODE_FLOAT: if (val) { char *p = (char*)tree->cdr; @@ -2511,7 +2511,7 @@ codegen(codegen_scope *s, node *tree, int val) mrb_bool overflow; i = readint_mrb_int(s, p, base, TRUE, &overflow); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (overflow) { double f = readint_float(s, p, base); int off = new_lit(s, mrb_float_value(s->mrb, -f)); @@ -2531,7 +2531,7 @@ codegen(codegen_scope *s, node *tree, int val) int off = new_lit(s, mrb_fixnum_value(i)); genop_2(s, OP_LOADL, cursp(), off); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT } #endif push(); diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y index c67c694fe..8e3087a2a 100644 --- a/mrbgems/mruby-compiler/core/parse.y +++ b/mrbgems/mruby-compiler/core/parse.y @@ -981,7 +981,7 @@ new_int(parser_state *p, const char *s, int base, int suffix) return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* (:float . i) */ static node* new_float(parser_state *p, const char *s, int suffix) @@ -5661,7 +5661,7 @@ parser_yylex(parser_state *p) } tokfix(p); if (is_float) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT yywarning_s(p, "floating point numbers are not supported", tok(p)); pylval.nd = new_int(p, "0", 10, 0); return tINTEGER; diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c index 096543349..48173933f 100644 --- a/mrbgems/mruby-compiler/core/y.tab.c +++ b/mrbgems/mruby-compiler/core/y.tab.c @@ -1044,7 +1044,7 @@ new_int(parser_state *p, const char *s, int base, int suffix) return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* (:float . i) */ static node* new_float(parser_state *p, const char *s, int suffix) @@ -11553,7 +11553,7 @@ parser_yylex(parser_state *p) } tokfix(p); if (is_float) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT yywarning_s(p, "floating point numbers are not supported", tok(p)); pylval.nd = new_int(p, "0", 10, 0); return tINTEGER; diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c index 24dad4235..85735b704 100644 --- a/mrbgems/mruby-complex/src/complex.c +++ b/mrbgems/mruby-complex/src/complex.c @@ -3,8 +3,8 @@ #include #include -#ifdef MRB_WITHOUT_FLOAT -# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb' +#ifdef MRB_NO_FLOAT +# error Complex conflicts with 'MRB_NO_FLOAT' configuration #endif struct mrb_complex { @@ -12,13 +12,13 @@ struct mrb_complex { mrb_float imaginary; }; -#ifdef MRB_USE_FLOAT +#ifdef MRB_USE_FLOAT32 #define F(x) x##f #else #define F(x) x #endif -#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) +#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) #define COMPLEX_USE_ISTRUCT /* use TT_ISTRUCT */ diff --git a/mrbgems/mruby-complex/test/complex.rb b/mrbgems/mruby-complex/test/complex.rb index d996e8277..14711ad73 100644 --- a/mrbgems/mruby-complex/test/complex.rb +++ b/mrbgems/mruby-complex/test/complex.rb @@ -60,7 +60,7 @@ assert 'Complex#/' do assert_complex Complex(9, 8) / 4 , ((9 / 4) + 2i) assert_complex Complex(20, 9) / 9.8 , (2.0408163265306123 + 0.9183673469387754i) if 1e39.infinite? then - # MRB_USE_FLOAT in effect + # MRB_USE_FLOAT32 in effect ten = 1e21 one = 1e20 else @@ -80,7 +80,7 @@ assert 'Complex#abs' do assert_float Complex(-1).abs, 1 assert_float Complex(3.0, -4.0).abs, 5.0 if 1e39.infinite? then - # MRB_USE_FLOAT in effect + # MRB_USE_FLOAT32 in effect exp = 125 else exp = 1021 diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c index 5d307dcab..b4d9b1f1e 100644 --- a/mrbgems/mruby-inline-struct/test/inline.c +++ b/mrbgems/mruby-inline-struct/test/inline.c @@ -13,7 +13,7 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self) if (mrb_fixnum_p(object)) { strncpy(string, "fixnum", size-1); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (mrb_float_p(object)) { strncpy(string, "float", size-1); } diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index 04dece910..a28360d81 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -448,8 +448,8 @@ mrb_file_size(mrb_state *mrb, mrb_value self) } if (st.st_size > MRB_INT_MAX) { -#ifdef MRB_WITHOUT_FLOAT - mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT"); +#ifdef MRB_NO_FLOAT + mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT"); #else return mrb_float_value(mrb, (mrb_float)st.st_size); #endif diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 988d19b02..587e195d9 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -973,10 +973,10 @@ mrb_io_sysseek(mrb_state *mrb, mrb_value io) mrb_sys_fail(mrb, "sysseek"); } if (pos > MRB_INT_MAX) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)pos); #else - mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT"); + mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_NO_FLOAT"); #endif } else { return mrb_fixnum_value(pos); @@ -1081,7 +1081,7 @@ time2timeval(mrb_state *mrb, mrb_value time) t.tv_usec = 0; break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: t.tv_sec = (ftime_t)mrb_float(time); t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0); diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index 70991c704..eaf8c6eb0 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -112,7 +112,7 @@ mrb_f_integer(mrb_state *mrb, mrb_value self) return mrb_convert_to_integer(mrb, arg, base); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * call-seq: * Float(arg) -> float @@ -212,7 +212,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb) mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2)); mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE()); mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1)); #endif mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1)); diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index ff1e84684..fcde7e700 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -4,8 +4,8 @@ ** See Copyright Notice in mruby.h */ -#ifdef MRB_WITHOUT_FLOAT -# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb' +#ifdef MRB_NO_FLOAT +# error Math conflicts with 'MRB_NO_FLOAT' configuration #endif #include diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index fd7072ccd..d00be4b5d 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c @@ -59,7 +59,7 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1)); mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX), mrb_fixnum_value(MRB_FLT_RADIX)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG), mrb_fixnum_value(MRB_FLT_MANT_DIG)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON), mrb_float_value(mrb, MRB_FLT_EPSILON)); @@ -70,7 +70,7 @@ mrb_mruby_numeric_ext_gem_init(mrb_state* mrb) mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP), mrb_fixnum_value(MRB_FLT_MAX_EXP)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX), mrb_float_value(mrb, MRB_FLT_MAX)); mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP), mrb_fixnum_value(MRB_FLT_MAX_10_EXP)); -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ } void diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c index 57361e8e2..2d99ce8c2 100644 --- a/mrbgems/mruby-object-ext/src/object.c +++ b/mrbgems/mruby-object-ext/src/object.c @@ -17,7 +17,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj) return mrb_ary_new(mrb); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * call-seq: * nil.to_f -> 0.0 @@ -115,7 +115,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb) struct RClass * n = mrb->nil_class; mrb_define_method(mrb, n, "to_a", nil_to_a, MRB_ARGS_NONE()); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, n, "to_f", nil_to_f, MRB_ARGS_NONE()); #endif mrb_define_method(mrb, n, "to_h", nil_to_h, MRB_ARGS_NONE()); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 7030299f4..78ef1e4df 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -111,7 +111,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) case MRB_TT_DATA: size += mrb_objspace_page_slot_size(); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #ifdef MRB_WORD_BOXING size += mrb_objspace_page_slot_size() + diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index e222cd946..45427afa0 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -425,7 +425,7 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un return 8; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static int pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags) { @@ -1248,7 +1248,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) if (type == PACK_TYPE_INTEGER) { o = mrb_to_int(mrb, o); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (type == PACK_TYPE_FLOAT) { if (!mrb_float_p(o)) { mrb_float f = mrb_to_flo(mrb, o); @@ -1284,7 +1284,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary) case PACK_DIR_STR: ridx += pack_a(mrb, o, result, ridx, count, flags); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case PACK_DIR_DOUBLE: ridx += pack_double(mrb, o, result, ridx, flags); break; @@ -1381,7 +1381,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single) case PACK_DIR_QUAD: srcidx += unpack_q(mrb, sptr, srclen - srcidx, result, flags); break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case PACK_DIR_FLOAT: srcidx += unpack_float(mrb, sptr, srclen - srcidx, result, flags); break; diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index fdb28e012..3010b3db7 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -85,7 +85,7 @@ rand_uint32(rand_state *state) } #endif /* XORSHIFT96 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static double rand_real(rand_state *t) { @@ -100,7 +100,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) mrb_value value; if (mrb_fixnum(max) == 0) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT value = mrb_float_value(mrb, rand_real(t)); #else mrb_raise(mrb, E_ARGUMENT_ERROR, "Float not supported"); diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c index 633894070..421e7d33a 100644 --- a/mrbgems/mruby-range-ext/src/range.c +++ b/mrbgems/mruby-range-ext/src/range.c @@ -96,7 +96,7 @@ range_last(mrb_state *mrb, mrb_value range) * ('a'..'z').size #=> nil */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value range_size(mrb_state *mrb, mrb_value range) { @@ -170,7 +170,7 @@ range_size(mrb_state *mrb, mrb_value range) } return mrb_nil_value(); } -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ void mrb_mruby_range_ext_gem_init(mrb_state* mrb) diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index 4a72a42f2..f9470de86 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -87,7 +87,7 @@ rational_s_new(mrb_state *mrb, mrb_value self) { mrb_int numerator, denominator; -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_get_args(mrb, "ii", &numerator, &denominator); #else @@ -136,7 +136,7 @@ rational_s_new(mrb_state *mrb, mrb_value self) return rational_new(mrb, numerator, denominator); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value rational_to_f(mrb_state *mrb, mrb_value self) { @@ -194,7 +194,7 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb) mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2)); mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE()); mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE()); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, rat, "to_f", rational_to_f, MRB_ARGS_NONE()); #endif mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE()); diff --git a/mrbgems/mruby-sleep/src/mrb_sleep.c b/mrbgems/mruby-sleep/src/mrb_sleep.c index a653242d1..7771db56b 100644 --- a/mrbgems/mruby-sleep/src/mrb_sleep.c +++ b/mrbgems/mruby-sleep/src/mrb_sleep.c @@ -44,7 +44,7 @@ mrb_f_sleep(mrb_state *mrb, mrb_value self) { time_t beg = time(0); time_t end; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float sec; mrb_get_args(mrb, "f", &sec); diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 0cf462ef7..7f36616ec 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -10,7 +10,7 @@ #include #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif #include @@ -20,7 +20,7 @@ #define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n))) mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int); #endif @@ -863,7 +863,7 @@ retry: bin_retry: switch (mrb_type(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: val = mrb_flo_to_fixnum(mrb, val); if (mrb_fixnum_p(val)) goto bin_retry; @@ -1030,7 +1030,7 @@ retry: } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': case 'g': case 'G': @@ -1131,7 +1131,7 @@ retry: return result; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static void fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec) { diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index ded34a89e..71fb5bb65 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/mrbgems/mruby-string-ext/src/string.c @@ -12,7 +12,7 @@ #define ENC_COMP_P(enc, enc_lit) \ str_casecmp_p(RSTRING_PTR(enc), RSTRING_LEN(enc), enc_lit, sizeof(enc_lit"")-1) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT # define mrb_float_p(o) FALSE #endif diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index fe1a475d5..4b82a9abc 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -224,8 +224,8 @@ mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose) mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN)); mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT)); -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-6)); #else mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-12)); diff --git a/mrbgems/mruby-test/vformat.c b/mrbgems/mruby-test/vformat.c index e7ada02da..d73e52311 100644 --- a/mrbgems/mruby-test/vformat.c +++ b/mrbgems/mruby-test/vformat.c @@ -48,7 +48,7 @@ vf_s_format_d(mrb_state *mrb, mrb_value klass) return mrb_format(mrb, fmt, d); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* f float */ static mrb_value vf_s_format_f(mrb_state *mrb, mrb_value klass) @@ -167,7 +167,7 @@ mrb_init_test_vformat(mrb_state *mrb) VF_DEFINE_FORMAT_METHOD(c); VF_DEFINE_FORMAT_METHOD(d); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT VF_DEFINE_FORMAT_METHOD(f); #endif VF_DEFINE_FORMAT_METHOD(i); diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 3655695cf..3d5cdca2e 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -4,7 +4,7 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif @@ -30,7 +30,7 @@ double round(double x) { } #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT # if !defined(__MINGW64__) && defined(_WIN32) # define llround(x) round(x) # endif @@ -199,7 +199,7 @@ struct mrb_time { static const struct mrb_data_type mrb_time_type = { "Time", mrb_free }; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT void mrb_check_num_exact(mrb_state *mrb, mrb_float num); typedef mrb_float mrb_sec; #define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec) @@ -231,7 +231,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) time_t t; switch (mrb_type(obj)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: { mrb_float f = mrb_float(obj); @@ -250,7 +250,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) } } break; -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ default: case MRB_TT_FIXNUM: { @@ -572,7 +572,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self) tm = time_get_ptr(mrb, self); tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time); if (tm2) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float f; f = (mrb_sec)(tm->sec - tm2->sec) + (mrb_sec)(tm->usec - tm2->usec) / 1.0e6; @@ -843,7 +843,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self) return mrb_fixnum_value(tm->datetime.tm_sec); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* 15.2.19.7.24 */ /* Returns a Float with the time since the epoch in seconds. */ static mrb_value @@ -864,7 +864,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) struct mrb_time *tm; tm = time_get_ptr(mrb, self); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (!fixable_time_t_p(tm->sec)) { return mrb_float_value(mrb, (mrb_float)tm->sec); } @@ -880,7 +880,7 @@ mrb_time_usec(mrb_state *mrb, mrb_value self) struct mrb_time *tm; tm = time_get_ptr(mrb, self); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (!fixable_time_t_p(tm->usec)) { return mrb_float_value(mrb, (mrb_float)tm->usec); } @@ -995,7 +995,7 @@ mrb_mruby_time_gem_init(mrb_state* mrb) mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE()); /* 15.2.19.7.23 */ mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE()); /* 15.2.19.7.25 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE()); /* 15.2.19.7.24 */ #endif mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE()); /* 15.2.19.7.26 */ diff --git a/src/array.c b/src/array.c index 285600969..432599bf7 100644 --- a/src/array.c +++ b/src/array.c @@ -825,7 +825,7 @@ aget_index(mrb_state *mrb, mrb_value index) if (mrb_fixnum_p(index)) { return mrb_fixnum(index); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT else if (mrb_float_p(index)) { return (mrb_int)mrb_float(index); } diff --git a/src/class.c b/src/class.c index 455a1b4e1..845246e97 100644 --- a/src/class.c +++ b/src/class.c @@ -899,7 +899,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': { mrb_float *p; @@ -1343,7 +1343,7 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) return mrb->object_class; case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif return NULL; diff --git a/src/dump.c b/src/dump.c index 3bc95f629..489e70f8a 100644 --- a/src/dump.c +++ b/src/dump.c @@ -13,8 +13,8 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 #define MRB_FLOAT_FMT "%.9g" #else #define MRB_FLOAT_FMT "%.17g" @@ -88,7 +88,7 @@ write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t fla return cur - buf; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value float_to_str(mrb_state *mrb, mrb_float f) { @@ -131,7 +131,7 @@ get_pool_block_size(mrb_state *mrb, const mrb_irep *irep) break; case IREP_TT_FLOAT: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT { mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); mrb_int len = RSTRING_LEN(str); @@ -192,7 +192,7 @@ write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf) case IREP_TT_FLOAT: cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT { mrb_value str = float_to_str(mrb, irep->pool[pool_no].u.f); ptr = RSTRING_PTR(str); diff --git a/src/error.c b/src/error.c index 742049ace..b6a82f867 100644 --- a/src/error.c +++ b/src/error.c @@ -288,7 +288,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap) #endif obj = mrb_fixnum_value(i); goto L_cat_obj; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double)); goto L_cat_obj; diff --git a/src/etc.c b/src/etc.c index a1e384717..b0019e6de 100644 --- a/src/etc.c +++ b/src/etc.c @@ -70,7 +70,7 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name) } MRB_API mrb_int -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_fixnum_id(mrb_int f) #else mrb_float_id(mrb_float f) @@ -80,7 +80,7 @@ mrb_float_id(mrb_float f) int len = sizeof(f); uint32_t id = 0; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* normalize -0.0 to 0.0 */ if (f == 0) f = 0.0; #endif @@ -115,7 +115,7 @@ mrb_obj_id(mrb_value obj) case MRB_TT_SYMBOL: return MakeID(mrb_symbol(obj)); case MRB_TT_FIXNUM: -#ifdef MRB_WITHOUT_FLOAT +#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); @@ -147,7 +147,7 @@ mrb_obj_id(mrb_value obj) #ifdef MRB_WORD_BOXING #define mrb_xxx_boxing_cptr_value mrb_word_boxing_cptr_value -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) { @@ -158,7 +158,7 @@ mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f) MRB_SET_FROZEN_FLAG(v.bp); return v.w; } -#endif /* MRB_WITHOUT_FLOAT */ +#endif /* MRB_NO_FLOAT */ #endif /* MRB_WORD_BOXING */ #if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT)) diff --git a/src/fmt_fp.c b/src/fmt_fp.c index 81ace6ec8..2c1e13c36 100644 --- a/src/fmt_fp.c +++ b/src/fmt_fp.c @@ -1,4 +1,4 @@ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #if defined(MRB_DISABLE_STDIO) || defined(_WIN32) || defined(_WIN64) /* diff --git a/src/gc.c b/src/gc.c index 17f7e81e4..50269f95c 100644 --- a/src/gc.c +++ b/src/gc.c @@ -122,7 +122,7 @@ typedef struct { struct RException exc; struct RBreak brk; #ifdef MRB_WORD_BOXING -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RFloat floatv; #endif struct RCptr cptr; @@ -784,7 +784,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) /* cannot happen */ return; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #ifdef MRB_WORD_BOXING break; @@ -929,7 +929,7 @@ root_scan_phase(mrb_state *mrb, mrb_gc *gc) mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class); mrb_gc_mark(mrb, (struct RBasic*)mrb->range_class); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class); #endif mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class); diff --git a/src/hash.c b/src/hash.c index 72ed3c731..2eef4afaf 100644 --- a/src/hash.c +++ b/src/hash.c @@ -11,7 +11,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* a function to get hash value of a float number */ mrb_int mrb_float_id(mrb_float f); #endif @@ -65,7 +65,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) case MRB_TT_FALSE: case MRB_TT_SYMBOL: case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif h = (size_t)mrb_obj_id(key); @@ -99,7 +99,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) switch (mrb_type(b)) { case MRB_TT_FIXNUM: return mrb_fixnum(a) == mrb_fixnum(b); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return (mrb_float)mrb_fixnum(a) == mrb_float(b); #endif @@ -107,7 +107,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) return FALSE; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: switch (mrb_type(b)) { case MRB_TT_FIXNUM: diff --git a/src/load.c b/src/load.c index 67217b128..b06b9ff37 100644 --- a/src/load.c +++ b/src/load.c @@ -39,7 +39,7 @@ offset_crc_body(void) return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck); static double @@ -165,7 +165,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag #endif case IREP_TT_FLOAT: -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT pool[i].tt = tt; pool_data_len = bin_to_uint16(src); /* pool data length */ src += sizeof(uint16_t); @@ -173,7 +173,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag src += pool_data_len; break; #else - return NULL; /* MRB_WITHOUT_FLOAT */ + return NULL; /* MRB_NO_FLOAT */ #endif case IREP_TT_STR: diff --git a/src/numeric.c b/src/numeric.c index 195bd40cf..f4ad116a4 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -4,7 +4,7 @@ ** See Copyright Notice in mruby.h */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #include #endif @@ -18,8 +18,8 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT -#ifdef MRB_USE_FLOAT +#ifndef MRB_NO_FLOAT +#ifdef MRB_USE_FLOAT32 #define trunc(f) truncf(f) #define floor(f) floorf(f) #define ceil(f) ceilf(f) @@ -30,7 +30,7 @@ #endif #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value val) { @@ -68,7 +68,7 @@ static mrb_value integral_pow(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_float d; #endif @@ -79,7 +79,7 @@ integral_pow(mrb_state *mrb, mrb_value x) mrb_int result = 1; if (exp < 0) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else goto float_pow; @@ -87,7 +87,7 @@ integral_pow(mrb_state *mrb, mrb_value x) for (;;) { if (exp & 1) { if (mrb_int_mul_overflow(result, base, &result)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT goto float_pow; #endif } @@ -95,14 +95,14 @@ integral_pow(mrb_state *mrb, mrb_value x) exp >>= 1; if (exp == 0) break; if (mrb_int_mul_overflow(base, base, &base)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT goto float_pow; #endif } } return mrb_fixnum_value(result); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else float_pow: @@ -114,7 +114,7 @@ integral_pow(mrb_state *mrb, mrb_value x) static mrb_value integral_idiv(mrb_state *mrb, mrb_value x) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_value y = mrb_get_arg1(mrb); if (!mrb_fixnum_p(y)) { @@ -151,7 +151,7 @@ integral_idiv(mrb_state *mrb, mrb_value x) static mrb_value integral_div(mrb_state *mrb, mrb_value xv) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_int y; mrb_get_args(mrb, "i", &y); @@ -184,7 +184,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "oo", &num, &step); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(self) || mrb_float_p(num) || mrb_float_p(step)) { return mrb_Float(mrb, self); } @@ -193,7 +193,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) return self; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /******************************************************************** * * Document-class: Float @@ -386,7 +386,7 @@ fix_eql(mrb_state *mrb, mrb_value x) return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_eql(mrb_state *mrb, mrb_value x) { @@ -803,13 +803,13 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return x; b = mrb_fixnum(y); if (mrb_int_mul_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y)); @@ -822,7 +822,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_mul(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y)); } @@ -898,7 +898,7 @@ fix_mod(mrb_state *mrb, mrb_value x) mrb_int mod; if (b == 0) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT /* ZeroDivisionError */ return mrb_fixnum_value(0); #else @@ -910,7 +910,7 @@ fix_mod(mrb_state *mrb, mrb_value x) fixdivmod(mrb, a, b, NULL, &mod); return mrb_fixnum_value(mod); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else else { @@ -937,7 +937,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) mrb_int div, mod; if (mrb_fixnum(y) == 0) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0)); #else return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ? @@ -949,7 +949,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else else { @@ -964,7 +964,7 @@ fix_divmod(mrb_state *mrb, mrb_value x) #endif } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_divmod(mrb_state *mrb, mrb_value x) { @@ -999,7 +999,7 @@ fix_equal(mrb_state *mrb, mrb_value x) switch (mrb_type(y)) { case MRB_TT_FIXNUM: return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y)); #endif @@ -1027,7 +1027,7 @@ fix_rev(mrb_state *mrb, mrb_value num) return mrb_fixnum_value(~val); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define bit_op(x,y,op1,op2) do {\ return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\ } while(0) @@ -1095,7 +1095,7 @@ static mrb_value lshift(mrb_state *mrb, mrb_int val, mrb_int width) { if (width < 0) { /* mrb_int overflow */ -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else return mrb_float_value(mrb, INFINITY); @@ -1104,7 +1104,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) if (val > 0) { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || (val > (MRB_INT_MAX >> width))) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(-1); #else goto bit_overflow; @@ -1115,7 +1115,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) else { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || (val <= (MRB_INT_MIN >> width))) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT return mrb_fixnum_value(0); #else goto bit_overflow; @@ -1124,7 +1124,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) return mrb_fixnum_value(val * ((mrb_int)1 << width)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT bit_overflow: { mrb_float f = (mrb_float)val; @@ -1210,7 +1210,7 @@ fix_rshift(mrb_state *mrb, mrb_value x) * */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value fix_to_f(mrb_state *mrb, mrb_value num) { @@ -1267,13 +1267,13 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) if (a == 0) return y; b = mrb_fixnum(y); if (mrb_int_add_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y)); @@ -1286,7 +1286,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_plus(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y)); } @@ -1323,13 +1323,13 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) b = mrb_fixnum(y); if (mrb_int_sub_overflow(a, b, &c)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); #endif } return mrb_fixnum_value(c); } -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); #else return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y)); @@ -1342,7 +1342,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) if (mrb_fixnum_p(x)) { return fixnum_minus(mrb, x, y); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(x)) { return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y)); } @@ -1431,26 +1431,26 @@ fix_to_s(mrb_state *mrb, mrb_value self) static mrb_int cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) { -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT mrb_int x, y; #else mrb_float x, y; #endif -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT x = mrb_fixnum(v1); #else x = mrb_to_flo(mrb, v1); #endif switch (mrb_type(v2)) { case MRB_TT_FIXNUM: -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT y = mrb_fixnum(v2); #else y = (mrb_float)mrb_fixnum(v2); #endif break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: y = mrb_float(v2); break; @@ -1585,7 +1585,7 @@ num_infinite_p(mrb_state *mrb, mrb_value self) * Returns a new float which is the sum of float * and other. */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT static mrb_value flo_plus(mrb_state *mrb, mrb_value x) { @@ -1600,7 +1600,7 @@ void mrb_init_numeric(mrb_state *mrb) { struct RClass *numeric, *integer, *fixnum, *integral; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT struct RClass *fl; #endif @@ -1627,7 +1627,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_undef_class_method(mrb, integer, "new"); 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_WITHOUT_FLOAT +#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) */ @@ -1648,14 +1648,14 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ mrb_define_method(mrb, fixnum, "eql?", fix_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ #endif mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */ mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_OPT(1)); mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* Float Class */ mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric); /* 15.2.9 */ MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT); diff --git a/src/object.c b/src/object.c index fd1f9e215..634f70830 100644 --- a/src/object.c +++ b/src/object.c @@ -24,7 +24,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) case MRB_TT_SYMBOL: return (mrb_symbol(v1) == mrb_symbol(v2)); -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return (mrb_float(v1) == mrb_float(v2)); #endif @@ -47,7 +47,7 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2) mrb_value result; if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE; -#ifndef MRB_WITHOUT_FLOAT +#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)) @@ -330,7 +330,7 @@ static const struct types { {MRB_TT_ICLASS, "iClass"}, /* internal use: mixed-in module holder */ {MRB_TT_SCLASS, "SClass"}, {MRB_TT_PROC, "Proc"}, -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT {MRB_TT_FLOAT, "Float"}, #endif {MRB_TT_ARRAY, "Array"}, @@ -510,7 +510,7 @@ mrb_to_int(mrb_state *mrb, mrb_value val) { if (!mrb_fixnum_p(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (mrb_float_p(val)) { return mrb_flo_to_fixnum(mrb, val); } @@ -530,7 +530,7 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base) mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer"); } switch (mrb_type(val)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: if (base != 0) goto arg_error; return mrb_flo_to_fixnum(mrb, val); @@ -566,7 +566,7 @@ mrb_Integer(mrb_state *mrb, mrb_value val) return mrb_convert_to_integer(mrb, val, 0); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val) { diff --git a/src/range.c b/src/range.c index 868d3d397..8f09eda24 100644 --- a/src/range.c +++ b/src/range.c @@ -23,7 +23,7 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b) ta = mrb_type(a); tb = mrb_type(b); -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) { #else if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) && diff --git a/src/string.c b/src/string.c index 73e514f41..f15770403 100644 --- a/src/string.c +++ b/src/string.c @@ -8,7 +8,7 @@ # define _CRT_NONSTDC_NO_DEPRECATE #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #include #endif @@ -2365,7 +2365,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, i n *= base; n += c; if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (base == 10) { return mrb_float_value(mrb, mrb_str_to_dbl(mrb, mrb_str_new(mrb, str, len), badcheck)); } @@ -2476,7 +2476,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self) return mrb_str_to_inum(mrb, self, base, FALSE); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck) { @@ -2937,7 +2937,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "slice", mrb_str_aref_m, MRB_ARGS_ANY()); /* 15.2.10.5.34 */ mrb_define_method(mrb, s, "split", mrb_str_split_m, MRB_ARGS_ANY()); /* 15.2.10.5.35 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, s, "to_f", mrb_str_to_f, MRB_ARGS_NONE()); /* 15.2.10.5.38 */ #endif mrb_define_method(mrb, s, "to_i", mrb_str_to_i, MRB_ARGS_ANY()); /* 15.2.10.5.39 */ @@ -2954,7 +2954,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "byteslice", mrb_str_byteslice, MRB_ARGS_ARG(1,1)); } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT /* * Source code for the "strtod" library procedure. * diff --git a/src/vm.c b/src/vm.c index 87606c1b4..48dea94fb 100644 --- a/src/vm.c +++ b/src/vm.c @@ -6,7 +6,7 @@ #include #include -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT #include #endif #include @@ -1101,7 +1101,7 @@ RETRY_TRY_BLOCK: } goto L_RAISE; #endif -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case IREP_TT_FLOAT: regs[a] = mrb_float_value(mrb, pool[b].u.f); break; @@ -2265,7 +2265,7 @@ RETRY_TRY_BLOCK: SET_INT_VALUE(regs[a], z); \ } \ break -#ifdef MRB_WITHOUT_FLOAT +#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) #else @@ -2305,14 +2305,14 @@ RETRY_TRY_BLOCK: } CASE(OP_DIV, B) { -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT double x, y, f; #endif /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); @@ -2342,7 +2342,7 @@ RETRY_TRY_BLOCK: goto L_SEND_SYM; } -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT if (y == 0) { if (x > 0) f = INFINITY; else if (x < 0) f = -INFINITY; @@ -2378,7 +2378,7 @@ RETRY_TRY_BLOCK: SET_INT_VALUE(regs[a], z); \ } \ break -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define OP_MATHI_CASE_FLOAT(op_name) (void)0 #else #define OP_MATHI_CASE_FLOAT(op_name) \ @@ -2400,7 +2400,7 @@ RETRY_TRY_BLOCK: #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1])) -#ifdef MRB_WITHOUT_FLOAT +#ifdef MRB_NO_FLOAT #define OP_CMP(op,sym) do {\ int result;\ /* need to check if - is overridden */\ diff --git a/target/RX630.rb b/target/RX630.rb index 8b1bbb42f..1b1f425c1 100644 --- a/target/RX630.rb +++ b/target/RX630.rb @@ -30,7 +30,7 @@ MRuby::CrossBuild.new("RX630") do |conf| cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"] #configuration for low memory environment - cc.defines << %w(MRB_USE_FLOAT) + cc.defines << %w(MRB_USE_FLOAT32) cc.defines << %w(MRB_HEAP_PAGE_SIZE=64) cc.defines << %w(KHASH_DEFAULT_SIZE=8) cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20) diff --git a/tasks/gitlab.rake b/tasks/gitlab.rake index 377b1cc9d..5c7b3d8c5 100644 --- a/tasks/gitlab.rake +++ b/tasks/gitlab.rake @@ -62,10 +62,10 @@ task :gitlab_config do configs = [] [true, false].each do |mode_32| - ['', 'MRB_USE_FLOAT'].each do |float_conf| + ['', 'MRB_USE_FLOAT32'].each do |float_conf| ['', 'MRB_NAN_BOXING', 'MRB_WORD_BOXING'].each do |boxing_conf| ['', 'MRB_UTF8_STRING'].each do |utf8_conf| - next if (float_conf == 'MRB_USE_FLOAT') && (boxing_conf == 'MRB_NAN_BOXING') + next if (float_conf == 'MRB_USE_FLOAT32') && (boxing_conf == 'MRB_NAN_BOXING') next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_NAN_BOXING') next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_WORD_BOXING') && mode_32 env = [float_conf, int_conf, boxing_conf, utf8_conf].map do |conf| diff --git a/test/t/float.rb b/test/t/float.rb index dc989636f..1cbc90532 100644 --- a/test/t/float.rb +++ b/test/t/float.rb @@ -207,7 +207,7 @@ assert('Float#>>') do end assert('Float#to_s') do - uses_float = 4e38.infinite? # enable MRB_USE_FLOAT? + uses_float = 4e38.infinite? # enable MRB_USE_FLOAT32? assert_equal("Infinity", Float::INFINITY.to_s) assert_equal("-Infinity", (-Float::INFINITY).to_s) -- cgit v1.2.3 From 80fe9838d2fdab1bb819bbeea892ebe748837b99 Mon Sep 17 00:00:00 2001 From: dearblue Date: Sun, 19 Jan 2020 09:48:14 +0900 Subject: Integrate `Fixnum` class into `Integer` class * The `Fixnum` constant is now an alias for the `Integer` class. * Remove `struct mrb_state::fixnum_class` member. If necessary, use `struct mrb_state::integer_class` instead. --- doc/limitations.md | 2 +- include/mruby.h | 6 +-- include/mruby/class.h | 2 +- include/mruby/numeric.h | 4 +- mrbgems/mruby-complex/mrblib/complex.rb | 2 +- mrbgems/mruby-io/mrblib/file.rb | 2 +- mrbgems/mruby-io/mrblib/io.rb | 4 +- mrbgems/mruby-io/test/io.rb | 4 +- mrbgems/mruby-kernel-ext/src/kernel.c | 2 +- mrbgems/mruby-math/src/math.c | 2 +- mrbgems/mruby-metaprog/test/metaprog.rb | 8 ++-- mrbgems/mruby-method/test/method.rb | 8 ++-- mrbgems/mruby-pack/src/pack.c | 8 ++-- mrbgems/mruby-random/test/random.rb | 4 +- mrbgems/mruby-range-ext/mrblib/range.rb | 2 +- mrbgems/mruby-rational/mrblib/rational.rb | 2 +- mrbgems/mruby-rational/src/rational.c | 2 +- mrbgems/mruby-rational/test/rational.rb | 12 ++--- mrbgems/mruby-socket/src/socket.c | 2 +- mrbgems/mruby-struct/src/struct.c | 4 +- mrblib/range.rb | 2 +- src/class.c | 6 +-- src/gc.c | 2 +- src/kernel.c | 8 ++-- src/numeric.c | 78 +++++++++++++++---------------- src/string.c | 6 +-- test/t/bs_literal.rb | 2 +- test/t/integer.rb | 2 +- test/t/kernel.rb | 2 +- test/t/module.rb | 2 +- test/t/vformat.rb | 6 +-- 31 files changed, 99 insertions(+), 99 deletions(-) (limited to 'src/numeric.c') diff --git a/doc/limitations.md b/doc/limitations.md index 79979fd5a..7e58ca420 100644 --- a/doc/limitations.md +++ b/doc/limitations.md @@ -17,7 +17,7 @@ Please help to improve it by submitting your findings. ## `1/2` gives `0.5` Since mruby does not have `Bignum`, bigger integers are represented -by `Float` numbers. To enhance interoperability between `Fixnum` +by `Float` numbers. To enhance interoperability between `Integer` and `Float`, mruby provides `Float#upto` and other iterating methods for the `Float` class. As a side effect, `1/2` gives `0.5` not `0`. diff --git a/include/mruby.h b/include/mruby.h index 485a94d70..f07adbb13 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -248,7 +248,7 @@ typedef struct mrb_state { #ifndef MRB_NO_FLOAT struct RClass *float_class; #endif - struct RClass *fixnum_class; + struct RClass *integer_class; struct RClass *true_class; struct RClass *false_class; struct RClass *nil_class; @@ -890,8 +890,8 @@ MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass * | `s` | {String} | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` | * | `z` | {String} | const char * | `NULL` terminated string; `z!` gives `NULL` for `nil` | * | `a` | {Array} | {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` | - * | `f` | {Fixnum}/{Float} | {mrb_float} | | - * | `i` | {Fixnum}/{Float} | {mrb_int} | | + * | `f` | {Integer}/{Float} | {mrb_float} | | + * | `i` | {Integer}/{Float} | {mrb_int} | | * | `b` | boolean | {mrb_bool} | | * | `n` | {String}/{Symbol} | {mrb_sym} | | * | `d` | data | void *, {mrb_data_type} const | 2nd argument will be used to check data type so it won't be modified; when `!` follows, the value may be `nil` | diff --git a/include/mruby/class.h b/include/mruby/class.h index a02c4ef17..b4b5454d5 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -36,7 +36,7 @@ mrb_class(mrb_state *mrb, mrb_value v) case MRB_TT_SYMBOL: return mrb->symbol_class; case MRB_TT_FIXNUM: - return mrb->fixnum_class; + return mrb->integer_class; #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: return mrb->float_class; diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index 10b242688..b8cc5b50f 100644 --- a/include/mruby/numeric.h +++ b/include/mruby/numeric.h @@ -1,5 +1,5 @@ /** -** @file mruby/numeric.h - Numeric, Integer, Float, Fixnum class +** @file mruby/numeric.h - Numeric, Integer, Float class ** ** See Copyright Notice in mruby.h */ @@ -12,7 +12,7 @@ /** * Numeric class and it's sub-classes. * - * Integer, Float and Fixnum + * Integer and Float */ MRB_BEGIN_DECL diff --git a/mrbgems/mruby-complex/mrblib/complex.rb b/mrbgems/mruby-complex/mrblib/complex.rb index 74c128a07..67f940865 100644 --- a/mrbgems/mruby-complex/mrblib/complex.rb +++ b/mrbgems/mruby-complex/mrblib/complex.rb @@ -104,7 +104,7 @@ class Complex < Numeric alias_method :imag, :imaginary - [Fixnum, Float].each do |cls| + [Integer, Float].each do |cls| [:+, :-, :*, :/, :==].each do |op| cls.instance_eval do original_operator_name = :"__original_operator_#{op}_complex" diff --git a/mrbgems/mruby-io/mrblib/file.rb b/mrbgems/mruby-io/mrblib/file.rb index aa73252e1..9398acef6 100644 --- a/mrbgems/mruby-io/mrblib/file.rb +++ b/mrbgems/mruby-io/mrblib/file.rb @@ -2,7 +2,7 @@ class File < IO attr_accessor :path def initialize(fd_or_path, mode = "r", perm = 0666) - if fd_or_path.kind_of? Fixnum + if fd_or_path.kind_of? Integer super(fd_or_path, mode) else @path = fd_or_path diff --git a/mrbgems/mruby-io/mrblib/io.rb b/mrbgems/mruby-io/mrblib/io.rb index e597db886..034f88529 100644 --- a/mrbgems/mruby-io/mrblib/io.rb +++ b/mrbgems/mruby-io/mrblib/io.rb @@ -186,7 +186,7 @@ class IO def read(length = nil, outbuf = "") unless length.nil? - unless length.is_a? Fixnum + unless length.is_a? Integer raise TypeError.new "can't convert #{length.class} into Integer" end if length < 0 @@ -229,7 +229,7 @@ class IO case arg when String rs = arg - when Fixnum + when Integer rs = "\n" limit = arg else diff --git a/mrbgems/mruby-io/test/io.rb b/mrbgems/mruby-io/test/io.rb index 2088a61e3..47c70cc60 100644 --- a/mrbgems/mruby-io/test/io.rb +++ b/mrbgems/mruby-io/test/io.rb @@ -7,7 +7,7 @@ $cr, $crlf, $cmd = MRubyIOTestUtil.win? ? [1, "\r\n", "cmd /c "] : [0, "\n", ""] def assert_io_open(meth) assert "assert_io_open" do fd = IO.sysopen($mrbtest_io_rfname) - assert_equal Fixnum, fd.class + assert_equal Integer, fd.class io1 = IO.__send__(meth, fd) begin assert_equal IO, io1.class @@ -433,7 +433,7 @@ assert('IO.popen') do $? = nil io = IO.popen("#{$cmd}echo mruby-io") assert_true io.close_on_exec? - assert_equal Fixnum, io.pid.class + assert_equal Integer, io.pid.class out = io.read assert_equal out.class, String diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c index eaf8c6eb0..e738287db 100644 --- a/mrbgems/mruby-kernel-ext/src/kernel.c +++ b/mrbgems/mruby-kernel-ext/src/kernel.c @@ -84,7 +84,7 @@ mrb_f_method(mrb_state *mrb, mrb_value self) * call-seq: * Integer(arg,base=0) -> integer * - * Converts arg to a Fixnum. + * Converts arg to a Integer. * Numeric types are converted directly (with floating point numbers * being truncated). base (0, or between 2 and 36) is a base for * integer string representation. If arg is a String, diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c index fcde7e700..f2622109d 100644 --- a/mrbgems/mruby-math/src/math.c +++ b/mrbgems/mruby-math/src/math.c @@ -629,7 +629,7 @@ math_cbrt(mrb_state *mrb, mrb_value obj) * Math.frexp(numeric) -> [ fraction, exponent ] * * Returns a two-element array containing the normalized fraction (a - * Float) and exponent (a Fixnum) of + * Float) and exponent (a Integer) of * numeric. * * fraction, exponent = Math.frexp(1234) #=> [0.6025390625, 11] diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb index 82ba0a3a5..84f4e00a0 100644 --- a/mrbgems/mruby-metaprog/test/metaprog.rb +++ b/mrbgems/mruby-metaprog/test/metaprog.rb @@ -395,15 +395,15 @@ end assert('alias_method and remove_method') do begin - Fixnum.alias_method :to_s_, :to_s - Fixnum.remove_method :to_s + Integer.alias_method :to_s_, :to_s + Integer.remove_method :to_s assert_nothing_raised do # segfaults if mrb_cptr is used 1.to_s end ensure - Fixnum.alias_method :to_s, :to_s_ - Fixnum.remove_method :to_s_ + Integer.alias_method :to_s, :to_s_ + Integer.remove_method :to_s_ end end diff --git a/mrbgems/mruby-method/test/method.rb b/mrbgems/mruby-method/test/method.rb index 641979d71..123ae34be 100644 --- a/mrbgems/mruby-method/test/method.rb +++ b/mrbgems/mruby-method/test/method.rb @@ -77,7 +77,7 @@ end assert 'instance' do assert_kind_of Method, 1.method(:+) - assert_kind_of UnboundMethod, Fixnum.instance_method(:+) + assert_kind_of UnboundMethod, Integer.instance_method(:+) end assert 'Method#call' do @@ -404,9 +404,9 @@ assert 'UnboundMethod#arity' do end assert 'UnboundMethod#==' do - assert_false(Fixnum.instance_method(:+) == Fixnum.instance_method(:-)) - assert_true(Fixnum.instance_method(:+) == Fixnum.instance_method(:+)) - assert_false(Fixnum.instance_method(:+) == Float.instance_method(:+)) + assert_false(Integer.instance_method(:+) == Integer.instance_method(:-)) + assert_true(Integer.instance_method(:+) == Integer.instance_method(:+)) + assert_false(Integer.instance_method(:+) == Float.instance_method(:+)) assert_true(UnboundMethod.instance_method(:==) == UnboundMethod.instance_method(:eql?)) end diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index 45427afa0..f797b599b 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/mrbgems/mruby-pack/src/pack.c @@ -290,7 +290,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un #ifndef MRB_INT64 if (!FIXABLE(sl)) { i32tostr(msg, sizeof(msg), sl); - mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg); + mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg); } #endif n = sl; @@ -298,7 +298,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un #ifndef MRB_INT64 if (!POSFIXABLE(ul)) { u32tostr(msg, sizeof(msg), ul); - mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg); + mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg); } #endif n = ul; @@ -411,13 +411,13 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un int64_t sll = ull; if (!FIXABLE(sll)) { i64tostr(msg, sizeof(msg), sll); - mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg); + mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg); } n = (mrb_int)sll; } else { if (!POSFIXABLE(ull)) { u64tostr(msg, sizeof(msg), ull); - mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg); + mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg); } n = (mrb_int)ull; } diff --git a/mrbgems/mruby-random/test/random.rb b/mrbgems/mruby-random/test/random.rb index cf4a55141..f3067748b 100644 --- a/mrbgems/mruby-random/test/random.rb +++ b/mrbgems/mruby-random/test/random.rb @@ -32,8 +32,8 @@ assert("Random.srand") do end assert("return class of Kernel.rand") do - assert_kind_of(Fixnum, rand(3)) - assert_kind_of(Fixnum, rand(1.5)) + assert_kind_of(Integer, rand(3)) + assert_kind_of(Integer, rand(1.5)) assert_kind_of(Float, rand) assert_kind_of(Float, rand(0.5)) end diff --git a/mrbgems/mruby-range-ext/mrblib/range.rb b/mrbgems/mruby-range-ext/mrblib/range.rb index a213beb57..fadddc343 100644 --- a/mrbgems/mruby-range-ext/mrblib/range.rb +++ b/mrbgems/mruby-range-ext/mrblib/range.rb @@ -33,7 +33,7 @@ class Range # fast path for numerics if val.kind_of?(Numeric) && last.kind_of?(Numeric) - raise TypeError if exclude_end? && !last.kind_of?(Fixnum) + raise TypeError if exclude_end? && !last.kind_of?(Integer) return nil if val > last return nil if val == last && exclude_end? diff --git a/mrbgems/mruby-rational/mrblib/rational.rb b/mrbgems/mruby-rational/mrblib/rational.rb index b65f77e2f..489d89ebd 100644 --- a/mrbgems/mruby-rational/mrblib/rational.rb +++ b/mrbgems/mruby-rational/mrblib/rational.rb @@ -92,7 +92,7 @@ module Kernel [:+, :-, :*, :/, :<=>, :==, :<, :<=, :>, :>=].each do |op| original_operator_name = :"__original_operator_#{op}_rational" - Fixnum.instance_eval do + Integer.instance_eval do alias_method original_operator_name, op define_method op do |rhs| if rhs.is_a? Rational diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index f9470de86..fcaba3df5 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/mrbgems/mruby-rational/src/rational.c @@ -200,7 +200,7 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb) mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE()); mrb_define_method(mrb, rat, "to_r", rational_to_r, MRB_ARGS_NONE()); mrb_define_method(mrb, rat, "negative?", rational_negative_p, MRB_ARGS_NONE()); - mrb_define_method(mrb, mrb->fixnum_class, "to_r", fix_to_r, MRB_ARGS_NONE()); + mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE()); } void diff --git a/mrbgems/mruby-rational/test/rational.rb b/mrbgems/mruby-rational/test/rational.rb index a8ebb8ea2..3fb4e4e82 100644 --- a/mrbgems/mruby-rational/test/rational.rb +++ b/mrbgems/mruby-rational/test/rational.rb @@ -143,7 +143,7 @@ assert 'Rational#==, Rational#!=' do assert_equal_rational(false, 1r, ComplexLikeNumeric.new(2)) end -assert 'Fixnum#==(Rational), Fixnum#!=(Rational)' do +assert 'Integer#==(Rational), Integer#!=(Rational)' do assert_equal_rational(true, 2, Rational(4,2)) assert_equal_rational(true, -2, Rational(-4,2)) assert_equal_rational(true, -2, Rational(4,-2)) @@ -186,7 +186,7 @@ assert 'Rational#<=>' do assert_raise(NoMethodError) { 1r <=> ComplexLikeNumeric.new(2) } end -assert 'Fixnum#<=>(Rational)' do +assert 'Integer#<=>(Rational)' do assert_cmp(-1, -2, Rational(-9,5)) assert_cmp(0, 5, 5r) assert_cmp(1, 3, Rational(8,3)) @@ -210,7 +210,7 @@ assert 'Rational#<' do assert_raise(ArgumentError) { 1r < "2" } end -assert 'Fixnum#<(Rational)' do +assert 'Integer#<(Rational)' do assert_not_operator(1, :<, Rational(2,3)) assert_not_operator(2, :<, 2r) assert_operator(-3, :<, Rational(2,3)) @@ -234,7 +234,7 @@ assert 'Rational#<=' do assert_raise(ArgumentError) { 1r <= "2" } end -assert 'Fixnum#<=(Rational)' do +assert 'Integer#<=(Rational)' do assert_not_operator(1, :<=, Rational(2,3)) assert_operator(2, :<=, 2r) assert_operator(-3, :<=, Rational(2,3)) @@ -258,7 +258,7 @@ assert 'Rational#>' do assert_raise(ArgumentError) { 1r > "2" } end -assert 'Fixnum#>(Rational)' do +assert 'Integer#>(Rational)' do assert_operator(1, :>, Rational(2,3)) assert_not_operator(2, :>, 2r) assert_not_operator(-3, :>, Rational(2,3)) @@ -282,7 +282,7 @@ assert 'Rational#>=' do assert_raise(ArgumentError) { 1r >= "2" } end -assert 'Fixnum#>=(Rational)' do +assert 'Integer#>=(Rational)' do assert_operator(1, :>=, Rational(2,3)) assert_operator(2, :>=, 2r) assert_not_operator(-3, :>=, Rational(2,3)) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 001021b81..6542c1603 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -145,7 +145,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass) } else if (mrb_nil_p(service)) { servname = NULL; } else { - mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil"); + mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Integer, or nil"); } memset(&hints, 0, sizeof(hints)); diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 4f50fe5dd..423cf99a5 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/mrbgems/mruby-struct/src/struct.c @@ -604,8 +604,8 @@ mrb_struct_eql(mrb_state *mrb, mrb_value s) /* * call-seq: - * struct.length -> Fixnum - * struct.size -> Fixnum + * struct.length -> Integer + * struct.size -> Integer * * Returns number of struct members. */ diff --git a/mrblib/range.rb b/mrblib/range.rb index 392cc2274..9f94f35d1 100644 --- a/mrblib/range.rb +++ b/mrblib/range.rb @@ -15,7 +15,7 @@ class Range val = self.first last = self.last - if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special + if val.kind_of?(Integer) && last.kind_of?(Integer) # fixnums are special lim = last lim += 1 unless exclude_end? i = val diff --git a/src/class.c b/src/class.c index 845246e97..df33feffb 100644 --- a/src/class.c +++ b/src/class.c @@ -638,8 +638,8 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); z: String [const char*] NUL terminated string; z! gives NULL for nil a: Array [mrb_value*,mrb_int] Receive two arguments; a! gives (NULL,0) for nil c: Class/Module [strcut RClass*] - f: Fixnum/Float [mrb_float] - i: Fixnum/Float [mrb_int] + f: Integer/Float [mrb_float] + i: Integer/Float [mrb_int] b: boolean [mrb_bool] n: String/Symbol [mrb_sym] d: data [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified; when ! follows, the value may be nil @@ -1874,7 +1874,7 @@ mrb_module_new(mrb_state *mrb) * called with an explicit receiver, as class is also a * reserved word in Ruby. * - * 1.class #=> Fixnum + * 1.class #=> Integer * self.class #=> Object */ diff --git a/src/gc.c b/src/gc.c index 50269f95c..fd472217e 100644 --- a/src/gc.c +++ b/src/gc.c @@ -932,7 +932,7 @@ root_scan_phase(mrb_state *mrb, mrb_gc *gc) #ifndef MRB_NO_FLOAT mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class); #endif - mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class); + mrb_gc_mark(mrb, (struct RBasic*)mrb->integer_class); mrb_gc_mark(mrb, (struct RBasic*)mrb->true_class); mrb_gc_mark(mrb, (struct RBasic*)mrb->false_class); mrb_gc_mark(mrb, (struct RBasic*)mrb->nil_class); diff --git a/src/kernel.c b/src/kernel.c index 020bce226..699c681d7 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -209,7 +209,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self) * called with an explicit receiver, as class is also a * reserved word in Ruby. * - * 1.class #=> Fixnum + * 1.class #=> Integer * self.class #=> Object */ static mrb_value @@ -341,7 +341,7 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj) * behavior will be documented under the #+initialize_copy+ method of * the class. * - * Some Class(True False Nil Symbol Fixnum Float) Object cannot clone. + * Some Class(True False Nil Symbol Integer Float) Object cannot clone. */ MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self) @@ -480,11 +480,11 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self) * call-seq: * obj.hash -> fixnum * - * Generates a Fixnum hash value for this object. This + * Generates a Integer hash value for this object. This * function must have the property that a.eql?(b) implies * a.hash == b.hash. The hash value is used by class * Hash. Any hash value that exceeds the capacity of a - * Fixnum will be truncated before being used. + * Integer will be truncated before being used. */ static mrb_value mrb_obj_hash(mrb_state *mrb, mrb_value self) diff --git a/src/numeric.c b/src/numeric.c index f4ad116a4..40114c07d 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1,5 +1,5 @@ /* -** numeric.c - Numeric, Integer, Float, Fixnum class +** numeric.c - Numeric, Integer, Float class ** ** See Copyright Notice in mruby.h */ @@ -378,7 +378,7 @@ flo_mod(mrb_state *mrb, mrb_value x) * (1.0).eql?(1.0) #=> true */ static mrb_value -fix_eql(mrb_state *mrb, mrb_value x) +int_eql(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -771,8 +771,7 @@ flo_nan_p(mrb_state *mrb, mrb_value num) /* * Document-class: Integer * - * Integer is the basis for the two concrete classes that - * hold whole numbers, Bignum and Fixnum. + * Integer is hold whole numbers. * */ @@ -842,7 +841,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y) */ static mrb_value -fix_mul(mrb_state *mrb, mrb_value x) +int_mul(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -888,7 +887,7 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) */ static mrb_value -fix_mod(mrb_state *mrb, mrb_value x) +int_mod(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); mrb_int a, b; @@ -929,7 +928,7 @@ fix_mod(mrb_state *mrb, mrb_value x) * See Numeric#divmod. */ static mrb_value -fix_divmod(mrb_state *mrb, mrb_value x) +int_divmod(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -992,7 +991,7 @@ flo_divmod(mrb_state *mrb, mrb_value x) */ static mrb_value -fix_equal(mrb_state *mrb, mrb_value x) +int_equal(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -1020,7 +1019,7 @@ fix_equal(mrb_state *mrb, mrb_value x) */ static mrb_value -fix_rev(mrb_state *mrb, mrb_value num) +int_rev(mrb_state *mrb, mrb_value num) { mrb_int val = mrb_fixnum(num); @@ -1050,7 +1049,7 @@ static mrb_value flo_xor(mrb_state *mrb, mrb_value x); */ static mrb_value -fix_and(mrb_state *mrb, mrb_value x) +int_and(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -1066,7 +1065,7 @@ fix_and(mrb_state *mrb, mrb_value x) */ static mrb_value -fix_or(mrb_state *mrb, mrb_value x) +int_or(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -1082,7 +1081,7 @@ fix_or(mrb_state *mrb, mrb_value x) */ static mrb_value -fix_xor(mrb_state *mrb, mrb_value x) +int_xor(mrb_state *mrb, mrb_value x) { mrb_value y = mrb_get_arg1(mrb); @@ -1160,7 +1159,7 @@ rshift(mrb_int val, mrb_int width) */ static mrb_value -fix_lshift(mrb_state *mrb, mrb_value x) +int_lshift(mrb_state *mrb, mrb_value x) { mrb_int width, val; @@ -1185,7 +1184,7 @@ fix_lshift(mrb_state *mrb, mrb_value x) */ static mrb_value -fix_rshift(mrb_state *mrb, mrb_value x) +int_rshift(mrb_state *mrb, mrb_value x) { mrb_int width, val; @@ -1212,7 +1211,7 @@ fix_rshift(mrb_state *mrb, mrb_value x) #ifndef MRB_NO_FLOAT static mrb_value -fix_to_f(mrb_state *mrb, mrb_value num) +int_to_f(mrb_state *mrb, mrb_value num) { return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num)); } @@ -1305,7 +1304,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y) * result. */ static mrb_value -fix_plus(mrb_state *mrb, mrb_value self) +int_plus(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); @@ -1362,7 +1361,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y) * result. */ static mrb_value -fix_minus(mrb_state *mrb, mrb_value self) +int_minus(mrb_state *mrb, mrb_value self) { mrb_value other = mrb_get_arg1(mrb); @@ -1419,7 +1418,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base) * */ static mrb_value -fix_to_s(mrb_state *mrb, mrb_value self) +int_to_s(mrb_state *mrb, mrb_value self) { mrb_int base = 10; @@ -1599,7 +1598,7 @@ flo_plus(mrb_state *mrb, mrb_value x) void mrb_init_numeric(mrb_state *mrb) { - struct RClass *numeric, *integer, *fixnum, *integral; + struct RClass *numeric, *integer, *integral; #ifndef MRB_NO_FLOAT struct RClass *fl; #endif @@ -1622,7 +1621,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, numeric, "infinite?",num_infinite_p, MRB_ARGS_NONE()); /* Integer Class */ - integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ + mrb->integer_class = integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM); mrb_undef_class_method(mrb, integer, "new"); mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */ @@ -1634,26 +1633,27 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.15 (x) */ #endif - /* Fixnum Class */ - mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer); - mrb_define_method(mrb, fixnum, "+", fix_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */ - mrb_define_method(mrb, fixnum, "-", fix_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */ - mrb_define_method(mrb, fixnum, "*", fix_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */ - mrb_define_method(mrb, fixnum, "%", fix_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */ - mrb_define_method(mrb, fixnum, "==", fix_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */ - mrb_define_method(mrb, fixnum, "~", fix_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */ - mrb_define_method(mrb, fixnum, "&", fix_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */ - mrb_define_method(mrb, fixnum, "|", fix_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */ - mrb_define_method(mrb, fixnum, "^", fix_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */ - mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ - mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ - mrb_define_method(mrb, fixnum, "eql?", fix_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ -#ifndef MRB_NO_FLOAT - mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ + mrb_define_method(mrb, integer, "+", int_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */ + mrb_define_method(mrb, integer, "-", int_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */ + mrb_define_method(mrb, integer, "*", int_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */ + mrb_define_method(mrb, integer, "%", int_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */ + mrb_define_method(mrb, integer, "==", int_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */ + mrb_define_method(mrb, integer, "~", int_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */ + mrb_define_method(mrb, integer, "&", int_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */ + mrb_define_method(mrb, integer, "|", int_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */ + mrb_define_method(mrb, integer, "^", int_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */ + mrb_define_method(mrb, integer, "<<", int_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ + mrb_define_method(mrb, integer, ">>", int_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ + mrb_define_method(mrb, integer, "eql?", int_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ +#ifndef MRB_WITHOUT_FLOAT + mrb_define_method(mrb, integer, "to_f", int_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ #endif - mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */ - mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_OPT(1)); - mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */ + 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) */ + + /* Fixnum Class for compatibility */ + mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer)); #ifndef MRB_NO_FLOAT /* Float Class */ diff --git a/src/string.c b/src/string.c index f15770403..a8dfb5503 100644 --- a/src/string.c +++ b/src/string.c @@ -1186,7 +1186,7 @@ range_arg: break; } - mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Fixnum"); + mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Integer"); } } return STR_OUT_OF_RANGE; @@ -1230,8 +1230,8 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen) * str.slice(range) => new_str or nil * str.slice(other_str) => new_str or nil * - * Element Reference---If passed a single Fixnum, returns the code - * of the character at that position. If passed two Fixnum + * Element Reference---If passed a single Integer, returns the code + * of the character at that position. If passed two Integer * objects, returns a substring starting at the offset given by the first, and * a length given by the second. If given a range, a substring containing * characters at offsets given by the range is returned. In all three cases, if diff --git a/test/t/bs_literal.rb b/test/t/bs_literal.rb index c6c38140b..d60957f0b 100644 --- a/test/t/bs_literal.rb +++ b/test/t/bs_literal.rb @@ -34,5 +34,5 @@ assert('BS Literal 8') do end assert('BS Literal 9') do - assert_equal Fixnum, 1234.class + assert_equal Integer, 1234.class end diff --git a/test/t/integer.rb b/test/t/integer.rb index f9c44a64f..620ec94d3 100644 --- a/test/t/integer.rb +++ b/test/t/integer.rb @@ -156,7 +156,7 @@ assert('Integer#<<', '15.2.8.3.12') do skip unless Object.const_defined?(:Float) - # Overflow to Fixnum + # Overflow to Integer assert_float 9223372036854775808.0, 1 << 63 assert_float(-13835058055282163712.0, -3 << 62) end diff --git a/test/t/kernel.rb b/test/t/kernel.rb index 606150147..cab1ddd3d 100644 --- a/test/t/kernel.rb +++ b/test/t/kernel.rb @@ -76,7 +76,7 @@ assert('Kernel.raise', '15.3.1.2.12') do end assert('Kernel#__id__', '15.3.1.3.3') do - assert_equal Fixnum, __id__.class + assert_equal Integer, __id__.class end assert('Kernel#__send__', '15.3.1.3.4') do diff --git a/test/t/module.rb b/test/t/module.rb index 12b7f1344..2957dec52 100644 --- a/test/t/module.rb +++ b/test/t/module.rb @@ -593,7 +593,7 @@ end # to_f / other # end # end - # Fixnum.send(:prepend, M) + # Integer.send(:prepend, M) # assert_equal(0.5, 1 / 2, "#{bug7983}") # } # assert_equal(0, 1 / 2) diff --git a/test/t/vformat.rb b/test/t/vformat.rb index df6950ee6..f645351ee 100644 --- a/test/t/vformat.rb +++ b/test/t/vformat.rb @@ -17,7 +17,7 @@ assert('mrb_vformat') do assert_equal '`t`: NilClass', vf.v('`t`: %t', nil) assert_equal '`t`: FalseClass', vf.v('`t`: %t', false) assert_equal '`t`: TrueClass', vf.v('`t`: %t', true) - assert_equal '`t`: Fixnum', vf.v('`t`: %t', 0) + assert_equal '`t`: Integer', vf.v('`t`: %t', 0) assert_equal '`t`: Hash', vf.v('`t`: %t', {k: "value"}) assert_match '#>>', vf.v('%t', sclass({})) assert_equal 'string and length', vf.l('string %l length', 'andante', 3) @@ -29,13 +29,13 @@ assert('mrb_vformat') do assert_equal '`T`: NilClass', vf.v('`T`: %T', nil) assert_equal '`T`: FalseClass', vf.v('`T`: %T', false) assert_equal '`T`: TrueClass', vf.v('`T`: %T', true) - assert_equal '`T`: Fixnum', vf.v('`T`: %T', 0) + assert_equal '`T`: Integer', vf.v('`T`: %T', 0) assert_equal '`T`: Hash', vf.v('`T`: %T', {k: "value"}) assert_match 'Class', vf.v('%T', sclass({})) assert_equal '`Y`: nil', vf.v('`Y`: %Y', nil) assert_equal '`Y`: false', vf.v('`Y`: %Y', false) assert_equal '`Y`: true', vf.v('`Y`: %Y', true) - assert_equal '`Y`: Fixnum', vf.v('`Y`: %Y', 0) + assert_equal '`Y`: Integer', vf.v('`Y`: %Y', 0) assert_equal '`Y`: Hash', vf.v('`Y`: %Y', {k: "value"}) assert_equal 'Class', vf.v('%Y', sclass({})) assert_match '#>', vf.v('%v', sclass("")) -- cgit v1.2.3 From 8bd1bc47b3e92bfc1c21c698dd7392d8b49a02ef Mon Sep 17 00:00:00 2001 From: KOBAYASHI Shuji Date: Fri, 25 Oct 2019 19:29:19 +0900 Subject: Always add trailing `.0` in `Float#inspect`; ref #4225 Trailing `.0` is removed from `Float#to_s` and `Float#inspect` at 9d08025b. However, I think the more human-readable format is better for `Float#inspect`. For example, in the `Float#to_s` format, the failure message is not well understood when testing values including types by `eql?` (e.g. `Numeric#step` test). ```ruby assert "example" do exp = 1.0 act = 1 assert_operator(exp, :eql?, act) #=> Expected 1 to be eql? 1. end ``` --- src/numeric.c | 61 +++++++++++++++++++++++++++++++++++++++++++++------------ test/t/float.rb | 5 +++++ 2 files changed, 53 insertions(+), 13 deletions(-) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index 40114c07d..617348254 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -203,19 +203,8 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self) * representation. */ -/* 15.2.9.3.16(x) */ -/* - * call-seq: - * flt.to_s -> string - * - * Returns a string containing a representation of self. As well as a - * fixed or exponential form of the number, the call may return - * "NaN", "Infinity", and - * "-Infinity". - */ - static mrb_value -flo_to_s(mrb_state *mrb, mrb_value flt) +flo_to_str(mrb_state *mrb, mrb_value flt, mrb_bool add_dot_zero) { mrb_float f = mrb_float(flt); mrb_value str; @@ -258,6 +247,9 @@ flo_to_s(mrb_state *mrb, mrb_value flt) str = mrb_float_to_str(mrb, flt, fmt); goto insert_dot_zero; } + else if (add_dot_zero) { + mrb_str_cat(mrb, str, ".0", 2); + } goto exit; } @@ -267,6 +259,49 @@ flo_to_s(mrb_state *mrb, mrb_value flt) return str; } +/* 15.2.9.3.16(x) */ +/* + * call-seq: + * flt.to_s -> string + * + * Returns a string containing a representation of self. As well as a + * fixed or exponential form of the number, the call may return + * "NaN", "Infinity", and + * "-Infinity". + * + * Trailing .0 is removed. + * + * 3.0.to_s #=> 3 + * 3.25.to_s #=> 3.25 + */ + +static mrb_value +flo_to_s(mrb_state *mrb, mrb_value flt) +{ + return flo_to_str(mrb, flt, FALSE); +} + +/* + * call-seq: + * flt.inspect -> string + * + * Returns a string containing a representation of self. As well as a + * fixed or exponential form of the number, the call may return + * "NaN", "Infinity", and + * "-Infinity". + * + * Trailing .0 is added. + * + * 3.0.to_s #=> 3.0 + * 3.25.to_s #=> 3.25 + */ + +static mrb_value +flo_inspect(mrb_state *mrb, mrb_value flt) +{ + return flo_to_str(mrb, flt, TRUE); +} + /* 15.2.9.3.2 */ /* * call-seq: @@ -1684,7 +1719,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, fl, "eql?", flo_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ mrb_define_method(mrb, fl, "to_s", flo_to_s, MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */ - mrb_define_method(mrb, fl, "inspect", flo_to_s, MRB_ARGS_NONE()); + mrb_define_method(mrb, fl, "inspect", flo_inspect, MRB_ARGS_NONE()); mrb_define_method(mrb, fl, "nan?", flo_nan_p, MRB_ARGS_NONE()); #ifdef INFINITY diff --git a/test/t/float.rb b/test/t/float.rb index 1cbc90532..e2a8a5088 100644 --- a/test/t/float.rb +++ b/test/t/float.rb @@ -239,6 +239,11 @@ assert('Float#to_s') do end end +assert('Float#inspect') do + assert_equal("-3.25", -3.25.inspect) + assert_equal("50.0", 50.0.inspect) +end + assert('Float#eql?') do assert_operator(5.0, :eql?, 5.0) assert_not_operator(5.0, :eql?, 5) -- cgit v1.2.3 From 55163a8a0a5737e9113f16d0f03b7ab4258706ba Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 21:32:36 +0900 Subject: Rename `MRB_TT_FIXNUM` to `MRB_TT_INTEGER`. We still have `#define MRB_TT_FIXNUM MRB_TT_INTEGER` for compatibility. --- include/mruby/boxing_nan.h | 2 +- include/mruby/boxing_no.h | 2 +- include/mruby/boxing_word.h | 2 +- include/mruby/class.h | 2 +- include/mruby/value.h | 7 +++++-- mrbgems/mruby-array-ext/src/array.c | 2 +- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- mrbgems/mruby-io/src/io.c | 4 ++-- mrbgems/mruby-objectspace/src/mruby_objectspace.c | 2 +- mrbgems/mruby-os-memsize/src/memsize.c | 2 +- mrbgems/mruby-sprintf/src/sprintf.c | 2 +- mrbgems/mruby-time/src/time.c | 2 +- src/array.c | 2 +- src/class.c | 2 +- src/etc.c | 2 +- src/gc.c | 2 +- src/hash.c | 4 ++-- src/numeric.c | 14 +++++++------- src/object.c | 8 ++++---- src/range.c | 6 +++--- src/string.c | 4 ++-- src/vm.c | 20 ++++++++++---------- 22 files changed, 50 insertions(+), 47 deletions(-) (limited to 'src/numeric.c') diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index eb89ac1f9..f013ed7fa 100644 --- a/include/mruby/boxing_nan.h +++ b/include/mruby/boxing_nan.h @@ -104,7 +104,7 @@ 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_FIXNUM, i, (uint32_t)(n)) +#define SET_INT_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 diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index 345f6b35b..ff3d9f787 100644 --- a/include/mruby/boxing_no.h +++ b/include/mruby/boxing_no.h @@ -42,7 +42,7 @@ 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_FIXNUM, value.i, (n)) +#define SET_INT_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 diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index b9b6a3fe9..e68d8148b 100644 --- a/include/mruby/boxing_word.h +++ b/include/mruby/boxing_word.h @@ -173,7 +173,7 @@ mrb_type(mrb_value o) { return !mrb_bool(o) ? MRB_TT_FALSE : mrb_true_p(o) ? MRB_TT_TRUE : - mrb_fixnum_p(o) ? MRB_TT_FIXNUM : + mrb_fixnum_p(o) ? MRB_TT_INTEGER : mrb_symbol_p(o) ? MRB_TT_SYMBOL : mrb_undef_p(o) ? MRB_TT_UNDEF : mrb_val_union(o).bp->tt; diff --git a/include/mruby/class.h b/include/mruby/class.h index b4b5454d5..19c2e1b7b 100644 --- a/include/mruby/class.h +++ b/include/mruby/class.h @@ -35,7 +35,7 @@ mrb_class(mrb_state *mrb, mrb_value v) return mrb->true_class; case MRB_TT_SYMBOL: return mrb->symbol_class; - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb->integer_class; #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: diff --git a/include/mruby/value.h b/include/mruby/value.h index 88c8d4dba..933e5a3ec 100644 --- a/include/mruby/value.h +++ b/include/mruby/value.h @@ -106,7 +106,7 @@ enum mrb_vtype { MRB_TT_FALSE = 0, MRB_TT_TRUE, MRB_TT_FLOAT, - MRB_TT_FIXNUM, + MRB_TT_INTEGER, MRB_TT_SYMBOL, MRB_TT_UNDEF, MRB_TT_CPTR, @@ -130,6 +130,9 @@ enum mrb_vtype { MRB_TT_MAXDEFINE }; +/* for compatibility */ +#define MRB_TT_FIXNUM MRB_TT_INTEGER + #include #ifdef MRB_DOCUMENTATION_BLOCK @@ -178,7 +181,7 @@ struct RCptr { #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE) #endif #ifndef mrb_fixnum_p -#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM) +#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_INTEGER) #endif #ifndef mrb_symbol_p #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL) diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c index 996679b6e..9d7f1b28a 100644 --- a/mrbgems/mruby-array-ext/src/array.c +++ b/mrbgems/mruby-array-ext/src/array.c @@ -148,7 +148,7 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self) else { return mrb_nil_value(); } - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index); return val; default: diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 372a2c5f7..72ae0a3a9 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -543,7 +543,7 @@ new_lit(codegen_scope *s, mrb_value val) } break; #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: for (i=0; iirep->plen; i++) { mrb_int v = mrb_fixnum(val); pv = &s->pool[i]; @@ -594,7 +594,7 @@ new_lit(codegen_scope *s, mrb_value val) pv->u.f = mrb_float(val); break; #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_INT64 pv->tt = IREP_TT_INT64; pv->u.i64 = mrb_fixnum(val); diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 587e195d9..712fea79c 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/mrbgems/mruby-io/src/io.c @@ -338,7 +338,7 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key) switch (mrb_type(opt)) { case MRB_TT_DATA: /* IO */ return mrb_io_fileno(mrb, opt); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (int)mrb_fixnum(opt); default: mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action"); @@ -1076,7 +1076,7 @@ time2timeval(mrb_state *mrb, mrb_value time) struct timeval t = { 0, 0 }; switch (mrb_type(time)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: t.tv_sec = (ftime_t)mrb_fixnum(time); t.tv_usec = 0; break; diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c index 16edafced..d8013c20f 100644 --- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c +++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c @@ -81,7 +81,7 @@ os_count_objects(mrb_state *mrb, mrb_value self) COUNT_TYPE(T_FALSE); COUNT_TYPE(T_FREE); COUNT_TYPE(T_TRUE); - COUNT_TYPE(T_FIXNUM); + COUNT_TYPE(T_INTEGER); COUNT_TYPE(T_SYMBOL); COUNT_TYPE(T_UNDEF); COUNT_TYPE(T_FLOAT); diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c index 78ef1e4df..625ffb258 100644 --- a/mrbgems/mruby-os-memsize/src/memsize.c +++ b/mrbgems/mruby-os-memsize/src/memsize.c @@ -144,7 +144,7 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj) * immediate VM stack values, contained within mrb_state, or on C stack */ case MRB_TT_TRUE: case MRB_TT_FALSE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_BREAK: case MRB_TT_CPTR: case MRB_TT_SYMBOL: diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 1f3ffc09a..362d16d1b 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -872,7 +872,7 @@ retry: case MRB_TT_STRING: val = mrb_str_to_inum(mrb, val, 0, TRUE); goto bin_retry; - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: v = mrb_fixnum(val); break; default: diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 3d5cdca2e..8a4f1d233 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -252,7 +252,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec) break; #endif /* MRB_NO_FLOAT */ default: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: { mrb_int i = mrb_int(mrb, obj); diff --git a/src/array.c b/src/array.c index 432599bf7..cd0b59ac2 100644 --- a/src/array.c +++ b/src/array.c @@ -885,7 +885,7 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self) else { return mrb_nil_value(); } - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_ary_ref(mrb, self, mrb_fixnum(index)); default: return mrb_ary_ref(mrb, self, aget_index(mrb, index)); diff --git a/src/class.c b/src/class.c index df33feffb..dd713ed7e 100644 --- a/src/class.c +++ b/src/class.c @@ -1342,7 +1342,7 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) case MRB_TT_CPTR: return mrb->object_class; case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif diff --git a/src/etc.c b/src/etc.c index b0019e6de..e9990bec5 100644 --- a/src/etc.c +++ b/src/etc.c @@ -114,7 +114,7 @@ mrb_obj_id(mrb_value obj) return MakeID(2); case MRB_TT_SYMBOL: return MakeID(mrb_symbol(obj)); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_NO_FLOAT return MakeID(mrb_fixnum_id(mrb_fixnum(obj))); #else diff --git a/src/gc.c b/src/gc.c index fd472217e..393f7f62c 100644 --- a/src/gc.c +++ b/src/gc.c @@ -779,7 +779,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end) switch (obj->tt) { /* immediate - no mark */ case MRB_TT_TRUE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_SYMBOL: /* cannot happen */ return; diff --git a/src/hash.c b/src/hash.c index 84ed00001..79cec4b71 100644 --- a/src/hash.c +++ b/src/hash.c @@ -64,7 +64,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key) case MRB_TT_TRUE: case MRB_TT_FALSE: case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif @@ -95,7 +95,7 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b) if (!mrb_symbol_p(b)) return FALSE; return mrb_symbol(a) == mrb_symbol(b); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: if (!mrb_fixnum_p(b)) return FALSE; return mrb_fixnum(a) == mrb_fixnum(b); diff --git a/src/numeric.c b/src/numeric.c index 617348254..99d32f919 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -35,7 +35,7 @@ MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value val) { switch (mrb_type(val)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (mrb_float)mrb_fixnum(val); case MRB_TT_FLOAT: break; @@ -450,7 +450,7 @@ flo_eq(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); case MRB_TT_FLOAT: return mrb_bool_value(mrb_float(x) == mrb_float(y)); @@ -463,7 +463,7 @@ static int64_t value_int64(mrb_state *mrb, mrb_value x) { switch (mrb_type(x)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (int64_t)mrb_fixnum(x); case MRB_TT_FLOAT: return (int64_t)mrb_float(x); @@ -1031,7 +1031,7 @@ int_equal(mrb_state *mrb, mrb_value x) mrb_value y = mrb_get_arg1(mrb); switch (mrb_type(y)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); #ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: @@ -1477,7 +1477,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2) x = mrb_to_flo(mrb, v1); #endif switch (mrb_type(v2)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: #ifdef MRB_NO_FLOAT y = mrb_fixnum(v2); #else @@ -1584,7 +1584,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2) mrb_value v; switch (mrb_type(obj1)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: case MRB_TT_FLOAT: return cmpnum(mrb, obj1, obj2); case MRB_TT_STRING: @@ -1657,7 +1657,7 @@ mrb_init_numeric(mrb_state *mrb) /* Integer Class */ mrb->integer_class = integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ - MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM); + MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER); mrb_undef_class_method(mrb, integer, "new"); 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()); diff --git a/src/object.c b/src/object.c index 634f70830..a6357a6a8 100644 --- a/src/object.c +++ b/src/object.c @@ -19,7 +19,7 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2) return TRUE; case MRB_TT_FALSE: - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return (mrb_fixnum(v1) == mrb_fixnum(v2)); case MRB_TT_SYMBOL: return (mrb_symbol(v1) == mrb_symbol(v2)); @@ -322,7 +322,7 @@ static const struct types { /* {MRB_TT_NIL, "nil"}, */ {MRB_TT_FALSE, "false"}, {MRB_TT_TRUE, "true"}, - {MRB_TT_FIXNUM, "Fixnum"}, + {MRB_TT_INTEGER,"Integer"}, {MRB_TT_SYMBOL, "Symbol"}, /* :symbol */ {MRB_TT_MODULE, "Module"}, {MRB_TT_OBJECT, "Object"}, @@ -536,7 +536,7 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base) return mrb_flo_to_fixnum(mrb, val); #endif - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: if (base != 0) goto arg_error; return val; @@ -574,7 +574,7 @@ mrb_Float(mrb_state *mrb, mrb_value val) mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float"); } switch (mrb_type(val)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val)); case MRB_TT_FLOAT: diff --git a/src/range.c b/src/range.c index 8f09eda24..0a76c9939 100644 --- a/src/range.c +++ b/src/range.c @@ -24,10 +24,10 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b) ta = mrb_type(a); tb = mrb_type(b); #ifdef MRB_NO_FLOAT - if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) { + if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) { #else - if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) && - (tb == MRB_TT_FIXNUM || tb == MRB_TT_FLOAT)) { + if ((ta == MRB_TT_INTEGER || ta == MRB_TT_FLOAT) && + (tb == MRB_TT_INTEGER || tb == MRB_TT_FLOAT)) { #endif return; } diff --git a/src/string.c b/src/string.c index a8dfb5503..e88ba2be5 100644 --- a/src/string.c +++ b/src/string.c @@ -1093,7 +1093,7 @@ mrb_str_to_str(mrb_state *mrb, mrb_value str) return str; case MRB_TT_SYMBOL: return mrb_sym_str(mrb, mrb_symbol(str)); - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: return mrb_fixnum_to_str(mrb, str, 10); case MRB_TT_SCLASS: case MRB_TT_CLASS: @@ -1154,7 +1154,7 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen, } else { switch (mrb_type(indx)) { - case MRB_TT_FIXNUM: + case MRB_TT_INTEGER: *beg = mrb_fixnum(indx); *len = 1; return STR_CHAR_RANGE; diff --git a/src/vm.c b/src/vm.c index 401d52414..979c67424 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2256,7 +2256,7 @@ RETRY_TRY_BLOCK: } \ NEXT; #define OP_MATH_CASE_FIXNUM(op_name) \ - case TYPES2(MRB_TT_FIXNUM, MRB_TT_FIXNUM): \ + case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER): \ { \ mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ @@ -2289,7 +2289,7 @@ RETRY_TRY_BLOCK: #define OP_MATH_OP_add + #define OP_MATH_OP_sub - #define OP_MATH_OP_mul * -#define OP_MATH_TT_fixnum MRB_TT_FIXNUM +#define OP_MATH_TT_fixnum MRB_TT_INTEGER #define OP_MATH_TT_float MRB_TT_FLOAT CASE(OP_ADD, B) { @@ -2311,7 +2311,7 @@ RETRY_TRY_BLOCK: /* need to check if op is overridden */ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) { - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM): + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER): { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); @@ -2345,11 +2345,11 @@ RETRY_TRY_BLOCK: } NEXT; #ifndef MRB_NO_FLOAT - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT): + case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT): x = (mrb_float)mrb_fixnum(regs[a]); y = mrb_float(regs[a+1]); break; - case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM): + case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER): x = mrb_float(regs[a]); y = (mrb_float)mrb_fixnum(regs[a+1]); break; @@ -2391,7 +2391,7 @@ RETRY_TRY_BLOCK: } \ NEXT; #define OP_MATHI_CASE_FIXNUM(op_name) \ - case MRB_TT_FIXNUM: \ + case MRB_TT_INTEGER: \ { \ mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z; \ if (mrb_int_##op_name##_overflow(x, y, &z)) \ @@ -2427,7 +2427,7 @@ RETRY_TRY_BLOCK: int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\ break;\ default:\ @@ -2447,13 +2447,13 @@ RETRY_TRY_BLOCK: int result;\ /* need to check if - is overridden */\ switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\ break;\ - case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\ + case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\ result = OP_CMP_BODY(op,mrb_fixnum,mrb_float);\ break;\ - case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):\ + case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\ result = OP_CMP_BODY(op,mrb_float,mrb_fixnum);\ break;\ case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\ -- cgit v1.2.3 From 2a92fb2516251fb0ddfa2d1026930a2c7465e528 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Tue, 18 Aug 2020 22:12:28 +0900 Subject: Make division by zero cause `ZeroDivisionError`. As described in ISO 15.2.30. --- doc/limitations.md | 9 ++++++++- include/mruby.h | 1 + mrblib/10error.rb | 4 ++++ src/numeric.c | 20 +++----------------- src/vm.c | 13 +++++++------ test/t/superclass.rb | 2 +- 6 files changed, 24 insertions(+), 25 deletions(-) (limited to 'src/numeric.c') diff --git a/doc/limitations.md b/doc/limitations.md index 7e58ca420..8ac959b98 100644 --- a/doc/limitations.md +++ b/doc/limitations.md @@ -63,8 +63,15 @@ end #### mruby [2.1.2 (2020-08-06)] -No exception is raised. +No exception is raised. Instead you have to do: +```ruby +begin + 1 / 0 +rescue => e + raise e +end +``` ## Fiber execution can't cross C function boundary mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This diff --git a/include/mruby.h b/include/mruby.h index f07adbb13..959d1ac6d 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -1292,6 +1292,7 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap); */ #define E_RUNTIME_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RuntimeError))) #define E_TYPE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(TypeError))) +#define E_ZERODIV_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ZeroDivisionError))) #define E_ARGUMENT_ERROR (mrb_exc_get_id(mrb, MRB_SYM(ArgumentError))) #define E_INDEX_ERROR (mrb_exc_get_id(mrb, MRB_SYM(IndexError))) #define E_RANGE_ERROR (mrb_exc_get_id(mrb, MRB_SYM(RangeError))) diff --git a/mrblib/10error.rb b/mrblib/10error.rb index 0d9f38d58..054603514 100644 --- a/mrblib/10error.rb +++ b/mrblib/10error.rb @@ -21,6 +21,10 @@ end class TypeError < StandardError end +# ISO 15.2.30 +class ZeroDivisionError < StandardError +end + # ISO 15.2.31 class NameError < StandardError attr_accessor :name diff --git a/src/numeric.c b/src/numeric.c index 99d32f919..0cc7958e6 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -156,7 +156,7 @@ integral_div(mrb_state *mrb, mrb_value xv) mrb_get_args(mrb, "i", &y); if (y == 0) { - mrb_raise(mrb, E_RUNTIME_ERROR, "devided by zero"); + mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero"); } return mrb_fixnum_value(mrb_fixnum(xv) / y); #else @@ -932,14 +932,7 @@ int_mod(mrb_state *mrb, mrb_value x) mrb_int mod; if (b == 0) { -#ifdef MRB_NO_FLOAT - /* ZeroDivisionError */ - return mrb_fixnum_value(0); -#else - if (a > 0) return mrb_float_value(mrb, INFINITY); - if (a < 0) return mrb_float_value(mrb, INFINITY); - return mrb_float_value(mrb, NAN); -#endif + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, a, b, NULL, &mod); return mrb_fixnum_value(mod); @@ -971,14 +964,7 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_int div, mod; if (mrb_fixnum(y) == 0) { -#ifdef MRB_NO_FLOAT - return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0)); -#else - return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ? - mrb_float_value(mrb, NAN): - mrb_float_value(mrb, INFINITY)), - mrb_float_value(mrb, NAN)); -#endif + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); diff --git a/src/vm.c b/src/vm.c index 979c67424..15a38c0e4 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2315,12 +2315,13 @@ RETRY_TRY_BLOCK: { mrb_int x = mrb_fixnum(regs[a]); mrb_int y = mrb_fixnum(regs[a+1]); - if (y == 0 || (x == MRB_INT_MIN && y == -1)) { -#ifdef MRB_NO_FLOAT - SET_INT_VALUE(regs[a], y ? x / y : 0); -#else - SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x / (mrb_float)y); -#endif + + + if (y == 0) { + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); + } + else if(x == MRB_INT_MIN && y == -1) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); } else { mrb_int div, mod; diff --git a/test/t/superclass.rb b/test/t/superclass.rb index 10b6438d3..70d5c24d9 100644 --- a/test/t/superclass.rb +++ b/test/t/superclass.rb @@ -29,7 +29,7 @@ [:RegexpError, :StandardError, '12.2.27.2'], [:RuntimeError, :StandardError, '12.2.28.2'], [:TypeError, :StandardError, '12.2.29.2'], -# [:ZeroDivisionError, :StandardError, '12.2.30.2'], # No ZeroDivisionError in mruby + [:ZeroDivisionError, :StandardError, '12.2.30.2'], [:NameError, :StandardError, '15.2.31.2'], [:NoMethodError, :NameError, '15.2.32.2'], [:IndexError, :StandardError, '15.2.33.2'], -- cgit v1.2.3 From 2b188ed8a191257f23ddf6f8a27bf1d3964587ed Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 26 Aug 2020 17:53:04 +0900 Subject: 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 | 2 +- include/mruby/boxing_nan.h | 3 +- include/mruby/boxing_no.h | 4 +- include/mruby/boxing_word.h | 20 +- include/mruby/numeric.h | 5 +- include/mruby/value.h | 30 ++- mrbgems/mruby-compiler/core/codegen.c | 6 +- mrbgems/mruby-enumerator/test/enumerator.rb | 2 +- mrbgems/mruby-inline-struct/test/inline.c | 2 +- mrbgems/mruby-io/src/io.c | 4 +- mrbgems/mruby-numeric-ext/src/numeric_ext.c | 2 +- mrbgems/mruby-pack/src/pack.c | 10 +- mrbgems/mruby-random/src/random.c | 16 +- mrbgems/mruby-range-ext/src/range.c | 14 +- mrbgems/mruby-rational/mrblib/rational.rb | 17 +- mrbgems/mruby-rational/src/rational.c | 14 +- mrbgems/mruby-socket/src/socket.c | 30 +-- mrbgems/mruby-sprintf/src/sprintf.c | 10 +- mrbgems/mruby-string-ext/src/string.c | 4 +- mrbgems/mruby-struct/src/struct.c | 4 +- mrbgems/mruby-test/driver.c | 4 +- mrbgems/mruby-time/src/time.c | 11 +- mrblib/numeric.rb | 47 +++- src/array.c | 6 +- src/class.c | 2 +- src/etc.c | 49 +++-- src/hash.c | 6 +- src/numeric.c | 329 +++++++++++++++------------- src/object.c | 14 +- src/range.c | 4 +- src/string.c | 12 +- src/vm.c | 38 ++-- target/boxing.rb | 24 +- test/t/array.rb | 3 +- test/t/integer.rb | 38 +--- 35 files changed, 425 insertions(+), 361 deletions(-) (limited to 'src/numeric.c') diff --git a/include/mruby.h b/include/mruby.h index 4ac26bfe9..dda0fad68 100644 --- a/include/mruby.h +++ b/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); diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h index f013ed7fa..adbfb0f55 100644 --- a/include/mruby/boxing_nan.h +++ b/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 diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h index ff3d9f787..0b14590d9 100644 --- a/include/mruby/boxing_no.h +++ b/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 diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h index e43665e94..433fbd094 100644 --- a/include/mruby/boxing_word.h +++ b/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;\ diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h index b8cc5b50f..f88868796 100644 --- a/include/mruby/numeric.h +++ b/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); diff --git a/include/mruby/value.h b/include/mruby/value.h index 933e5a3ec..698c83300 100644 --- a/include/mruby/value.h +++ b/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; } diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 72ae0a3a9..2e39817ec 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/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; iirep->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; diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb index ecd6c4d65..26d5766fc 100644 --- a/mrbgems/mruby-enumerator/test/enumerator.rb +++ b/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 = [] diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c index b4d9b1f1e..6764b1af4 100644 --- a/mrbgems/mruby-inline-struct/test/inline.c +++ b/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 diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c index 712fea79c..97bff31b4 100644 --- a/mrbgems/mruby-io/src/io.c +++ b/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; diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c index d00be4b5d..e5ec90866 100644 --- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c +++ b/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)); diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c index f797b599b..35e79d25d 100644 --- a/mrbgems/mruby-pack/src/pack.c +++ b/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 */ diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 39c72ac9e..5fa15c508 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/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(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 diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c index fcaba3df5..5b1bec9e2 100644 --- a/mrbgems/mruby-rational/src/rational.c +++ b/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) diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index 6542c1603..d94573c96 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/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); diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 4df3e3a17..9ac8a512d 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/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); diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c index 71fb5bb65..4b8f99597 100644 --- a/mrbgems/mruby-string-ext/src/string.c +++ b/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 diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c index 1189381cb..7c6f50090 100644 --- a/mrbgems/mruby-struct/src/struct.c +++ b/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); diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index 4b82a9abc..b22888ec5 100644 --- a/mrbgems/mruby-test/driver.c +++ b/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) \ diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 8a4f1d233..2af86b14e 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/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); } diff --git a/mrblib/numeric.rb b/mrblib/numeric.rb index 5926518d5..e28d63324 100644 --- a/mrblib/numeric.rb +++ b/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 diff --git a/src/array.c b/src/array.c index cd0b59ac2..c4bc554ef 100644 --- a/src/array.c +++ b/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)); } diff --git a/src/class.c b/src/class.c index 500e7f953..779a02da9 100644 --- a/src/class.c +++ b/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; diff --git a/src/etc.c b/src/etc.c index e9990bec5..96f95ad5f 100644 --- a/src/etc.c +++ b/src/etc.c @@ -8,6 +8,7 @@ #include #include #include +#include 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)) diff --git a/src/hash.c b/src/hash.c index 79cec4b71..d67fa6254 100644 --- a/src/hash.c +++ b/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: diff --git a/src/numeric.c b/src/numeric.c index 0cc7958e6..8fb144fae 100644 --- a/src/numeric.c +++ b/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 - - 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; + mrb_value y; + mrb_float z; - if (exp < 0) -#ifdef MRB_NO_FLOAT - return mrb_fixnum_value(0); -#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_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_fixnum_value(result); } -#ifdef MRB_NO_FLOAT - mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); + return mrb_int_value(mrb, (mrb_int)z); #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); + mrb_int result = 1; - if (!mrb_fixnum_p(y)) { - mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); + mrb_get_args(mrb, "i", &exp); + if (exp < 0) { + return mrb_fixnum_value(0); } - 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); + for (;;) { + if (exp & 1) { + if (mrb_int_mul_overflow(result, base, &result)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + } + exp >>= 1; + if (exp == 0) break; + if (mrb_int_mul_overflow(base, base, &base)) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + } + 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 num 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 } diff --git a/src/object.c b/src/object.c index a6357a6a8..95bd1c737 100644 --- a/src/object.c +++ b/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; diff --git a/src/range.c b/src/range.c index 0a76c9939..c06a8a00b 100644 --- a/src/range.c +++ b/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; diff --git a/src/string.c b/src/string.c index e88ba2be5..a8072f7a7 100644 --- a/src/string.c +++ b/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; } diff --git a/src/vm.c b/src/vm.c index 15a38c0e4..540ba7681 100644 --- a/src/vm.c +++ b/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 diff --git a/target/boxing.rb b/target/boxing.rb index 509c0d4b6..e3bf3425b 100644 --- a/target/boxing.rb +++ b/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 diff --git a/test/t/array.rb b/test/t/array.rb index eec31d751..2982cab01 100644 --- a/test/t/array.rb +++ b/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 diff --git a/test/t/integer.rb b/test/t/integer.rb index 620ec94d3..5204eb91b 100644 --- a/test/t/integer.rb +++ b/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 -- cgit v1.2.3 From 5134031e189e1cdde198e1c09f7b1d22bf2a1ce0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 27 Aug 2020 09:42:26 +0900 Subject: Use `mrb_int_value()` instead of `mrb_fixnum_value()`. Where fixnum overflow can happen. --- mrbgems/mruby-compiler/core/codegen.c | 4 ++-- mrbgems/mruby-io/src/file.c | 2 +- mrbgems/mruby-io/src/file_test.c | 4 ++-- mrbgems/mruby-random/src/random.c | 6 +++--- mrbgems/mruby-rational/src/rational.c | 6 +++--- mrbgems/mruby-socket/src/socket.c | 4 ++-- mrbgems/mruby-sprintf/src/sprintf.c | 4 ++-- mrbgems/mruby-test/driver.c | 2 +- mrbgems/mruby-time/src/time.c | 6 +++--- src/enum.c | 2 +- src/kernel.c | 4 ++-- src/numeric.c | 26 +++++++++++++------------- src/proc.c | 2 +- src/vm.c | 6 +++--- 14 files changed, 39 insertions(+), 39 deletions(-) (limited to 'src/numeric.c') diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c index 2e39817ec..eb37cd701 100644 --- a/mrbgems/mruby-compiler/core/codegen.c +++ b/mrbgems/mruby-compiler/core/codegen.c @@ -2465,7 +2465,7 @@ codegen(codegen_scope *s, node *tree, int val) int off; lit_int: - off = new_lit(s, mrb_fixnum_value(i)); + off = new_lit(s, mrb_int_value(s->mrb, i)); genop_2(s, OP_LOADL, cursp(), off); } } @@ -2528,7 +2528,7 @@ codegen(codegen_scope *s, node *tree, int val) genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i); } else { - int off = new_lit(s, mrb_fixnum_value(i)); + int off = new_lit(s, mrb_int_value(s->mrb, i)); genop_2(s, OP_LOADL, cursp(), off); } #ifndef MRB_NO_FLOAT diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c index a28360d81..d272cab7d 100644 --- a/mrbgems/mruby-io/src/file.c +++ b/mrbgems/mruby-io/src/file.c @@ -399,7 +399,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self) if (mrb_fstat(fd, &st) == -1) return mrb_false_value(); - return mrb_fixnum_value((mrb_int)st.st_mtime); + return mrb_int_value(mrb, (mrb_int)st.st_mtime); } static mrb_value diff --git a/mrbgems/mruby-io/src/file_test.c b/mrbgems/mruby-io/src/file_test.c index 50402a681..f1762369a 100644 --- a/mrbgems/mruby-io/src/file_test.c +++ b/mrbgems/mruby-io/src/file_test.c @@ -304,7 +304,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass) if (mrb_stat(mrb, obj, &st) < 0) mrb_sys_fail(mrb, "mrb_stat"); - return mrb_fixnum_value(st.st_size); + return mrb_int_value(mrb, st.st_size); } /* @@ -326,7 +326,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass) if (st.st_size == 0) return mrb_nil_value(); - return mrb_fixnum_value(st.st_size); + return mrb_int_value(mrb, st.st_size); } void diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c index 37b100084..0a5df6bd0 100644 --- a/mrbgems/mruby-random/src/random.c +++ b/mrbgems/mruby-random/src/random.c @@ -131,7 +131,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max) #endif } else { - value = mrb_fixnum_value(rand_uint32(t) % mrb_integer(max)); + value = mrb_int_value(mrb, rand_uint32(t) % mrb_integer(max)); } return value; @@ -224,7 +224,7 @@ random_m_srand(mrb_state *mrb, mrb_value self) } old_seed = rand_seed(t, seed); - return mrb_fixnum_value((mrb_int)old_seed); + return mrb_int_value(mrb, (mrb_int)old_seed); } /* @@ -378,7 +378,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary) } break; } - mrb_ary_push(mrb, result, mrb_fixnum_value(r)); + mrb_ary_push(mrb, result, mrb_int_value(mrb, r)); } for (i=0; inumerator); + return mrb_int_value(mrb, p->numerator); } static mrb_value rational_denominator(mrb_state *mrb, mrb_value self) { struct mrb_rational *p = rational_ptr(mrb, self); - return mrb_fixnum_value(p->denominator); + return mrb_int_value(mrb, p->denominator); } static mrb_value @@ -154,7 +154,7 @@ rational_to_i(mrb_state *mrb, mrb_value self) if (p->denominator == 0) { mrb_raise(mrb, mrb->eStandardError_class, "divided by 0"); } - return mrb_fixnum_value(p->numerator / p->denominator); + return mrb_int_value(mrb, p->numerator / p->denominator); } static mrb_value diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c index d94573c96..0afbca521 100644 --- a/mrbgems/mruby-socket/src/socket.c +++ b/mrbgems/mruby-socket/src/socket.c @@ -842,7 +842,7 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self) n = send(sd, RSTRING_PTR(str), (int)RSTRING_LEN(str), 0); if (n == SOCKET_ERROR) mrb_sys_fail(mrb, "send"); - return mrb_fixnum_value(n); + return mrb_int_value(mrb, n); } #endif @@ -938,7 +938,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb) #define define_const(SYM) \ do { \ - mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM)); \ + mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM)); \ } while (0) #include "const.cstub" diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c index 9ac8a512d..189b54b5c 100644 --- a/mrbgems/mruby-sprintf/src/sprintf.c +++ b/mrbgems/mruby-sprintf/src/sprintf.c @@ -938,10 +938,10 @@ retry: s = nbuf; if (v < 0) { dots = 1; - val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base); + val = mrb_fix2binstr(mrb, mrb_int_value(mrb, v), base); } else { - val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base); + val = mrb_fixnum_to_str(mrb, mrb_int_value(mrb, v), base); } strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-2); if (v < 0) { diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c index b22888ec5..3bd52e175 100644 --- a/mrbgems/mruby-test/driver.c +++ b/mrbgems/mruby-test/driver.c @@ -254,7 +254,7 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src) res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name)); \ 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_integer(res_dst) + mrb_integer(res_src))); \ + mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_int_value(mrb_dst, mrb_integer(res_dst) + mrb_integer(res_src))); \ } \ } while (FALSE) \ diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c index 2af86b14e..f0347f54f 100644 --- a/mrbgems/mruby-time/src/time.c +++ b/mrbgems/mruby-time/src/time.c @@ -205,7 +205,7 @@ typedef mrb_float mrb_sec; #define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec) #else typedef mrb_int mrb_sec; -#define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec) +#define mrb_sec_value(mrb, sec) mrb_int_value(mrb, sec) #endif #define MRB_TIME_T_UINT (~(time_t)0 > 0) @@ -585,7 +585,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self) mrb_int f; f = tm->sec - tm2->sec; if (tm->usec < tm2->usec) f--; - return mrb_fixnum_value(f); + return mrb_int_value(mrb, f); #endif } else { @@ -873,7 +873,7 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self) return mrb_float_value(mrb, (mrb_float)tm->sec); } #endif - return mrb_fixnum_value((mrb_int)tm->sec); + return mrb_int_value(mrb, (mrb_int)tm->sec); } /* 15.2.19.7.26 */ diff --git a/src/enum.c b/src/enum.c index d31370188..b95956715 100644 --- a/src/enum.c +++ b/src/enum.c @@ -18,7 +18,7 @@ enum_update_hash(mrb_state *mrb, mrb_value self) mrb_get_args(mrb, "iii", &hash, &index, &hv); hash ^= ((uint32_t)hv << (index % 16)); - return mrb_fixnum_value(hash); + return mrb_int_value(mrb, hash); } void diff --git a/src/kernel.c b/src/kernel.c index 699c681d7..a23eeea4e 100644 --- a/src/kernel.c +++ b/src/kernel.c @@ -96,7 +96,7 @@ mrb_equal_m(mrb_state *mrb, mrb_value self) mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_obj_id(self)); + return mrb_int_value(mrb, mrb_obj_id(self)); } static int @@ -489,7 +489,7 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self) static mrb_value mrb_obj_hash(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_obj_id(self)); + return mrb_int_value(mrb, mrb_obj_id(self)); } /* 15.3.1.3.16 */ diff --git a/src/numeric.c b/src/numeric.c index 8fb144fae..a5fb87940 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -131,7 +131,7 @@ int_div(mrb_state *mrb, mrb_value xv) if (y == 0) { mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero"); } - return mrb_fixnum_value(mrb_integer(xv) / y); + return mrb_int_value(mrb, mrb_integer(xv) / y); } } @@ -988,7 +988,7 @@ int_divmod(mrb_state *mrb, mrb_value x) mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); } fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod); - return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); + return mrb_assoc_new(mrb, mrb_int_value(mrb, div), mrb_int_value(mrb, mod)); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); @@ -1065,12 +1065,12 @@ int_rev(mrb_state *mrb, mrb_value num) { mrb_int val = mrb_integer(num); - return mrb_fixnum_value(~val); + return mrb_int_value(mrb, ~val); } #ifdef MRB_NO_FLOAT #define bit_op(x,y,op1,op2) do {\ - return mrb_fixnum_value(mrb_integer(x) op2 mrb_integer(y));\ + return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y)));\ } while(0) #else static mrb_value flo_and(mrb_state *mrb, mrb_value x); @@ -1151,7 +1151,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) goto bit_overflow; #endif } - return mrb_fixnum_value(val << width); + return mrb_int_value(mrb, val << width); } else { if ((width > NUMERIC_SHIFT_WIDTH_MAX) || @@ -1162,7 +1162,7 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width) goto bit_overflow; #endif } - return mrb_fixnum_value(val * ((mrb_int)1 << width)); + return mrb_int_value(mrb, (val * ((mrb_int)1 << width))); } #ifndef MRB_NO_FLOAT @@ -1178,7 +1178,7 @@ bit_overflow: } static mrb_value -rshift(mrb_int val, mrb_int width) +rshift(mrb_state *mrb, mrb_int val, mrb_int width) { if (width < 0) { /* mrb_int overflow */ return mrb_fixnum_value(0); @@ -1189,7 +1189,7 @@ rshift(mrb_int val, mrb_int width) } return mrb_fixnum_value(0); } - return mrb_fixnum_value(val >> width); + return mrb_int_value(mrb, val >> width); } /* 15.2.8.3.12 */ @@ -1212,7 +1212,7 @@ int_lshift(mrb_state *mrb, mrb_value x) val = mrb_integer(x); if (val == 0) return x; if (width < 0) { - return rshift(val, -width); + return rshift(mrb, val, -width); } return lshift(mrb, val, width); } @@ -1239,7 +1239,7 @@ int_rshift(mrb_state *mrb, mrb_value x) if (width < 0) { return lshift(mrb, val, -width); } - return rshift(val, width); + return rshift(mrb, val, width); } /* 15.2.8.3.23 */ @@ -1292,7 +1292,7 @@ mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x) mrb_raisef(mrb, E_RANGE_ERROR, "number (%v) too big for integer", x); } } - return mrb_fixnum_value(z); + return mrb_int_value(mrb, z); } #endif @@ -1312,7 +1312,7 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); #endif } - return mrb_fixnum_value(c); + return mrb_int_value(mrb, c); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); @@ -1368,7 +1368,7 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); #endif } - return mrb_fixnum_value(c); + return mrb_int_value(mrb, c); } #ifdef MRB_NO_FLOAT mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value"); diff --git a/src/proc.c b/src/proc.c index de463df3e..d94044f72 100644 --- a/src/proc.c +++ b/src/proc.c @@ -242,7 +242,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self) static mrb_value proc_arity(mrb_state *mrb, mrb_value self) { - return mrb_fixnum_value(mrb_proc_arity(mrb_proc_ptr(self))); + return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self))); } /* 15.3.1.2.6 */ diff --git a/src/vm.c b/src/vm.c index 540ba7681..52895bd28 100644 --- a/src/vm.c +++ b/src/vm.c @@ -1082,16 +1082,16 @@ RETRY_TRY_BLOCK: CASE(OP_LOADL, BB) { switch (pool[b].tt) { /* number */ case IREP_TT_INT32: - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i32); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32); break; case IREP_TT_INT64: #if defined(MRB_INT64) - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64); break; #else #if defined(MRB_64BIT) if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) { - regs[a] = mrb_fixnum_value((mrb_int)pool[b].u.i64); + regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64); break; } #endif -- cgit v1.2.3 From e479a427579e863899ed2bd3c5a90e54a7aa46e1 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 27 Aug 2020 09:43:56 +0900 Subject: Handle potential overflow in `int_div` and `flo_idiv`. --- src/numeric.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index a5fb87940..f6c2c57a1 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -120,7 +120,10 @@ int_div(mrb_state *mrb, mrb_value xv) 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))); + double d = mrb_integer(xv)/mrb_float(yv); + if (MRB_INT_MIN <= d && d <= MRB_INT_MAX) + return mrb_int_value(mrb, (mrb_int)d); + return mrb_float_value(mrb, d); } else #endif @@ -202,7 +205,10 @@ 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)); + y = mrb_to_flo(mrb, x) / y; + if (MRB_INT_MIN <= y && y <= MRB_INT_MAX) + return mrb_int_value(mrb, (mrb_int)y); + return mrb_float_value(mrb, y); } static mrb_value -- cgit v1.2.3 From bf118b90064ad41412f918458f8082c7e0e14bce Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 27 Aug 2020 18:12:48 +0900 Subject: Stop warning on 64 bit platforms. --- src/numeric.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index f6c2c57a1..f1b06ded4 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -121,9 +121,13 @@ int_div(mrb_state *mrb, mrb_value xv) mrb_get_args(mrb, "o", &yv); if (mrb_float_p(yv)) { double d = mrb_integer(xv)/mrb_float(yv); +#ifdef MRB_INT32 if (MRB_INT_MIN <= d && d <= MRB_INT_MAX) return mrb_int_value(mrb, (mrb_int)d); return mrb_float_value(mrb, d); +#else + return mrb_int_value(mrb, (mrb_int)d); +#endif } else #endif @@ -206,9 +210,13 @@ flo_idiv(mrb_state *mrb, mrb_value x) mrb_get_args(mrb, "f", &y); y = mrb_to_flo(mrb, x) / y; +#ifdef MRB_INT32 if (MRB_INT_MIN <= y && y <= MRB_INT_MAX) return mrb_int_value(mrb, (mrb_int)y); return mrb_float_value(mrb, y); +#else + return mrb_int_value(mrb, (mrb_int)y); +#endif } static mrb_value -- cgit v1.2.3 From 026726dd49421f93783d62f738c37d215f8119f0 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Wed, 2 Sep 2020 08:32:52 +0900 Subject: Remove obsolete `MRB_WITHOUT_FLOAT` macro from `numeric.c`. --- src/numeric.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index f1b06ded4..9fdaf2542 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -1699,7 +1699,7 @@ mrb_init_numeric(mrb_state *mrb) mrb_define_method(mrb, integer, "<<", int_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ mrb_define_method(mrb, integer, ">>", int_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ mrb_define_method(mrb, integer, "eql?", int_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT mrb_define_method(mrb, integer, "to_f", int_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ #endif mrb_define_method(mrb, integer, "to_s", int_to_s, MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */ -- cgit v1.2.3 From 9e842b3a75ced03488411e0e2a993dce40bd1e01 Mon Sep 17 00:00:00 2001 From: "Yukihiro \"Matz\" Matsumoto" Date: Thu, 3 Sep 2020 17:48:07 +0900 Subject: Extract `div` code in VM and make them shared by `div` methods. --- src/numeric.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++++----------- src/vm.c | 43 ++++++-------------------------------- 2 files changed, 60 insertions(+), 49 deletions(-) (limited to 'src/numeric.c') diff --git a/src/numeric.c b/src/numeric.c index 9fdaf2542..e1898301e 100644 --- a/src/numeric.c +++ b/src/numeric.c @@ -101,6 +101,41 @@ int_pow(mrb_state *mrb, mrb_value x) #endif } + +mrb_int +mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y) +{ + if (y == 0) { + mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); + } + else if(x == MRB_INT_MIN && y == -1) { + mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); + } + else { + mrb_int div, mod; + + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = - (x / -y); + } + else { + if (x < 0) + div = - (-x / y); + else + div = x / y; + } + mod = x - div * y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + div -= 1; + } + return div; + } + /* not reached */ + return 0; +} + /* 15.2.8.3.4 */ /* 15.2.9.3.4 */ /* @@ -111,7 +146,6 @@ int_pow(mrb_state *mrb, mrb_value x) * the class of num and on the magnitude of the * result. */ - static mrb_value int_div(mrb_state *mrb, mrb_value xv) { @@ -219,23 +253,31 @@ flo_idiv(mrb_state *mrb, mrb_value x) #endif } +mrb_float +mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y) +{ + mrb_float f; + + if (y == 0) { + if (x > 0) f = INFINITY; + else if (x < 0) f = -INFINITY; + else /* if (x == 0) */ f = NAN; + } + else { + f = x / y; + } + return f; +} + 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); + mrb_get_args(mrb, "f", &y); + x = mrb_num_div_flo(mrb, x, y); + return mrb_float_value(mrb, x); } static mrb_value diff --git a/src/vm.c b/src/vm.c index 2e3024cd8..7f79db32b 100644 --- a/src/vm.c +++ b/src/vm.c @@ -2309,8 +2309,10 @@ RETRY_TRY_BLOCK: } CASE(OP_DIV, B) { + mrb_int mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y); #ifndef MRB_NO_FLOAT - double x, y, f; + mrb_float mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y); + mrb_float x, y, f; #endif /* need to check if op is overridden */ @@ -2319,34 +2321,8 @@ RETRY_TRY_BLOCK: { mrb_int x = mrb_integer(regs[a]); mrb_int y = mrb_integer(regs[a+1]); - - - if (y == 0) { - mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"); - } - else if(x == MRB_INT_MIN && y == -1) { - mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division"); - } - else { - mrb_int div, mod; - if (y < 0) { - if (x < 0) - div = -x / -y; - else - div = - (x / -y); - } - else { - if (x < 0) - div = - (-x / y); - else - div = x / y; - } - mod = x - div*y; - if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { - div -= 1; - } - SET_INT_VALUE(mrb, regs[a], div); - } + mrb_int div = mrb_num_div_int(mrb, x, y); + SET_INT_VALUE(mrb, regs[a], div); } goto L_DIV_OUT; #ifndef MRB_NO_FLOAT @@ -2370,14 +2346,7 @@ RETRY_TRY_BLOCK: } #ifndef MRB_NO_FLOAT - if (y == 0) { - if (x > 0) f = INFINITY; - else if (x < 0) f = -INFINITY; - else /* if (x == 0) */ f = NAN; - } - else { - f = x / y; - } + f = mrb_num_div_flo(mrb, x, y); SET_FLOAT_VALUE(mrb, regs[a], f); #endif L_DIV_OUT: -- cgit v1.2.3