script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/src/range.c

@@ -9,6 +9,7 @@
 #include <mruby/range.h>
 #include <mruby/string.h>
 #include <mruby/array.h>
+#include <mruby/presym.h>
 
 #define RANGE_INITIALIZED_MASK 1
 #define RANGE_INITIALIZED(p) ((p)->flags |= RANGE_INITIALIZED_MASK)
@@ -23,15 +24,17 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b)
 
   ta = mrb_type(a);
   tb = mrb_type(b);
-#ifdef MRB_WITHOUT_FLOAT
-  if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) {
+#ifdef MRB_NO_FLOAT
+  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;
   }
 
+  if (mrb_nil_p(a) || mrb_nil_p(b)) return;
+
   n = mrb_cmp(mrb, a, b);
   if (n == -2) {                /* can not be compared */
     mrb_raise(mrb, E_ARGUMENT_ERROR, "bad value for range");
@@ -78,7 +81,7 @@ range_ptr_init(mrb_state *mrb, struct RRange *r, mrb_value beg, mrb_value end, m
   if (r) {
     if (RANGE_INITIALIZED_P(r)) {
       /* Ranges are immutable, so that they should be initialized only once. */
-      mrb_name_error(mrb, mrb_intern_lit(mrb, "initialize"), "'initialize' called twice");
+      mrb_name_error(mrb, MRB_SYM(initialize), "'initialize' called twice");
     }
     else {
       range_ptr_alloc_edges(mrb, r);
@@ -161,6 +164,7 @@ range_initialize(mrb_state *mrb, mrb_value range)
 
   mrb_get_args(mrb, "oo|b", &beg, &end, &exclusive);
   range_ptr_replace(mrb, mrb_range_raw_ptr(range), beg, end, exclusive);
+  mrb_obj_freeze(mrb, range);
   return range;
 }
 
@@ -182,11 +186,9 @@ range_eq(mrb_state *mrb, mrb_value range)
 {
   struct RRange *rr;
   struct RRange *ro;
-  mrb_value obj;
+  mrb_value obj = mrb_get_arg1(mrb);
   mrb_bool v1, v2;
 
-  mrb_get_args(mrb, "o", &obj);
-
   if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value();
   if (!mrb_obj_is_instance_of(mrb, obj, mrb_obj_class(mrb, range))) { /* same class? */
     return mrb_false_value();
@@ -211,20 +213,28 @@ range_eq(mrb_state *mrb, mrb_value range)
 static mrb_value
 range_include(mrb_state *mrb, mrb_value range)
 {
-  mrb_value val;
+  mrb_value val = mrb_get_arg1(mrb);
   struct RRange *r = mrb_range_ptr(mrb, range);
   mrb_value beg, end;
-  mrb_bool include_p;
-
-  mrb_get_args(mrb, "o", &val);
 
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
-  include_p = r_le(mrb, beg, val) &&                 /* beg <= val */
-              (RANGE_EXCL(r) ? r_gt(mrb, end, val)   /* end >  val */
-                             : r_ge(mrb, end, val)); /* end >= val */
-
-  return mrb_bool_value(include_p);
+  if (mrb_nil_p(beg)) {
+    if (RANGE_EXCL(r) ? r_gt(mrb, end, val)    /* end >  val */
+                      : r_ge(mrb, end, val)) { /* end >= val */
+      return mrb_true_value();
+    }
+  }
+  else if (r_le(mrb, beg, val)) {              /* beg <= val */
+    if (mrb_nil_p(end)) {
+      return mrb_true_value();
+    }
+    if (RANGE_EXCL(r) ? r_gt(mrb, end, val)    /* end >  val */
+                      : r_ge(mrb, end, val)) { /* end >= val */
+      return mrb_true_value();
+    }
+  }
+  return mrb_false_value();
 }
 
 /* 15.2.14.4.12(x) */
@@ -261,14 +271,21 @@ range_to_s(mrb_state *mrb, mrb_value range)
 static mrb_value
 range_inspect(mrb_state *mrb, mrb_value range)
 {
-  mrb_value str, str2;
+  mrb_value str;
   struct RRange *r = mrb_range_ptr(mrb, range);
 
-  str  = mrb_inspect(mrb, RANGE_BEG(r));
-  str2 = mrb_inspect(mrb, RANGE_END(r));
-  str  = mrb_str_dup(mrb, str);
-  mrb_str_cat(mrb, str, "...", RANGE_EXCL(r) ? 3 : 2);
-  mrb_str_cat_str(mrb, str, str2);
+  if (!mrb_nil_p(RANGE_BEG(r))) {
+    str  = mrb_inspect(mrb, RANGE_BEG(r));
+    str  = mrb_str_dup(mrb, str);
+    mrb_str_cat(mrb, str, "...", RANGE_EXCL(r) ? 3 : 2);
+  }
+  else {
+    str = mrb_str_new(mrb, "...", RANGE_EXCL(r) ? 3 : 2);
+  }
+  if (!mrb_nil_p(RANGE_END(r))) {
+    mrb_value str2 = mrb_inspect(mrb, RANGE_END(r));
+    mrb_str_cat_str(mrb, str, str2);
+  }
 
   return str;
 }
@@ -289,11 +306,9 @@ range_inspect(mrb_state *mrb, mrb_value range)
 static mrb_value
 range_eql(mrb_state *mrb, mrb_value range)
 {
-  mrb_value obj;
+  mrb_value obj = mrb_get_arg1(mrb);
   struct RRange *r, *o;
 
-  mrb_get_args(mrb, "o", &obj);
-
   if (mrb_obj_equal(mrb, range, obj)) return mrb_true_value();
   if (!mrb_obj_is_kind_of(mrb, obj, mrb->range_class)) return mrb_false_value();
   if (!mrb_range_p(obj)) return mrb_false_value();
@@ -312,11 +327,9 @@ range_eql(mrb_state *mrb, mrb_value range)
 static mrb_value
 range_initialize_copy(mrb_state *mrb, mrb_value copy)
 {
-  mrb_value src;
+  mrb_value src = mrb_get_arg1(mrb);
   struct RRange *r;
 
-  mrb_get_args(mrb, "o", &src);
-
   if (mrb_obj_equal(mrb, copy, src)) return copy;
   if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
     mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
@@ -324,6 +337,7 @@ range_initialize_copy(mrb_state *mrb, mrb_value copy)
 
   r = mrb_range_ptr(mrb, src);
   range_ptr_replace(mrb, mrb_range_raw_ptr(copy), RANGE_BEG(r), RANGE_END(r), RANGE_EXCL(r));
+  mrb_obj_freeze(mrb, copy);
 
   return copy;
 }
@@ -336,8 +350,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;
@@ -389,13 +403,15 @@ MRB_API enum mrb_range_beg_len
 mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc)
 {
   mrb_int beg, end;
+  mrb_bool excl;
   struct RRange *r;
 
   if (!mrb_range_p(range)) return MRB_RANGE_TYPE_MISMATCH;
   r = mrb_range_ptr(mrb, range);
 
   beg = mrb_int(mrb, RANGE_BEG(r));
-  end = mrb_int(mrb, RANGE_END(r));
+  end = mrb_nil_p(RANGE_END(r)) ? -1 : mrb_int(mrb, RANGE_END(r));
+  excl = mrb_nil_p(RANGE_END(r)) ? 0 : RANGE_EXCL(r);
 
   if (beg < 0) {
     beg += len;
@@ -408,7 +424,7 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp,
   }
 
   if (end < 0) end += len;
-  if (!RANGE_EXCL(r) && (!trunc || end < len)) end++;  /* include end point */
+  if (!excl && (!trunc || end < len)) end++;  /* include end point */
   len = end - beg;
   if (len < 0) len = 0;
 

data/ext/enterprise_script_service/mruby/src/state.c

@@ -19,11 +19,25 @@ void mrb_init_mrbgems(mrb_state*);
 void mrb_gc_init(mrb_state*, mrb_gc *gc);
 void mrb_gc_destroy(mrb_state*, mrb_gc *gc);
 
+int mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state *, void *), void *opaque);
+
+static void
+init_gc_and_core(mrb_state *mrb, void *opaque)
+{
+  static const struct mrb_context mrb_context_zero = { 0 };
+
+  mrb_gc_init(mrb, &mrb->gc);
+  mrb->c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context));
+  *mrb->c = mrb_context_zero;
+  mrb->root_c = mrb->c;
+
+  mrb_init_core(mrb);
+}
+
 MRB_API mrb_state*
 mrb_open_core(mrb_allocf f, void *ud)
 {
   static const mrb_state mrb_state_zero = { 0 };
-  static const struct mrb_context mrb_context_zero = { 0 };
   mrb_state *mrb;
 
   if (f == NULL) f = mrb_default_allocf;
@@ -35,12 +49,10 @@ mrb_open_core(mrb_allocf f, void *ud)
   mrb->allocf = f;
   mrb->atexit_stack_len = 0;
 
-  mrb_gc_init(mrb, &mrb->gc);
-  mrb->c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context));
-  *mrb->c = mrb_context_zero;
-  mrb->root_c = mrb->c;
-
-  mrb_init_core(mrb);
+  if (mrb_core_init_protect(mrb, init_gc_and_core, NULL)) {
+    mrb_close(mrb);
+    return NULL;
+  }
 
   return mrb;
 }
@@ -65,6 +77,14 @@ mrb_open(void)
   return mrb;
 }
 
+#ifndef MRB_NO_GEMS
+static void
+init_mrbgems(mrb_state *mrb, void *opaque)
+{
+  mrb_init_mrbgems(mrb);
+}
+#endif
+
 MRB_API mrb_state*
 mrb_open_allocf(mrb_allocf f, void *ud)
 {
@@ -74,8 +94,11 @@ mrb_open_allocf(mrb_allocf f, void *ud)
     return NULL;
   }
 
-#ifndef DISABLE_GEMS
-  mrb_init_mrbgems(mrb);
+#ifndef MRB_NO_GEMS
+  if (mrb_core_init_protect(mrb, init_mrbgems, NULL)) {
+    mrb_close(mrb);
+    return NULL;
+  }
   mrb_gc_arena_restore(mrb, 0);
 #endif
   return mrb;
@@ -86,12 +109,14 @@ void mrb_free_symtbl(mrb_state *mrb);
 void
 mrb_irep_incref(mrb_state *mrb, mrb_irep *irep)
 {
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   irep->refcnt++;
 }
 
 void
 mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
 {
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   irep->refcnt--;
   if (irep->refcnt == 0) {
     mrb_irep_free(mrb, irep);
@@ -101,12 +126,14 @@ mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
 void
 mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep)
 {
-  mrb_irep *tmp;
+  mrb_irep **reps;
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
+  reps = (mrb_irep**)irep->reps;
   for (i=0; i<irep->rlen; i++) {
-    tmp = irep->reps[i];
-    irep->reps[i] = NULL;
+    mrb_irep *tmp = reps[i];
+    reps[i] = NULL;
     if (tmp) mrb_irep_decref(mrb, tmp);
   }
 }
@@ -116,57 +143,46 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
 {
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   if (!(irep->flags & MRB_ISEQ_NO_FREE))
     mrb_free(mrb, (void*)irep->iseq);
-  if (irep->pool) for (i=0; i<irep->plen; i++) {
-    if (mrb_string_p(irep->pool[i])) {
-      mrb_gc_free_str(mrb, RSTRING(irep->pool[i]));
-      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
-    }
-#if defined(MRB_WORD_BOXING) && !defined(MRB_WITHOUT_FLOAT)
-    else if (mrb_float_p(irep->pool[i])) {
-      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
+  if (irep->pool) {
+    for (i=0; i<irep->plen; i++) {
+      if ((irep->pool[i].tt & 3) == IREP_TT_STR) {
+        mrb_free(mrb, (void*)irep->pool[i].u.str);
+      }
     }
-#endif
+    mrb_free(mrb, (void*)irep->pool);
   }
-  mrb_free(mrb, irep->pool);
-  mrb_free(mrb, irep->syms);
-  for (i=0; i<irep->rlen; i++) {
-    if (irep->reps[i])
-      mrb_irep_decref(mrb, irep->reps[i]);
+  mrb_free(mrb, (void*)irep->syms);
+  if (irep->reps) {
+    for (i=0; i<irep->rlen; i++) {
+      if (irep->reps[i])
+        mrb_irep_decref(mrb, (mrb_irep*)irep->reps[i]);
+    }
+    mrb_free(mrb, (void*)irep->reps);
   }
-  mrb_free(mrb, irep->reps);
-  mrb_free(mrb, irep->lv);
+  mrb_free(mrb, (void*)irep->lv);
   mrb_debug_info_free(mrb, irep->debug_info);
   mrb_free(mrb, irep);
 }
 
-void mrb_free_backtrace(mrb_state *mrb);
-
 MRB_API void
 mrb_free_context(mrb_state *mrb, struct mrb_context *c)
 {
   if (!c) return;
   mrb_free(mrb, c->stbase);
   mrb_free(mrb, c->cibase);
-  mrb_free(mrb, c->rescue);
-  mrb_free(mrb, c->ensure);
   mrb_free(mrb, c);
 }
 
-MRB_API void
+int mrb_protect_atexit(mrb_state *mrb);
+
+  MRB_API void
 mrb_close(mrb_state *mrb)
 {
   if (!mrb) return;
-  if (mrb->atexit_stack_len > 0) {
-    mrb_int i;
-    for (i = mrb->atexit_stack_len; i > 0; --i) {
-      mrb->atexit_stack[i - 1](mrb);
-    }
-#ifndef MRB_FIXED_STATE_ATEXIT_STACK
-    mrb_free(mrb, mrb->atexit_stack);
-#endif
-  }
+  mrb_protect_atexit(mrb);
 
   /* free */
   mrb_gc_destroy(mrb, &mrb->gc);

data/ext/enterprise_script_service/mruby/src/string.c

@@ -8,8 +8,9 @@
 # define _CRT_NONSTDC_NO_DEPRECATE
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <float.h>
+#include <math.h>
 #endif
 #include <limits.h>
 #include <stddef.h>
@@ -21,6 +22,7 @@
 #include <mruby/range.h>
 #include <mruby/string.h>
 #include <mruby/numeric.h>
+#include <mruby/presym.h>
 
 typedef struct mrb_shared_string {
   int refcnt;
@@ -174,19 +176,6 @@ mrb_str_new_capa(mrb_state *mrb, size_t capa)
   return mrb_obj_value(s);
 }
 
-#ifndef MRB_STR_BUF_MIN_SIZE
-# define MRB_STR_BUF_MIN_SIZE 128
-#endif
-
-MRB_API mrb_value
-mrb_str_buf_new(mrb_state *mrb, size_t capa)
-{
-  if (capa < MRB_STR_BUF_MIN_SIZE) {
-    capa = MRB_STR_BUF_MIN_SIZE;
-  }
-  return mrb_str_new_capa(mrb, capa);
-}
-
 static void
 resize_capa(mrb_state *mrb, struct RString *s, size_t capacity)
 {
@@ -296,12 +285,14 @@ static const char utf8len_codepage[256] =
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1,
 };
 
-static mrb_int
-utf8len(const char* p, const char* e)
+#define utf8_islead(c) ((unsigned char)((c)&0xc0) != 0x80)
+
+mrb_int
+mrb_utf8len(const char* p, const char* e)
 {
   mrb_int len;
   mrb_int i;
@@ -311,23 +302,23 @@ utf8len(const char* p, const char* e)
   if (len == 1) return 1;
   if (len > e - p) return 1;
   for (i = 1; i < len; ++i)
-    if ((p[i] & 0xc0) != 0x80)
+    if (utf8_islead(p[i]))
       return 1;
   return len;
 }
 
 mrb_int
-mrb_utf8_len(const char *str, mrb_int byte_len)
+mrb_utf8_strlen(const char *str, mrb_int byte_len)
 {
-  mrb_int total = 0;
+  mrb_int len = 0;
   const char *p = str;
   const char *e = p + byte_len;
 
   while (p < e) {
-    p += utf8len(p, e);
-    total++;
+    p += mrb_utf8len(p, e);
+    len++;
   }
-  return total;
+  return len;
 }
 
 static mrb_int
@@ -340,7 +331,7 @@ utf8_strlen(mrb_value str)
     return byte_len;
   }
   else {
-    mrb_int utf8_len = mrb_utf8_len(RSTR_PTR(s), byte_len);
+    mrb_int utf8_len = mrb_utf8_strlen(RSTR_PTR(s), byte_len);
     if (byte_len == utf8_len) RSTR_SET_ASCII_FLAG(s);
     return utf8_len;
   }
@@ -361,7 +352,7 @@ chars2bytes(mrb_value s, mrb_int off, mrb_int idx)
     const char *e = RSTRING_END(s);
 
     for (b=i=0; p<e && i<idx; i++) {
-      n = utf8len(p, e);
+      n = mrb_utf8len(p, e);
       b += n;
       p += n;
     }
@@ -378,7 +369,7 @@ bytes2chars(char *p, mrb_int len, mrb_int bi)
   mrb_int i;
 
   for (i = 0; p < pivot; i ++) {
-    p += utf8len(p, e);
+    p += mrb_utf8len(p, e);
   }
   if (p != pivot) return -1;
   return i;
@@ -399,7 +390,7 @@ char_adjust(const char *beg, const char *end, const char *ptr)
     while (p > beg) {
       p --;
       if ((*p & 0xc0) != 0x80) {
-        int clen = utf8len(p, end);
+        int clen = mrb_utf8len(p, end);
         if (clen > ptr - p) return p;
         break;
       }
@@ -462,10 +453,10 @@ str_index_str_by_char_search(mrb_state *mrb, const char *p, const char *pend, co
     }
 
     pivot = p + qstable[(unsigned char)p[slen - 1]];
-    if (pivot > pend || pivot < p /* overflowed */) { return -1; }
+    if (pivot >= pend || pivot < p /* overflowed */) { return -1; }
 
     do {
-      p += utf8len(p, pend);
+      p += mrb_utf8len(p, pend);
       off ++;
     } while (p < pivot);
   }
@@ -484,7 +475,7 @@ str_index_str_by_char(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)
 
   for (; pos > 0; pos --) {
     if (pend - p < 1) { return -1; }
-    p += utf8len(p, pend);
+    p += mrb_utf8len(p, pend);
   }
 
   if (slen < 1) { return off; }
@@ -503,25 +494,45 @@ str_index_str_by_char(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)
 #define str_index_str_by_char(mrb, str, sub, pos) str_index_str(mrb, str, sub, pos)
 #endif
 
+#ifndef MRB_QS_SHORT_STRING_LENGTH
+#define MRB_QS_SHORT_STRING_LENGTH 2048
+#endif
+
 static inline mrb_int
 mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mrb_int n)
 {
-  const unsigned char *x = xs, *xe = xs + m;
-  const unsigned char *y = ys;
-  int i;
-  ptrdiff_t qstable[256];
+  if (n + m < MRB_QS_SHORT_STRING_LENGTH) {
+    const unsigned char *y = ys;
+    const unsigned char *ye = ys+n-m+1;
 
-  /* Preprocessing */
-  for (i = 0; i < 256; ++i)
-    qstable[i] = m + 1;
-  for (; x < xe; ++x)
-    qstable[*x] = xe - x;
-  /* Searching */
-  for (; y + m <= ys + n; y += *(qstable + y[m])) {
-    if (*xs == *y && memcmp(xs, y, m) == 0)
-      return (mrb_int)(y - ys);
+    for (;;) {
+      y = (const unsigned char*)memchr(y, xs[0], (size_t)(ye-y));
+      if (y == NULL) return -1;
+      if (memcmp(xs, y, m) == 0) {
+        return (mrb_int)(y - ys);
+      }
+      y++;
+    }
+    return -1;
+  }
+  else {
+    const unsigned char *x = xs, *xe = xs + m;
+    const unsigned char *y = ys;
+    int i;
+    ptrdiff_t qstable[256];
+
+    /* Preprocessing */
+    for (i = 0; i < 256; ++i)
+      qstable[i] = m + 1;
+    for (; x < xe; ++x)
+      qstable[*x] = xe - x;
+    /* Searching */
+    for (; y + m <= ys + n; y += *(qstable + y[m])) {
+      if (*xs == *y && memcmp(xs, y, m) == 0)
+        return (mrb_int)(y - ys);
+    }
+    return -1;
   }
-  return -1;
 }
 
 static mrb_int
@@ -562,9 +573,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
   else if (RSTR_FSHARED_P(orig)) {
     str_init_fshared(orig, s, orig->as.heap.aux.fshared);
   }
-  else if (mrb_frozen_p(orig) && !RSTR_POOL_P(orig)) {
-    str_init_fshared(orig, s, orig);
-  }
   else {
     if (orig->as.heap.aux.capa > orig->as.heap.len) {
       orig->as.heap.ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
@@ -575,29 +583,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
   }
 }
 
-mrb_value
-mrb_str_pool(mrb_state *mrb, const char *p, mrb_int len, mrb_bool nofree)
-{
-  struct RString *s = (struct RString *)mrb_malloc(mrb, sizeof(struct RString));
-
-  s->tt = MRB_TT_STRING;
-  s->c = mrb->string_class;
-  s->flags = 0;
-
-  if (RSTR_EMBEDDABLE_P(len)) {
-    str_init_embed(s, p, len);
-  }
-  else if (nofree) {
-    str_init_nofree(s, p, len);
-  }
-  else {
-    str_init_normal(mrb, s, p, len);
-  }
-  RSTR_SET_POOL_FLAG(s);
-  MRB_SET_FROZEN_FLAG(s);
-  return mrb_obj_value(s);
-}
-
 mrb_value
 mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
 {
@@ -877,7 +862,7 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
 MRB_API void
 mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 {
-  other = mrb_str_to_str(mrb, other);
+  other = mrb_obj_as_string(mrb, other);
   mrb_str_cat_str(mrb, self, other);
 }
 
@@ -1040,10 +1025,9 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)
 static mrb_value
 mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)
 {
-  mrb_value str2;
+  mrb_value str2 = mrb_get_arg1(mrb);
   mrb_int result;
 
-  mrb_get_args(mrb, "o", &str2);
   if (!mrb_string_p(str2)) {
     return mrb_nil_value();
   }
@@ -1085,37 +1069,17 @@ mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)
 static mrb_value
 mrb_str_equal_m(mrb_state *mrb, mrb_value str1)
 {
-  mrb_value str2;
-
-  mrb_get_args(mrb, "o", &str2);
+  mrb_value str2 = mrb_get_arg1(mrb);
 
   return mrb_bool_value(mrb_str_equal(mrb, str1, str2));
 }
 /* ---------------------------------- */
 
-MRB_API mrb_value
-mrb_str_to_str(mrb_state *mrb, mrb_value str)
-{
-  switch (mrb_type(str)) {
-  case MRB_TT_STRING:
-    return str;
-  case MRB_TT_SYMBOL:
-    return mrb_sym_str(mrb, mrb_symbol(str));
-  case MRB_TT_FIXNUM:
-    return mrb_fixnum_to_str(mrb, str, 10);
-  case MRB_TT_CLASS:
-  case MRB_TT_MODULE:
-    return mrb_mod_to_s(mrb, str);
-  default:
-    return mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s");
-  }
-}
-
 /* obslete: use RSTRING_PTR() */
 MRB_API const char*
 mrb_string_value_ptr(mrb_state *mrb, mrb_value str)
 {
-  str = mrb_str_to_str(mrb, str);
+  str = mrb_obj_as_string(mrb, str);
   return RSTRING_PTR(str);
 }
 
@@ -1161,8 +1125,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
   }
   else {
     switch (mrb_type(indx)) {
-      case MRB_TT_FIXNUM:
-        *beg = mrb_fixnum(indx);
+      case MRB_TT_INTEGER:
+        *beg = mrb_integer(indx);
         *len = 1;
         return STR_CHAR_RANGE;
 
@@ -1177,8 +1141,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;
         }
@@ -1193,7 +1157,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;
@@ -1237,8 +1201,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 <code>Fixnum</code>, returns the code
- *  of the character at that position. If passed two <code>Fixnum</code>
+ *  Element Reference---If passed a single <code>Integer</code>, returns the code
+ *  of the character at that position. If passed two <code>Integer</code>
  *  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
@@ -1296,7 +1260,7 @@ str_replace_partial(mrb_state *mrb, mrb_value src, mrb_int pos, mrb_int end, mrb
   }
 
   replen = (mrb_nil_p(rep) ? 0 : RSTRING_LEN(rep));
-  newlen = replen + len - (end - pos);
+  newlen = replen + (len - (end - pos));
 
   if (newlen >= MRB_SSIZE_MAX || newlen < replen /* overflowed */) {
     mrb_raise(mrb, E_RUNTIME_ERROR, "string size too big");
@@ -1341,7 +1305,7 @@ str_escape(mrb_state *mrb, mrb_value str, mrb_bool inspect)
     unsigned char c, cc;
 #ifdef MRB_UTF8_STRING
     if (inspect) {
-      mrb_int clen = utf8len(p, pend);
+      mrb_int clen = mrb_utf8len(p, pend);
       if (clen > 1) {
         mrb_int i;
 
@@ -1644,7 +1608,7 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str)
     const char* t = RSTR_PTR(s), *p = t;
     const char* e = p + RSTR_LEN(s);
     while (p<e) {
-      mrb_int clen = utf8len(p, e);
+      mrb_int clen = mrb_utf8len(p, e);
       if (p + clen>=e) break;
       p += clen;
     }
@@ -1770,10 +1734,9 @@ mrb_str_empty_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_str_eql(mrb_state *mrb, mrb_value self)
 {
-  mrb_value str2;
+  mrb_value str2 = mrb_get_arg1(mrb);
   mrb_bool eql_p;
 
-  mrb_get_args(mrb, "o", &str2);
   eql_p = (mrb_string_p(str2)) && str_eql(mrb, self, str2);
 
   return mrb_bool_value(eql_p);
@@ -1792,13 +1755,17 @@ mrb_str_hash(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
   mrb_int len = RSTR_LEN(s);
   char *p = RSTR_PTR(s);
-  uint64_t key = 0;
+  uint32_t hash = 0;
 
-  while (len--) {
-    key = key*65599 + *p;
-    p++;
+  for(int i = 0; i < len; ++i) {
+    hash += p[i];
+    hash += (hash << 10);
+    hash ^= (hash >> 6);
   }
-  return (uint32_t)(key + (key>>5));
+  hash += (hash << 3);
+  hash ^= (hash >> 11);
+  hash += (hash << 15);
+  return hash;
 }
 
 /* 15.2.10.5.20 */
@@ -1945,10 +1912,20 @@ mrb_str_intern(mrb_state *mrb, mrb_value self)
 MRB_API mrb_value
 mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
 {
-  if (mrb_string_p(obj)) {
+  switch (mrb_type(obj)) {
+  case MRB_TT_STRING:
     return obj;
+  case MRB_TT_SYMBOL:
+    return mrb_sym_str(mrb, mrb_symbol(obj));
+  case MRB_TT_INTEGER:
+    return mrb_fixnum_to_str(mrb, obj, 10);
+  case MRB_TT_SCLASS:
+  case MRB_TT_CLASS:
+  case MRB_TT_MODULE:
+    return mrb_mod_to_s(mrb, obj);
+  default:
+    return mrb_type_convert(mrb, obj, MRB_TT_STRING, MRB_SYM(to_s));
   }
-  return mrb_str_to_str(mrb, obj);
 }
 
 MRB_API mrb_value
@@ -2016,7 +1993,7 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
     p = RSTR_PTR(s);
     e = p + RSTR_LEN(s);
     while (p<e) {
-      mrb_int clen = utf8len(p, e);
+      mrb_int clen = mrb_utf8len(p, e);
       str_reverse(p, p + clen - 1);
       p += clen;
     }
@@ -2240,13 +2217,13 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
 }
 
 mrb_value
-mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base, int badcheck)
+mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, int badcheck)
 {
   const char *p = str;
   const char *pend = str + len;
   char sign = 1;
   int c;
-  uint64_t n = 0;
+  mrb_int n = 0;
   mrb_int val;
 
 #define conv_digit(c) \
@@ -2373,19 +2350,17 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base,
     if (c < 0 || c >= base) {
       break;
     }
-    n *= base;
-    n += c;
-    if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) {
-#ifndef MRB_WITHOUT_FLOAT
-      if (base == 10) {
-        return mrb_float_value(mrb, mrb_str_to_dbl(mrb, mrb_str_new(mrb, str, len), badcheck));
-      }
-      else
-#endif
-      {
-        mrb_raisef(mrb, E_RANGE_ERROR, "string (%l) too big for integer", str, pend-str);
+    if (mrb_int_mul_overflow(n, base, &n)) goto overflow;
+    if (MRB_INT_MAX - c < n) {
+      if (sign == 0 && MRB_INT_MAX - n == c - 1) {
+        n = MRB_INT_MIN;
+        sign = 1;
+        break;
       }
+    overflow:
+      mrb_raisef(mrb, E_RANGE_ERROR, "string (%l) too big for integer", str, pend-str);
     }
+    n += c;
   }
   val = (mrb_int)n;
   if (badcheck) {
@@ -2395,7 +2370,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base,
     if (p<pend) goto bad;               /* trailing garbage */
   }
 
-  return mrb_fixnum_value(sign ? val : -val);
+  return mrb_int_value(mrb, sign ? val : -val);
  nullbyte:
   mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
   /* not reached */
@@ -2487,49 +2462,57 @@ 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)
 {
-  char buf[DBL_DIG * 4 + 10];
-  const char *p = s;
+  char buf[DBL_DIG * 4 + 20];
+  const char *p = s, *p2;
   const char *pend = p + len;
   char *end;
   char *n;
   char prev = 0;
   double d;
+  mrb_bool dot = FALSE;
 
   if (!p) return 0.0;
-  while (ISSPACE(*p)) p++;
+  while (p<pend && ISSPACE(*p)) p++;
+  p2 = p;
 
   if (pend - p > 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
     mrb_value x;
 
     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;
   }
   while (p < pend) {
     if (!*p) {
-      if (badcheck && p < pend) {
+      if (badcheck) {
         mrb_raise(mrb, E_ARGUMENT_ERROR, "string for Float contains null byte");
         /* not reached */
       }
       pend = p;
-      p = s;
+      p = p2;
+      goto nocopy;
+    }
+    if (!badcheck && *p == ' ') {
+      pend = p;
+      p = p2;
       goto nocopy;
     }
     if (*p == '_') break;
     p++;
   }
-  p = s;
+  p = p2;
   n = buf;
   while (p < pend) {
     char c = *p++;
+    if (c == '.') dot = TRUE;
     if (c == '_') {
       /* remove an underscore between digits */
       if (n == buf || !ISDIGIT(prev) || p == pend) {
@@ -2539,6 +2522,11 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
     }
     else if (badcheck && prev == '_' && !ISDIGIT(c)) goto bad;
     else {
+      const char *bend = buf+sizeof(buf)-1;
+      if (n==bend) {            /* buffer overflow */
+        if (dot) break;         /* cut off remaining fractions */
+        return INFINITY;
+      }
       *n++ = c;
     }
     prev = c;
@@ -2725,7 +2713,7 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len)
 MRB_API mrb_value
 mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr)
 {
-  return mrb_str_cat(mrb, str, ptr, strlen(ptr));
+  return mrb_str_cat(mrb, str, ptr, ptr ? strlen(ptr) : 0);
 }
 
 MRB_API mrb_value
@@ -2855,25 +2843,32 @@ mrb_str_setbyte(mrb_state *mrb, mrb_value str)
 static mrb_value
 mrb_str_byteslice(mrb_state *mrb, mrb_value str)
 {
-  mrb_value a1, a2;
+  mrb_value a1;
   mrb_int str_len = RSTRING_LEN(str), beg, len;
   mrb_bool empty = TRUE;
 
-  if (mrb_get_args(mrb, "o|o", &a1, &a2) == 2) {
-    beg = mrb_fixnum(mrb_to_int(mrb, a1));
-    len = mrb_fixnum(mrb_to_int(mrb, a2));
-  }
-  else if (mrb_range_p(a1)) {
-    if (mrb_range_beg_len(mrb, a1, &beg, &len, str_len, TRUE) != MRB_RANGE_OK) {
-      return mrb_nil_value();
+  len = mrb_get_argc(mrb);
+  switch (len) {
+  case 2:
+    mrb_get_args(mrb, "ii", &beg, &len);
+    break;
+  case 1:
+    a1 = mrb_get_arg1(mrb);
+    if (mrb_range_p(a1)) {
+      if (mrb_range_beg_len(mrb, a1, &beg, &len, str_len, TRUE) != MRB_RANGE_OK) {
+        return mrb_nil_value();
+      }
     }
+    else {
+      beg = mrb_integer(mrb_to_int(mrb, a1));
+      len = 1;
+      empty = FALSE;
+    }
+    break;
+  default:
+    mrb_argnum_error(mrb, len, 1, 2);
+    break;
   }
-  else {
-    beg = mrb_fixnum(mrb_to_int(mrb, a1));
-    len = 1;
-    empty = FALSE;
-  }
-
   if (mrb_str_beg_len(str_len, &beg, &len) && (empty || len != 0)) {
     return mrb_str_byte_subseq(mrb, str, beg, len);
   }
@@ -2928,7 +2923,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 */
@@ -2945,7 +2940,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.
  *
@@ -3007,7 +3002,7 @@ mrb_float_read(const char *string, char **endPtr)
     int c;
     int exp = 0;                /* Exponent read from "EX" field. */
     int fracExp = 0;            /* Exponent that derives from the fractional
-                                 * part.  Under normal circumstatnces, it is
+                                 * part.  Under normal circumstances, it is
                                  * the negative of the number of digits in F.
                                  * However, if I is very long, the last digits
                                  * of I get dropped (otherwise a long I with a