Merge pull request #1820 from ksss/string-embed

Embed small string

6 files changed, 244 insertions, 187 deletions

diff --git a/src/class.c b/src/class.c
index 8188db131..9880a82fa 100644
--- a/src/class.c
+++ b/src/class.c
@@ -511,7 +511,6 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     case 's':
       {
         mrb_value ss;
-        struct RString *s;
         char **ps = 0;
         int *pl = 0;
 
@@ -519,9 +518,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         pl = va_arg(ap, int*);
         if (i < argc) {
           ss = to_str(mrb, *sp++);
-          s = mrb_str_ptr(ss);
-          *ps = s->ptr;
-          *pl = s->len;
+          *ps = RSTRING_PTR(ss);
+          *pl = RSTRING_LEN(ss);
           i++;
         }
       }
@@ -537,14 +535,14 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           s = mrb_str_ptr(ss);
-          len = (mrb_int)strlen(s->ptr);
-          if (len < s->len) {
+          len = (mrb_int)strlen(RSTRING_PTR(ss));
+          if (len < RSTRING_LEN(ss)) {
             mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
           }
-          else if (len > s->len) {
+          else if (len > RSTRING_LEN(ss)) {
             mrb_str_modify(mrb, s);
           }
-          *ps = s->ptr;
+          *ps = RSTRING_PTR(ss);
           i++;
         }
       }
@@ -1298,7 +1296,7 @@ mrb_class_name(mrb_state *mrb, struct RClass* c)
     mrb_str_concat(mrb, path, mrb_ptr_to_str(mrb, c));
     mrb_str_cat_lit(mrb, path, ">");
   }
-  return mrb_str_ptr(path)->ptr;
+  return RSTRING_PTR(path);
 }
 
 const char*
diff --git a/src/object.c b/src/object.c
index 1f0d903f2..2f14c5698 100644
--- a/src/object.c
+++ b/src/object.c
@@ -390,7 +390,6 @@ void
 mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
 {
   const struct types *type = builtin_types;
-  struct RString *s;
   enum mrb_vtype xt;
 
   xt = mrb_type(x);
@@ -409,8 +408,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
           etype = "Symbol";
         }
         else if (mrb_special_const_p(x)) {
-          s = mrb_str_ptr(mrb_obj_as_string(mrb, x));
-          etype = s->ptr;
+          etype = RSTRING_PTR(mrb_obj_as_string(mrb, x));
         }
         else {
           etype = mrb_obj_classname(mrb, x);
diff --git a/src/print.c b/src/print.c
index 9d59aa4ff..6472a4675 100644
--- a/src/print.c
+++ b/src/print.c
@@ -12,14 +12,12 @@ static void
 printstr(mrb_state *mrb, mrb_value obj)
 {
 #ifdef ENABLE_STDIO
-  struct RString *str;
   char *s;
   int len;
 
   if (mrb_string_p(obj)) {
-    str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = RSTRING_PTR(obj);
+    len = RSTRING_LEN(obj);
     fwrite(s, len, 1, stdout);
   }
 #endif
@@ -44,8 +42,7 @@ mrb_print_error(mrb_state *mrb)
   mrb_print_backtrace(mrb);
   s = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0);
   if (mrb_string_p(s)) {
-    struct RString *str = mrb_str_ptr(s);
-    fwrite(str->ptr, str->len, 1, stderr);
+    fwrite(RSTRING_PTR(s), RSTRING_LEN(s), 1, stderr);
     putc('\n', stderr);
   }
 #endif
diff --git a/src/state.c b/src/state.c
index 9b7ad1c5a..f05dbda34 100644
--- a/src/state.c
+++ b/src/state.c
@@ -135,8 +135,8 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
     mrb_free(mrb, irep->iseq);
   for (i=0; i<irep->plen; i++) {
     if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
-      if ((mrb_str_ptr(irep->pool[i])->flags & MRB_STR_NOFREE) == 0) {
-        mrb_free(mrb, mrb_str_ptr(irep->pool[i])->ptr);
+      if ((mrb_str_ptr(irep->pool[i])->flags & (MRB_STR_NOFREE|MRB_STR_EMBED)) == 0) {
+        mrb_free(mrb, RSTRING_PTR(irep->pool[i]));
       }
       mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
     }
@@ -163,25 +163,30 @@ mrb_str_pool(mrb_state *mrb, mrb_value str)
 {
   struct RString *s = mrb_str_ptr(str);
   struct RString *ns;
+  char *ptr;
   mrb_int len;
 
   ns = (struct RString *)mrb_malloc(mrb, sizeof(struct RString));
   ns->tt = MRB_TT_STRING;
   ns->c = mrb->string_class;
 
-  len = s->len;
-  ns->len = len;
+  if (s->flags & MRB_STR_EMBED)
+    len = (mrb_int)((s->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT);
+  else
+    len = s->as.heap.len;
+  ns->as.heap.len = len;
   if (s->flags & MRB_STR_NOFREE) {
-    ns->ptr = s->ptr;
+    ns->as.heap.ptr = s->as.heap.ptr;
     ns->flags = MRB_STR_NOFREE;
   }
   else {
     ns->flags = 0;
-    ns->ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
-    if (s->ptr) {
-      memcpy(ns->ptr, s->ptr, len);
+    ns->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
+    ptr = (s->flags & MRB_STR_EMBED) ? s->as.ary : s->as.heap.ptr;
+    if (ptr) {
+      memcpy(ns->as.heap.ptr, ptr, len);
     }
-    ns->ptr[len] = '\0';
+    ns->as.heap.ptr[len] = '\0';
   }
   return mrb_obj_value(ns);
 }
diff --git a/src/string.c b/src/string.c
index ad3ef2c70..85a3cc2a7 100644
--- a/src/string.c
+++ b/src/string.c
@@ -16,6 +16,28 @@
 #include "mruby/string.h"
 #include "re.h"
 
+#define STR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
+#define STR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
+#define STR_UNSET_EMBED_FLAG(s) ((s)->flags &= ~(MRB_STR_EMBED|MRB_STR_EMBED_LEN_MASK))
+#define STR_SET_EMBED_LEN(s, n) do {\
+  mrb_int tmp_n = (n);\
+  s->flags &= ~MRB_STR_EMBED_LEN_MASK;\
+  s->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
+} while (0)
+#define STR_SET_LEN(s, n) do {\
+  if (STR_EMBED_P(s)) {\
+    STR_SET_EMBED_LEN((s),(n));\
+  } else {\
+    s->as.heap.len = (n);\
+  }\
+} while (0)
+#define RSTRING_EMBED_LEN(s) \
+  (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+#define STR_EMBED_LEN(s)\
+  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+#define STR_PTR(s) ((STR_EMBED_P(s)) ? (s)->as.ary : (s)->as.heap.ptr)
+#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (s)->as.heap.len)
+
 const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
 typedef struct mrb_shared_string {
@@ -33,8 +55,20 @@ static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString
 static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
 
 #define RESIZE_CAPA(s,capacity) do {\
-      s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\
-      s->aux.capa = capacity;\
+  if (STR_EMBED_P(s)) {\
+    if (RSTRING_EMBED_LEN_MAX < (capacity)) {\
+      char *const tmp = (char *)mrb_malloc(mrb, (capacity)+1);\
+      const mrb_int len = STR_EMBED_LEN(s);\
+      memcpy(tmp, s->as.ary, len);\
+      STR_UNSET_EMBED_FLAG(s);\
+      s->as.heap.ptr = tmp;\
+      s->as.heap.len = len;\
+      s->as.heap.aux.capa = (capacity);\
+    }\
+  } else {\
+    s->as.heap.ptr = (char *)mrb_realloc(mrb, STR_PTR(s), (capacity)+1);\
+    s->as.heap.aux.capa = capacity;\
+  }\
 } while(0)
 
 static void
@@ -53,41 +87,41 @@ void
 mrb_str_modify(mrb_state *mrb, struct RString *s)
 {
   if (STR_SHARED_P(s)) {
-    mrb_shared_string *shared = s->aux.shared;
+    mrb_shared_string *shared = s->as.heap.aux.shared;
 
-    if (shared->refcnt == 1 && s->ptr == shared->ptr) {
-      s->ptr = shared->ptr;
-      s->aux.capa = shared->len;
-      s->ptr[s->len] = '\0';
+    if (shared->refcnt == 1 && s->as.heap.ptr == shared->ptr) {
+      s->as.heap.ptr = shared->ptr;
+      s->as.heap.aux.capa = shared->len;
+      STR_PTR(s)[s->as.heap.len] = '\0';
       mrb_free(mrb, shared);
     }
     else {
       char *ptr, *p;
       mrb_int len;
 
-      p = s->ptr;
-      len = s->len;
+      p = STR_PTR(s);
+      len = s->as.heap.len;
       ptr = (char *)mrb_malloc(mrb, (size_t)len + 1);
       if (p) {
         memcpy(ptr, p, len);
       }
-      ptr[len] =  '\0';
-      s->ptr = ptr;
-      s->aux.capa = len;
+      ptr[len] = '\0';
+      s->as.heap.ptr = ptr;
+      s->as.heap.aux.capa = len;
       str_decref(mrb, shared);
     }
     STR_UNSET_SHARED_FLAG(s);
     return;
   }
   if (s->flags & MRB_STR_NOFREE) {
-    char *p = s->ptr;
+    char *p = STR_PTR(s);
 
-    s->ptr = (char *)mrb_malloc(mrb, (size_t)s->len+1);
+    s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)s->as.heap.len+1);
     if (p) {
-      memcpy(s->ptr, p, s->len);
+      memcpy(STR_PTR(s), p, s->as.heap.len);
     }
-    s->ptr[s->len] = '\0';
-    s->aux.capa = s->len;
+    STR_PTR(s)[s->as.heap.len] = '\0';
+    s->as.heap.aux.capa = s->as.heap.len;
     s->flags &= ~MRB_STR_NOFREE;
     return;
   }
@@ -100,13 +134,13 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len)
   struct RString *s = mrb_str_ptr(str);
 
   mrb_str_modify(mrb, s);
-  slen = s->len;
+  slen = STR_LEN(s);
   if (len != slen) {
     if (slen < len || slen - len > 256) {
       RESIZE_CAPA(s, len);
     }
-    s->len = len;
-    s->ptr[len] = '\0';   /* sentinel */
+    STR_SET_LEN(s, len);
+    STR_PTR(s)[len] = '\0';   /* sentinel */
   }
   return str;
 }
@@ -126,13 +160,21 @@ str_new(mrb_state *mrb, const char *p, mrb_int len)
   struct RString *s;
 
   s = mrb_obj_alloc_string(mrb);
-  s->len = len;
-  s->aux.capa = len;
-  s->ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
-  if (p) {
-    memcpy(s->ptr, p, len);
+  if (len < RSTRING_EMBED_LEN_MAX) {
+    STR_SET_EMBED_FLAG(s);
+    STR_SET_EMBED_LEN(s,len);
+    if (p) {
+      memcpy(s->as.ary, p, len);
+    }
+  } else {
+    s->as.heap.len = len;
+    s->as.heap.aux.capa = len;
+    s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
+    if (p) {
+      memcpy(s->as.heap.ptr, p, len);
+    }
   }
-  s->ptr[len] = '\0';
+  STR_PTR(s)[len] = '\0';
   return s;
 }
 
@@ -165,10 +207,10 @@ mrb_str_buf_new(mrb_state *mrb, mrb_int capa)
   if (capa < MRB_STR_BUF_MIN_SIZE) {
     capa = MRB_STR_BUF_MIN_SIZE;
   }
-  s->len = 0;
-  s->aux.capa = capa;
-  s->ptr = (char *)mrb_malloc(mrb, capa+1);
-  s->ptr[0] = '\0';
+  s->as.heap.len = 0;
+  s->as.heap.aux.capa = capa;
+  s->as.heap.ptr = (char *)mrb_malloc(mrb, capa+1);
+  STR_PTR(s)[0] = '\0';
 
   return mrb_obj_value(s);
 }
@@ -181,15 +223,20 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
   ptrdiff_t off = -1;
 
   mrb_str_modify(mrb, s);
-  if (ptr >= s->ptr && ptr <= s->ptr + s->len) {
-      off = ptr - s->ptr;
+  if (ptr >= STR_PTR(s) && ptr <= STR_PTR(s) + STR_LEN(s)) {
+      off = ptr - STR_PTR(s);
   }
   if (len == 0) return;
-  capa = s->aux.capa;
-  if (s->len >= MRB_INT_MAX - (mrb_int)len) {
+
+  if (STR_EMBED_P(s))
+    capa = RSTRING_EMBED_LEN_MAX;
+  else
+    capa = s->as.heap.aux.capa;
+
+  if (STR_LEN(s) >= MRB_INT_MAX - (mrb_int)len) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big");
   }
-  total = s->len+len;
+  total = STR_LEN(s)+len;
   if (capa <= total) {
     while (total > capa) {
         if (capa + 1 >= MRB_INT_MAX / 2) {
@@ -201,11 +248,11 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
     RESIZE_CAPA(s, capa);
   }
   if (off != -1) {
-      ptr = s->ptr + off;
+      ptr = STR_PTR(s) + off;
   }
-  memcpy(s->ptr + s->len, ptr, len);
-  s->len = total;
-  s->ptr[total] = '\0';   /* sentinel */
+  memcpy(STR_PTR(s) + STR_LEN(s), ptr, len);
+  STR_SET_LEN(s, total);
+  STR_PTR(s)[total] = '\0';   /* sentinel */
 }
 
 mrb_value
@@ -265,9 +312,9 @@ mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
   }
 
   s = mrb_obj_alloc_string(mrb);
-  s->len = len;
-  s->aux.capa = 0;             /* nofree */
-  s->ptr = (char *)p;
+  s->as.heap.len = len;
+  s->as.heap.aux.capa = 0;             /* nofree */
+  s->as.heap.ptr = (char *)p;
   s->flags = MRB_STR_NOFREE;
   return mrb_obj_value(s);
 }
@@ -275,10 +322,12 @@ mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
 void
 mrb_gc_free_str(mrb_state *mrb, struct RString *str)
 {
-  if (STR_SHARED_P(str))
-    str_decref(mrb, str->aux.shared);
+  if (STR_EMBED_P(str))
+    /* no code */;
+  else if (STR_SHARED_P(str))
+    str_decref(mrb, str->as.heap.aux.shared);
   else if ((str->flags & MRB_STR_NOFREE) == 0)
-    mrb_free(mrb, str->ptr);
+    mrb_free(mrb, str->as.heap.ptr);
 }
 
 char *
@@ -291,10 +340,10 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
   }
 
   s = str_new(mrb, RSTRING_PTR(str0), RSTRING_LEN(str0));
-  if ((strlen(s->ptr) ^ s->len) != 0) {
+  if ((strlen(STR_PTR(s)) ^ STR_LEN(s)) != 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
   }
-  return s->ptr;
+  return STR_PTR(s);
 }
 
 static void
@@ -304,22 +353,33 @@ str_make_shared(mrb_state *mrb, struct RString *s)
     mrb_shared_string *shared = (mrb_shared_string *)mrb_malloc(mrb, sizeof(mrb_shared_string));
 
     shared->refcnt = 1;
-    if (s->flags & MRB_STR_NOFREE) {
+    if (STR_EMBED_P(s)) {
+      const mrb_int len = STR_EMBED_LEN(s);
+      char *const tmp = (char *)mrb_malloc(mrb, len+1);
+      memcpy(tmp, s->as.ary, len);
+      tmp[len] = '\0';
+      STR_UNSET_EMBED_FLAG(s);
+      s->as.heap.ptr = tmp;
+      s->as.heap.len = len;
+      shared->nofree = FALSE;
+      shared->ptr = s->as.heap.ptr;
+    }
+    else if (s->flags & MRB_STR_NOFREE) {
       shared->nofree = TRUE;
-      shared->ptr = s->ptr;
+      shared->ptr = STR_PTR(s);
       s->flags &= ~MRB_STR_NOFREE;
     }
     else {
       shared->nofree = FALSE;
-      if (s->aux.capa > s->len) {
-        s->ptr = shared->ptr = (char *)mrb_realloc(mrb, s->ptr, s->len+1);
+      if (s->as.heap.aux.capa > s->as.heap.len) {
+        s->as.heap.ptr = shared->ptr = (char *)mrb_realloc(mrb, STR_PTR(s), s->as.heap.len+1);
       }
       else {
-        shared->ptr = s->ptr;
+        shared->ptr = STR_PTR(s);
       }
     }
-    shared->len = s->len;
-    s->aux.shared = shared;
+    shared->len = s->as.heap.len;
+    s->as.heap.aux.shared = shared;
     STR_SET_SHARED_FLAG(s);
   }
 }
@@ -335,8 +395,8 @@ mrb_str_body(mrb_value str, int *len_p)
 {
   struct RString *s = mrb_str_ptr(str);
 
-  *len_p = s->len;
-  return s->ptr;
+  *len_p = STR_LEN(s);
+  return STR_PTR(s);
 }
 
 /*
@@ -356,15 +416,14 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
     other = mrb_str_to_str(mrb, other);
   }
   s2 = mrb_str_ptr(other);
-  len = s1->len + s2->len;
+  len = STR_LEN(s1) + STR_LEN(s2);
 
-  if (s1->aux.capa < len) {
-    s1->aux.capa = len;
-    s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, len+1);
+  if (RSTRING_CAPA(self) < len) {
+    RESIZE_CAPA(s1, len);
   }
-  memcpy(s1->ptr+s1->len, s2->ptr, s2->len);
-  s1->len = len;
-  s1->ptr[len] =  '\0';
+  memcpy(STR_PTR(s1)+STR_LEN(s1), STR_PTR(s2), STR_LEN(s2));
+  STR_SET_LEN(s1, len);
+  STR_PTR(s1)[len] = '\0';
 }
 
 /*
@@ -380,9 +439,9 @@ mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b)
   struct RString *s2 = mrb_str_ptr(b);
   struct RString *t;
 
-  t = str_new(mrb, 0, s->len + s2->len);
-  memcpy(t->ptr, s->ptr, s->len);
-  memcpy(t->ptr + s->len, s2->ptr, s2->len);
+  t = str_new(mrb, 0, STR_LEN(s) + STR_LEN(s2));
+  memcpy(STR_PTR(t), STR_PTR(s), STR_LEN(s));
+  memcpy(STR_PTR(t) + STR_LEN(s), STR_PTR(s2), STR_LEN(s2));
 
   return mrb_obj_value(t);
 }
@@ -414,7 +473,7 @@ static mrb_value
 mrb_str_bytesize(mrb_state *mrb, mrb_value self)
 {
   struct RString *s = mrb_str_ptr(self);
-  return mrb_fixnum_value(s->len);
+  return mrb_fixnum_value(STR_LEN(s));
 }
 
 /* 15.2.10.5.26 */
@@ -429,7 +488,7 @@ mrb_value
 mrb_str_size(mrb_state *mrb, mrb_value self)
 {
   struct RString *s = mrb_str_ptr(self);
-  return mrb_fixnum_value(s->len);
+  return mrb_fixnum_value(STR_LEN(s));
 }
 
 /* 15.2.10.5.1  */
@@ -460,7 +519,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
   len = RSTRING_LEN(self)*times;
   str2 = str_new(mrb, 0, len);
   str_with_class(mrb, str2, self);
-  p = str2->ptr;
+  p = STR_PTR(str2);
   if (len > 0) {
     n = RSTRING_LEN(self);
     memcpy(p, RSTRING_PTR(self), n);
@@ -470,7 +529,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
     }
     memcpy(p + n, p, len-n);
   }
-  p[str2->len] = '\0';
+  p[STR_LEN(str2)] = '\0';
 
   return mrb_obj_value(str2);
 }
@@ -494,11 +553,11 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)
   struct RString *s1 = mrb_str_ptr(str1);
   struct RString *s2 = mrb_str_ptr(str2);
 
-  len = lesser(s1->len, s2->len);
-  retval = memcmp(s1->ptr, s2->ptr, len);
+  len = lesser(STR_LEN(s1), STR_LEN(s2));
+  retval = memcmp(STR_PTR(s1), STR_PTR(s2), len);
   if (retval == 0) {
-    if (s1->len == s2->len) return 0;
-    if (s1->len > s2->len)  return 1;
+    if (STR_LEN(s1) == STR_LEN(s2)) return 0;
+    if (STR_LEN(s1) > STR_LEN(s2))  return 1;
     return -1;
   }
   if (retval > 0) return 1;
@@ -724,7 +783,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str)
   /* should return shared string */
   struct RString *s = mrb_str_ptr(str);
 
-  return mrb_str_new(mrb, s->ptr, s->len);
+  return mrb_str_new(mrb, STR_PTR(s), STR_LEN(s));
 }
 
 static mrb_value
@@ -853,8 +912,8 @@ mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   mrb_str_modify(mrb, s);
-  if (s->len == 0 || !s->ptr) return mrb_nil_value();
-  p = s->ptr; pend = s->ptr + s->len;
+  if (STR_LEN(s) == 0 || !STR_PTR(s)) return mrb_nil_value();
+  p = STR_PTR(s); pend = STR_PTR(s) + STR_LEN(s);
   if (ISLOWER(*p)) {
     *p = TOUPPER(*p);
     modify = 1;
@@ -910,29 +969,29 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   mrb_str_modify(mrb, s);
-  len = s->len;
+  len = STR_LEN(s);
   if (mrb_get_args(mrb, "|S", &rs) == 0) {
     if (len == 0) return mrb_nil_value();
   smart_chomp:
-    if (s->ptr[len-1] == '\n') {
-      s->len--;
-      if (s->len > 0 &&
-          s->ptr[s->len-1] == '\r') {
-        s->len--;
+    if (STR_PTR(s)[len-1] == '\n') {
+      STR_SET_LEN(s, STR_LEN(s) - 1);
+      if (STR_LEN(s) > 0 &&
+          STR_PTR(s)[STR_LEN(s)-1] == '\r') {
+        STR_SET_LEN(s, STR_LEN(s) - 1);
       }
     }
-    else if (s->ptr[len-1] == '\r') {
-      s->len--;
+    else if (STR_PTR(s)[len-1] == '\r') {
+      STR_SET_LEN(s, STR_LEN(s) - 1);
     }
     else {
       return mrb_nil_value();
     }
-    s->ptr[s->len] = '\0';
+    STR_PTR(s)[STR_LEN(s)] = '\0';
     return str;
   }
 
   if (len == 0 || mrb_nil_p(rs)) return mrb_nil_value();
-  p = s->ptr;
+  p = STR_PTR(s);
   rslen = RSTRING_LEN(rs);
   if (rslen == 0) {
     while (len>0 && p[len-1] == '\n') {
@@ -940,8 +999,8 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
       if (len>0 && p[len-1] == '\r')
         len--;
     }
-    if (len < s->len) {
-      s->len = len;
+    if (len < STR_LEN(s)) {
+      STR_SET_LEN(s, len);
       p[len] = '\0';
       return str;
     }
@@ -958,8 +1017,8 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
   if (p[len-1] == newline &&
      (rslen <= 1 ||
      memcmp(RSTRING_PTR(rs), pp, rslen) == 0)) {
-    s->len = len - rslen;
-    p[s->len] = '\0';
+    STR_SET_LEN(s, len - rslen);
+    p[STR_LEN(s)] = '\0';
     return str;
   }
   return mrb_nil_value();
@@ -1009,17 +1068,17 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   mrb_str_modify(mrb, s);
-  if (s->len > 0) {
+  if (STR_LEN(s) > 0) {
     int len;
-    len = s->len - 1;
-    if (s->ptr[len] == '\n') {
+    len = STR_LEN(s) - 1;
+    if (STR_PTR(s)[len] == '\n') {
       if (len > 0 &&
-          s->ptr[len-1] == '\r') {
+          STR_PTR(s)[len-1] == '\r') {
         len--;
       }
     }
-    s->len = len;
-    s->ptr[len] = '\0';
+    STR_SET_LEN(s, len);
+    STR_PTR(s)[len] = '\0';
     return str;
   }
   return mrb_nil_value();
@@ -1067,8 +1126,8 @@ mrb_str_downcase_bang(mrb_state *mrb, mrb_value str)
   struct RString *s = mrb_str_ptr(str);
 
   mrb_str_modify(mrb, s);
-  p = s->ptr;
-  pend = s->ptr + s->len;
+  p = STR_PTR(s);
+  pend = STR_PTR(s) + STR_LEN(s);
   while (p < pend) {
     if (ISUPPER(*p)) {
       *p = TOLOWER(*p);
@@ -1117,7 +1176,7 @@ mrb_str_empty_p(mrb_state *mrb, mrb_value self)
 {
   struct RString *s = mrb_str_ptr(self);
 
-  return mrb_bool_value(s->len == 0);
+  return mrb_bool_value(STR_LEN(s) == 0);
 }
 
 /* 15.2.10.5.17 */
@@ -1146,14 +1205,18 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
   mrb_shared_string *shared;
 
   orig = mrb_str_ptr(str);
-  str_make_shared(mrb, orig);
-  shared = orig->aux.shared;
-  s = mrb_obj_alloc_string(mrb);
-  s->ptr = orig->ptr + beg;
-  s->len = len;
-  s->aux.shared = shared;
-  STR_SET_SHARED_FLAG(s);
-  shared->refcnt++;
+  if (STR_EMBED_P(orig)) {
+    s = str_new(mrb, orig->as.ary+beg, len);
+  } else {
+    str_make_shared(mrb, orig);
+    shared = orig->as.heap.aux.shared;
+    s = mrb_obj_alloc_string(mrb);
+    s->as.heap.ptr = orig->as.heap.ptr + beg;
+    s->as.heap.len = len;
+    s->as.heap.aux.shared = shared;
+    STR_SET_SHARED_FLAG(s);
+    shared->refcnt++;
+  }
 
   return mrb_obj_value(s);
 }
@@ -1194,8 +1257,8 @@ mrb_str_hash(mrb_state *mrb, mrb_value str)
 {
   /* 1-8-7 */
   struct RString *s = mrb_str_ptr(str);
-  mrb_int len = s->len;
-  char *p = s->ptr;
+  mrb_int len = STR_LEN(s);
+  char *p = STR_PTR(s);
   mrb_int key = 0;
 
   while (len--) {
@@ -1341,38 +1404,36 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str)
 static mrb_value
 str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
 {
+  long len;
+
+  len = STR_LEN(s2);
   if (STR_SHARED_P(s2)) {
   L_SHARE:
     if (STR_SHARED_P(s1)) {
-      str_decref(mrb, s1->aux.shared);
+      str_decref(mrb, s1->as.heap.aux.shared);
     }
-    else {
-      mrb_free(mrb, s1->ptr);
+    else if (!STR_EMBED_P(s1) && !(s1->flags & MRB_STR_NOFREE)) {
+      mrb_free(mrb, s1->as.heap.ptr);
     }
-    s1->ptr = s2->ptr;
-    s1->len = s2->len;
-    s1->aux.shared = s2->aux.shared;
+    STR_UNSET_EMBED_FLAG(s1);
+    s1->as.heap.ptr = s2->as.heap.ptr;
+    s1->as.heap.len = len;
+    s1->as.heap.aux.shared = s2->as.heap.aux.shared;
     STR_SET_SHARED_FLAG(s1);
-    s1->aux.shared->refcnt++;
-  }
-  else if (s2->len > STR_REPLACE_SHARED_MIN) {
-    str_make_shared(mrb, s2);
-    goto L_SHARE;
+    s1->as.heap.aux.shared->refcnt++;
   }
   else {
-    if (STR_SHARED_P(s1)) {
-      str_decref(mrb, s1->aux.shared);
-      STR_UNSET_SHARED_FLAG(s1);
-      s1->ptr = (char *)mrb_malloc(mrb, s2->len+1);
+    if (len <= RSTRING_EMBED_LEN_MAX) {
+      STR_SET_EMBED_FLAG(s1);
+      memcpy(STR_PTR(s1), STR_PTR(s2), len);
+      STR_SET_EMBED_LEN(s1, len);
     }
     else {
-      s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, s2->len+1);
+      str_make_shared(mrb, s2);
+      goto L_SHARE;
     }
-    memcpy(s1->ptr, s2->ptr, s2->len);
-    s1->ptr[s2->len] = 0;
-    s1->len = s2->len;
-    s1->aux.capa = s2->len;
   }
+
   return mrb_obj_value(s1);
 }
 
@@ -1466,7 +1527,7 @@ mrb_ptr_to_str(mrb_state *mrb, void *p)
   uintptr_t n = (uintptr_t)p;
 
   p_str = str_new(mrb, NULL, 2 + sizeof(uintptr_t) * CHAR_BIT / 4);
-  p1 = p_str->ptr;
+  p1 = STR_PTR(p_str);
   *p1++ = '0';
   *p1++ = 'x';
   p2 = p1;
@@ -1476,7 +1537,7 @@ mrb_ptr_to_str(mrb_state *mrb, void *p)
     n /= 16;
   } while (n > 0);
   *p2 = '\0';
-  p_str->len = (mrb_int)(p2 - p_str->ptr);
+  STR_SET_LEN(p_str, (mrb_int)(p2 - STR_PTR(p_str)));
 
   while (p1 < p2) {
     const char  c = *p1;
@@ -1515,12 +1576,12 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str)
   struct RString *s2;
   char *s, *e, *p;
 
-  if (RSTRING(str)->len <= 1) return mrb_str_dup(mrb, str);
+  if (RSTRING_LEN(str) <= 1) return mrb_str_dup(mrb, str);
 
-  s2 = str_new(mrb, 0, RSTRING(str)->len);
+  s2 = str_new(mrb, 0, RSTRING_LEN(str));
   str_with_class(mrb, s2, str);
   s = RSTRING_PTR(str); e = RSTRING_END(str) - 1;
-  p = s2->ptr;
+  p = STR_PTR(s2);
 
   while (e >= s) {
     *p++ = *e--;
@@ -1543,9 +1604,9 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
   char c;
 
   mrb_str_modify(mrb, s);
-  if (s->len > 1) {
-    p = s->ptr;
-    e = p + s->len - 1;
+  if (STR_LEN(s) > 1) {
+    p = STR_PTR(s);
+    e = p + STR_LEN(s) - 1;
     while (p < e) {
       c = *p;
       *p++ = *e;
@@ -1578,21 +1639,20 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)
 {
   char *s, *sbeg, *t;
   struct RString *ps = mrb_str_ptr(str);
-  struct RString *psub = mrb_str_ptr(sub);
-  mrb_int len = psub->len;
+  mrb_int len = RSTRING_LEN(sub);
 
   /* substring longer than string */
-  if (ps->len < len) return -1;
-  if (ps->len - pos < len) {
-    pos = ps->len - len;
+  if (STR_LEN(ps) < len) return -1;
+  if (STR_LEN(ps) - pos < len) {
+    pos = STR_LEN(ps) - len;
   }
-  sbeg = ps->ptr;
-  s = ps->ptr + pos;
-  t = psub->ptr;
+  sbeg = STR_PTR(ps);
+  s = STR_PTR(ps) + pos;
+  t = RSTRING_PTR(sub);
   if (len) {
     while (sbeg <= s) {
       if (memcmp(s, t, len) == 0) {
-        return s - ps->ptr;
+        return s - STR_PTR(ps);
       }
       s--;
     }
@@ -1823,7 +1883,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
     }
   }
   else if (split_type == string) {
-    char *ptr = RSTRING_PTR(str);
+    char *ptr = RSTRING_PTR(str); // s->as.ary
     char *temp = ptr;
     char *eptr = RSTRING_END(str);
     mrb_int slen = RSTRING_LEN(spat);
@@ -2006,9 +2066,9 @@ char *
 mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 {
   struct RString *ps = mrb_str_ptr(*ptr);
-  char *s = ps->ptr;
+  char *s = STR_PTR(ps);
 
-  if (!s || ps->len != strlen(s)) {
+  if (!s || STR_LEN(ps) != strlen(s)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
   }
   return s;
@@ -2031,7 +2091,7 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
     len = RSTRING_LEN(str);
     if (s[len]) {    /* no sentinel somehow */
       struct RString *temp_str = str_new(mrb, s, len);
-      s = temp_str->ptr;
+      s = STR_PTR(temp_str);
     }
   }
   return mrb_cstr_to_inum(mrb, s, base, badcheck);
@@ -2161,7 +2221,7 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck)
     }
     if (s[len]) {    /* no sentinel somehow */
       struct RString *temp_str = str_new(mrb, s, len);
-      s = temp_str->ptr;
+      s = STR_PTR(temp_str);
     }
   }
   return mrb_cstr_to_dbl(mrb, s, badcheck);
@@ -2300,8 +2360,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
   result = str_new(mrb, 0, len);
   str_with_class(mrb, result, str);
   p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
-  q = result->ptr;
-
+  q = STR_PTR(result);
   *q++ = '"';
   while (p < pend) {
     unsigned char c = *p++;
@@ -2477,8 +2536,8 @@ static mrb_value
 mrb_str_bytes(mrb_state *mrb, mrb_value str)
 {
   struct RString *s = mrb_str_ptr(str);
-  mrb_value a = mrb_ary_new_capa(mrb, s->len);
-  unsigned char *p = (unsigned char *)(s->ptr), *pend = p + s->len;
+  mrb_value a = mrb_ary_new_capa(mrb, STR_LEN(s));
+  unsigned char *p = (unsigned char *)(STR_PTR(s)), *pend = p + STR_LEN(s);
 
   while (p < pend) {
     mrb_ary_push(mrb, a, mrb_fixnum_value(p[0]));
diff --git a/src/symbol.c b/src/symbol.c
index 7971f71ca..95e8ed290 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -397,11 +397,11 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
 
   name = mrb_sym2name_len(mrb, id, &len);
   str = mrb_str_new(mrb, 0, len+1);
-  RSTRING(str)->ptr[0] = ':';
-  memcpy(RSTRING(str)->ptr+1, name, len);
+  RSTRING_PTR(str)[0] = ':';
+  memcpy(RSTRING_PTR(str)+1, name, len);
   if (!symname_p(name) || strlen(name) != len) {
     str = mrb_str_dump(mrb, str);
-    memcpy(RSTRING(str)->ptr, ":\"", 2);
+    memcpy(RSTRING_PTR(str), ":\"", 2);
   }
   return str;
 }
@@ -428,7 +428,7 @@ mrb_sym2name(mrb_state *mrb, mrb_sym sym)
   }
   else {
     mrb_value str = mrb_str_dump(mrb, mrb_str_new_static(mrb, name, len));
-    return RSTRING(str)->ptr;
+    return RSTRING_PTR(str);
   }
 }