script_core 0.2.7 → 0.3.0

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

@@ -143,7 +143,7 @@ def assert_cmp(exp, o1, o2)
   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 @@ def assert_cmp(exp, o1, o2)
   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 @@ def assert_cmp(exp, o1, o2)
   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 @@ def assert_cmp(exp, o1, o2)
   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 @@ def assert_cmp(exp, o1, o2)
   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 @@ def assert_cmp(exp, o1, o2)
   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))

data/ext/enterprise_script_service/mruby/mrbgems/mruby-sleep/README.md

@@ -1,8 +1,11 @@
 # Sleep Module for mruby
+
 mruby sleep module
 
 ## install by mrbgems
- - add conf.gem line to `build_config.rb`
+
+- add conf.gem line to your build configuration.
+
 ```ruby
 MRuby::Build.new do |conf|
 
@@ -20,8 +23,7 @@ usleep(10000)
 ```
 
 # License
-under the MIT License:
-
-* http://www.opensource.org/licenses/mit-license.php
 
+under the MIT License:
 
+* https://www.opensource.org/licenses/mit-license.php

data/ext/enterprise_script_service/mruby/mrbgems/mruby-sleep/src/mrb_sleep.c

@@ -23,7 +23,7 @@
 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 **
-** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
+** [ MIT license: https://www.opensource.org/licenses/mit-license.php ]
 */
 
 #include <time.h>
@@ -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);
@@ -66,7 +66,7 @@ mrb_f_sleep(mrb_state *mrb, mrb_value self)
 #endif
     end = time(0) - beg;
 
-    return mrb_fixnum_value(end);
+    return mrb_fixnum_value((mrb_int)end);
 }
 
 /* mruby special; needed for mruby without float numbers */
@@ -120,7 +120,7 @@ mrb_f_usleep(mrb_state *mrb, mrb_value self)
     }
 #endif
 
-    return mrb_fixnum_value(slp_tm);
+    return mrb_fixnum_value((mrb_int)slp_tm);
 }
 
 void

data/ext/enterprise_script_service/mruby/mrbgems/mruby-socket/README.md

@@ -4,8 +4,8 @@ mruby-socket
 "mruby-socket" mrbgem provides BSD socket interface for mruby.
 API is compatible with CRuby's "socket" library.
 
-
 ## Example
+
 ```sh
 % vi kame.rb
 s = TCPSocket.open("www.kame.net", 80)
@@ -20,18 +20,19 @@ Date: Tue, 21 May 2013 04:31:30 GMT
 ```
 
 ## Requirement
+
 - [mruby-io](https://github.com/mruby/mruby/tree/master/mrbgems/mruby-io) mrbgem
 - [iij/mruby-mtest](https://github.com/iij/mruby-mtest) mrgbem to run tests
 - system must have RFC3493 basic socket interface
 - and some POSIX API...
 
 ## TODO
+
 - add missing methods
 - write more tests
 - fix possible descriptor leakage (see XXX comments)
 - `UNIXSocket#recv_io` `UNIXSocket#send_io`
 
-
 ## License
 
 Copyright (c) 2013 Internet Initiative Japan Inc.

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

@@ -42,6 +42,7 @@
 #include "mruby/string.h"
 #include "mruby/variable.h"
 #include "mruby/error.h"
+#include "mruby/presym.h"
 
 #include "mruby/ext/io.h"
 
@@ -53,7 +54,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))
@@ -140,50 +141,50 @@ 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;
   } 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));
   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_intern_lit(mrb, "_lastai"));
+  lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai));
   if (mrb_cptr_p(lastai)) {
     freeaddrinfo((struct addrinfo*)mrb_cptr(lastai));
-    mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+    mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
   }
 
   error = getaddrinfo(hostname, servname, &hints, &res0);
   if (error) {
     mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %s", gai_strerror(error));
   }
-  mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0));
+  mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_cptr_value(mrb, res0));
 
   for (res = res0; res != NULL; res = res->ai_next) {
     sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen);
-    ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
+    ai = mrb_funcall_id(mrb, klass, MRB_SYM(new), 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
     mrb_ary_push(mrb, ary, ai);
     mrb_gc_arena_restore(mrb, arena_idx);
   }
 
   freeaddrinfo(res0);
-  mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+  mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
 
   return ary;
 }
@@ -197,10 +198,10 @@ mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
 
   flags = 0;
   mrb_get_args(mrb, "|i", &flags);
-  host = mrb_str_buf_new(mrb, NI_MAXHOST);
-  serv = mrb_str_buf_new(mrb, NI_MAXSERV);
+  host = mrb_str_new_capa(mrb, NI_MAXHOST);
+  serv = mrb_str_new_capa(mrb, NI_MAXSERV);
 
-  sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+  sastr = mrb_iv_get(mrb, self, MRB_IVSYM(sockaddr));
   if (!mrb_string_p(sastr)) {
     mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
   }
@@ -222,7 +223,7 @@ mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
 {
   mrb_value sastr;
 
-  sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+  sastr = mrb_iv_get(mrb, self, MRB_IVSYM(sockaddr));
   if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
     mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
   if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) {
@@ -254,7 +255,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
     return mrb_nil_value();
   }
   port = ntohs(port);
-  host = mrb_str_buf_new(mrb, NI_MAXHOST);
+  host = mrb_str_new_capa(mrb, NI_MAXHOST);
   if (getnameinfo(sa, salen, RSTRING_PTR(host), NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == -1)
     mrb_sys_fail(mrb, "getnameinfo");
   mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host)));
@@ -269,7 +270,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(mrb, sock, "fileno", 0));
+  return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
 }
 
 static int
@@ -347,10 +348,10 @@ 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_intern_lit(mrb, "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(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
+  return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
 }
 
 static mrb_value
@@ -361,7 +362,7 @@ mrb_basicsocket_recv(mrb_state *mrb, mrb_value self)
   mrb_value buf;
 
   mrb_get_args(mrb, "i|i", &maxlen, &flags);
-  buf = mrb_str_buf_new(mrb, maxlen);
+  buf = mrb_str_new_capa(mrb, maxlen);
   n = recv(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags);
   if (n == -1)
     mrb_sys_fail(mrb, "recv");
@@ -378,9 +379,9 @@ mrb_basicsocket_recvfrom(mrb_state *mrb, mrb_value self)
   socklen_t socklen;
 
   mrb_get_args(mrb, "i|i", &maxlen, &flags);
-  buf = mrb_str_buf_new(mrb, maxlen);
+  buf = mrb_str_new_capa(mrb, maxlen);
   socklen = sizeof(struct sockaddr_storage);
-  sa = mrb_str_buf_new(mrb, socklen);
+  sa = mrb_str_new_capa(mrb, socklen);
   n = recvfrom(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags, (struct sockaddr *)RSTRING_PTR(sa), &socklen);
   if (n == -1)
     mrb_sys_fail(mrb, "recvfrom");
@@ -449,21 +450,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,9 +473,9 @@ 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(mrb, so, "level", 0));
-    optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
-    optval = mrb_funcall(mrb, so, "data", 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);
   }
@@ -515,7 +516,8 @@ static mrb_value
 mrb_ipsocket_ntop(mrb_state *mrb, mrb_value klass)
 {
   mrb_int af, n;
-  char *addr, buf[50];
+  const char *addr;
+  char buf[50];
 
   mrb_get_args(mrb, "is", &af, &addr, &n);
   if ((af == AF_INET && n != 4) || (af == AF_INET6 && n != 16))
@@ -529,7 +531,8 @@ static mrb_value
 mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass)
 {
   mrb_int af, n;
-  char *bp, buf[50];
+  const char *bp;
+  char buf[50];
 
   mrb_get_args(mrb, "is", &af, &bp, &n);
   if ((size_t)n > sizeof(buf) - 1)
@@ -568,7 +571,7 @@ mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self)
   fd = socket_fd(mrb, self);
   flags = 0;
   mrb_get_args(mrb, "i|i", &maxlen, &flags);
-  buf = mrb_str_buf_new(mrb, maxlen);
+  buf = mrb_str_new_capa(mrb, maxlen);
   socklen = sizeof(ss);
   n = recvfrom(fd, RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags,
   	       (struct sockaddr *)&ss, &socklen);
@@ -594,7 +597,7 @@ mrb_socket_gethostname(mrb_state *mrb, mrb_value cls)
 #else
   bufsize = 256;
 #endif
-  buf = mrb_str_buf_new(mrb, (mrb_int)bufsize);
+  buf = mrb_str_new_capa(mrb, (mrb_int)bufsize);
   if (gethostname(RSTRING_PTR(buf), (fsize_t)bufsize) != 0)
     mrb_sys_fail(mrb, "gethostname");
   mrb_str_resize(mrb, buf, (mrb_int)strlen(RSTRING_PTR(buf)));
@@ -625,7 +628,7 @@ mrb_socket_accept2(mrb_state *mrb, mrb_value klass)
 
   mrb_get_args(mrb, "i", &s0);
   socklen = sizeof(struct sockaddr_storage);
-  sastr = mrb_str_buf_new(mrb, socklen);
+  sastr = mrb_str_new_capa(mrb, socklen);
   s1 = (int)accept(s0, (struct sockaddr *)RSTRING_PTR(sastr), &socklen);
   if (s1 == -1) {
     mrb_sys_fail(mrb, "accept");
@@ -704,7 +707,7 @@ mrb_socket_sockaddr_un(mrb_state *mrb, mrb_value klass)
   if ((size_t)RSTRING_LEN(path) > sizeof(sunp->sun_path) - 1) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "too long unix socket path (max: %d bytes)", (int)sizeof(sunp->sun_path) - 1);
   }
-  s = mrb_str_buf_new(mrb, sizeof(struct sockaddr_un));
+  s = mrb_str_new_capa(mrb, sizeof(struct sockaddr_un));
   sunp = (struct sockaddr_un *)RSTRING_PTR(s);
 #if HAVE_SA_LEN
   sunp->sun_len = sizeof(struct sockaddr_un);
@@ -778,7 +781,6 @@ mrb_win32_basicsocket_close(mrb_state *mrb, mrb_value self)
   return mrb_nil_value();
 }
 
-#define E_EOF_ERROR                (mrb_class_get(mrb, "EOFError"))
 static mrb_value
 mrb_win32_basicsocket_sysread(mrb_state *mrb, mrb_value self)
 {
@@ -841,7 +843,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
@@ -861,14 +863,14 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
 #endif
 
   ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
-  mrb_mod_cv_set(mrb, ai, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+  mrb_mod_cv_set(mrb, ai, MRB_SYM(_lastai), mrb_nil_value());
   mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
   mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
 #ifndef _WIN32
   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));
@@ -937,7 +939,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"
@@ -947,7 +949,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_intern_lit(mrb, "_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));
   }

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

@@ -10,7 +10,8 @@
 #include <mruby/string.h>
 #include <mruby/hash.h>
 #include <mruby/numeric.h>
-#ifndef MRB_WITHOUT_FLOAT
+#include <mruby/presym.h>
+#ifndef MRB_NO_FLOAT
 #include <math.h>
 #endif
 #include <ctype.h>
@@ -20,7 +21,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
 
@@ -74,20 +75,36 @@ 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);
+  const int mask = base -1;
+  int shift;
+#ifdef MRB_INT64
   uint64_t val = (uint64_t)num;
+#else
+  uint32_t val = (uint32_t)num;
+#endif
   char d;
 
-  if (base != 2) {
+  switch (base) {
+  case 2:
+    shift = 1;
+    break;
+  case 8:
+    shift = 3;
+    break;
+  case 16:
+    shift = 4;
+    break;
+  default:
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
   }
-  if (val == 0) {
+  if (num == 0) {
     return mrb_str_new_lit(mrb, "0");
   }
   *--b = '\0';
   do {
-    *--b = mrb_digitmap[(int)(val % base)];
-  } while (val /= base);
+    *--b = mrb_digitmap[(int)(val & mask)];
+  } while (val >>= shift);
 
   if (num < 0) {
     b = remove_sign_bits(b, base);
@@ -192,20 +209,14 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
 #define GETNTHARG(nth) \
   ((nth >= argc) ? (mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments"), mrb_undef_value()) : argv[nth])
 
-#define GETNAMEARG(id, name, len) (\
+#define CHECKNAMEARG(name, len) (\
   check_name_arg(mrb, posarg, name, len),\
-  (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
-
-#define GETNUM(n, val) \
-  for (; p < end && ISDIGIT(*p); p++) {\
-    if (n > (MRB_INT_MAX - (*p - '0'))/10) {\
-      mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \
-    } \
-    n = 10 * n + (*p - '0'); \
-  } \
-  if (p >= end) { \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \
-  }
+  posarg = -2)
+
+#define GETNUM(n, val) do { \
+  if (!(p = get_num(mrb, p, end, &(n)))) \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big 1"); \
+} while(0)
 
 #define GETASTER(num) do { \
   mrb_value tmp_v; \
@@ -222,12 +233,32 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
   num = mrb_int(mrb, tmp_v); \
 } while (0)
 
-static mrb_value
+static const char *
+get_num(mrb_state *mrb, const char *p, const char *end, mrb_int *valp)
+{
+  mrb_int next_n = *valp;
+  for (; p < end && ISDIGIT(*p); p++) {
+    if (mrb_int_mul_overflow(10, next_n, &next_n)) {
+      return NULL;
+    }
+    if (MRB_INT_MAX - (*p - '0') < next_n) {
+      return NULL;
+    }
+    next_n += *p - '0';
+  }
+  if (p >= end) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%*[0-9]");
+  }
+  *valp = next_n;
+  return p;
+}
+
+static void
 get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
 {
   mrb_value tmp;
 
-  if (!mrb_undef_p(*hash)) return *hash;
+  if (!mrb_undef_p(*hash)) return;
   if (argc != 2) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
   }
@@ -235,7 +266,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
   if (mrb_nil_p(tmp)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
   }
-  return (*hash = tmp);
+  *hash = tmp;
 }
 
 /*
@@ -492,18 +523,18 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
  *  For more complex formatting, Ruby supports a reference by name.
  *  %<name>s style uses format style, but %{name} style doesn't.
  *
- *  Exapmles:
+ *  Examples:
  *    sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
  *      #=> 1 : 2.000000
  *    sprintf("%{foo}f", { :foo => 1 })
  *      # => "1f"
  */
 
-mrb_value
+static mrb_value
 mrb_f_sprintf(mrb_state *mrb, mrb_value obj)
 {
   mrb_int argc;
-  mrb_value *argv;
+  const mrb_value *argv;
 
   mrb_get_args(mrb, "*", &argv, &argc);
 
@@ -519,7 +550,7 @@ mrb_f_sprintf(mrb_state *mrb, mrb_value obj)
 static int
 mrb_int2str(char *buf, size_t len, mrb_int n)
 {
-#ifdef MRB_DISABLE_STDIO
+#ifdef MRB_NO_STDIO
   char *bufend = buf + len;
   char *p = bufend - 1;
 
@@ -557,7 +588,7 @@ mrb_int2str(char *buf, size_t len, mrb_int n)
   return bufend - p - 1;
 #else
   return snprintf(buf, len, "%" MRB_PRId, n);
-#endif /* MRB_DISABLE_STDIO */
+#endif /* MRB_NO_STDIO */
 }
 
 mrb_value
@@ -577,19 +608,19 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm
   mrb_value str;
   mrb_value hash = mrb_undef_value();
 
-#define CHECK_FOR_WIDTH(f)                                                  \
-  if ((f) & FWIDTH) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice");         \
-  }                                                                         \
-  if ((f) & FPREC0) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision");     \
+#define CHECK_FOR_WIDTH(f)                                              \
+  if ((f) & FWIDTH) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice");              \
+    }                                                                   \
+  if ((f) & FPREC0) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision");          \
   }
-#define CHECK_FOR_FLAGS(f)                                                  \
-  if ((f) & FWIDTH) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width");          \
-  }                                                                         \
-  if ((f) & FPREC0) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision");      \
+#define CHECK_FOR_FLAGS(f)                                              \
+  if ((f) & FWIDTH) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width");               \
+  }                                                                     \
+  if ((f) & FPREC0) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision");           \
   }
 
   ++argc;
@@ -676,7 +707,6 @@ retry:
       case '{': {
         const char *start = p;
         char term = (*p == '<') ? '>' : '}';
-        mrb_value symname;
 
         for (; p < end && *p != term; )
           p++;
@@ -684,10 +714,13 @@ retry:
           mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%l after <%n>",
                      start, p - start + 1, id);
         }
-        symname = mrb_str_new(mrb, start + 1, p - start - 1);
-        id = mrb_intern_str(mrb, symname);
-        nextvalue = GETNAMEARG(mrb_symbol_value(id), start, p - start + 1);
-        if (mrb_undef_p(nextvalue)) {
+        CHECKNAMEARG(start, p - start + 1);
+        get_hash(mrb, &hash, argc, argv);
+        id = mrb_intern_check(mrb, start + 1, p - start - 1);
+        if (id) {
+          nextvalue = mrb_hash_fetch(mrb, hash, mrb_symbol_value(id), mrb_undef_value());
+        }
+        if (!id || mrb_undef_p(nextvalue)) {
           mrb_raisef(mrb, E_KEY_ERROR, "key%l not found", start, p - start + 1);
         }
         if (term == '}') goto format_s;
@@ -748,8 +781,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];
 
@@ -763,7 +796,7 @@ retry:
             tmp = mrb_str_new(mrb, buf, 1);
           }
           else {
-            tmp = mrb_funcall(mrb, val, "chr", 0);
+            tmp = mrb_funcall_id(mrb, val, MRB_SYM(chr), 0);
             mrb_check_type(mrb, tmp, MRB_TT_STRING);
           }
 #endif
@@ -863,17 +896,17 @@ 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;
+            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_FIXNUM:
-            v = mrb_fixnum(val);
+          case MRB_TT_INTEGER:
+            v = mrb_integer(val);
             break;
           default:
             val = mrb_Integer(mrb, val);
@@ -922,27 +955,12 @@ 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) {
-            char d;
-
-            s = remove_sign_bits(s, base);
-            switch (base) {
-              case 16: d = 'f'; break;
-              case 8:  d = '7'; break;
-              case 2:  d = '1'; break;
-              default: d = 0; break;
-            }
-
-            if (d && *s != d) {
-              *--s = d;
-            }
-          }
         }
         {
           size_t size;
@@ -1030,7 +1048,7 @@ retry:
       }
       break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case 'f':
       case 'g':
       case 'G':
@@ -1131,7 +1149,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)
 {
@@ -1160,3 +1178,16 @@ fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
   *buf = '\0';
 }
 #endif
+
+void
+mrb_mruby_sprintf_gem_init(mrb_state *mrb)
+{
+  struct RClass *krn = mrb->kernel_module;
+  mrb_define_module_function(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_ANY());
+  mrb_define_module_function(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_ANY());
+}
+
+void
+mrb_mruby_sprintf_gem_final(mrb_state *mrb)
+{
+}