embed small string

use flags 4 for *this object is embed*
use flags 8~64 for *embed string length*

include/mruby/string.h

@@ -15,25 +15,34 @@ extern "C" {
 
 extern const char mrb_digitmap[];
 
+#define RSTRING_EMBED_LEN_MAX ((mrb_int)((sizeof(mrb_int)*2+sizeof(char*))/sizeof(char)-1))
 struct RString {
   MRB_OBJECT_HEADER;
-  mrb_int len;
   union {
-    mrb_int capa;
-    struct mrb_shared_string *shared;
-  } aux;
-  char *ptr;
+    struct {
+      mrb_int len;
+      union {
+        mrb_int capa;
+        struct mrb_shared_string *shared;
+      } aux;
+      char *ptr;
+    } heap;
+    char ary[RSTRING_EMBED_LEN_MAX + 1];
+  } as;
 };
 
 #define mrb_str_ptr(s)    ((struct RString*)(mrb_ptr(s)))
 #define RSTRING(s)        ((struct RString*)(mrb_ptr(s)))
-#define RSTRING_PTR(s)    (RSTRING(s)->ptr)
-#define RSTRING_LEN(s)    (RSTRING(s)->len)
-#define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
-#define RSTRING_END(s)    (RSTRING(s)->ptr + RSTRING(s)->len)
+#define RSTRING_PTR(s)    (RSTRING(s)->as.heap.ptr)
+#define RSTRING_LEN(s)    (RSTRING(s)->as.heap.len)
+#define RSTRING_CAPA(s)   (RSTRING(s)->as.heap.aux.capa)
+#define RSTRING_END(s)    (RSTRING(s)->as.heap.ptr + RSTRING(s)->as.heap.len)
 
 #define MRB_STR_SHARED    1
 #define MRB_STR_NOFREE    2
+#define MRB_STR_EMBED     4
+#define MRB_STR_EMBED_LEN_MASK 120
+#define MRB_STR_EMBED_LEN_SHIFT 3
 
 void mrb_gc_free_str(mrb_state*, struct RString*);
 void mrb_str_modify(mrb_state*, struct RString*);

mrbgems/mruby-print/src/print.c

@@ -11,8 +11,8 @@ printstr(mrb_state *mrb, mrb_value obj)
 
   if (mrb_string_p(obj)) {
     str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = str->as.heap.ptr;
+    len = str->as.heap.len;
     fwrite(s, len, 1, stdout);
   }
 }

mrbgems/mruby-sprintf/src/sprintf.c

@@ -712,7 +712,7 @@ retry:
         if (*p == 'p') arg = mrb_inspect(mrb, arg);
         str = mrb_obj_as_string(mrb, arg);
         len = RSTRING_LEN(str);
-        RSTRING_LEN(result) = blen;
+        RSTRING(result)->as.heap.len = blen;
         if (flags&(FPREC|FWIDTH)) {
           slen = RSTRING_LEN(str);
           if (slen < 0) {

mrbgems/mruby-string-ext/src/string.c

@@ -33,8 +33,8 @@ mrb_str_swapcase_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 = s->as.heap.ptr;
+  pend = s->as.heap.ptr + s->as.heap.len;
   while (p < pend) {
     if (ISUPPER(*p)) {
       *p = TOLOWER(*p);

src/class.c

@@ -520,8 +520,8 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           s = mrb_str_ptr(ss);
-          *ps = s->ptr;
-          *pl = s->len;
+          *ps = s->as.heap.ptr;
+          *pl = s->as.heap.len;
           i++;
         }
       }
@@ -537,14 +537,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(s->as.heap.ptr);
+          if (len < s->as.heap.len) {
             mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
           }
-          else if (len > s->len) {
+          else if (len > s->as.heap.len) {
             mrb_str_modify(mrb, s);
           }
-          *ps = s->ptr;
+          *ps = s->as.heap.ptr;
           i++;
         }
       }
@@ -1298,7 +1298,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 mrb_str_ptr(path)->as.heap.ptr;
 }
 
 const char*

src/object.c

@@ -410,7 +410,7 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
         }
         else if (mrb_special_const_p(x)) {
           s = mrb_str_ptr(mrb_obj_as_string(mrb, x));
-          etype = s->ptr;
+          etype = s->as.heap.ptr;
         }
         else {
           etype = mrb_obj_classname(mrb, x);

src/print.c

@@ -18,8 +18,8 @@ printstr(mrb_state *mrb, mrb_value obj)
 
   if (mrb_string_p(obj)) {
     str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = str->as.heap.ptr;
+    len = str->as.heap.len;
     fwrite(s, len, 1, stdout);
   }
 #endif
@@ -45,7 +45,7 @@ mrb_print_error(mrb_state *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(str->as.heap.ptr, str->as.heap.len, 1, stderr);
     putc('\n', stderr);
   }
 #endif

src/state.c

@@ -136,7 +136,7 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
   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);
+        mrb_free(mrb, mrb_str_ptr(irep->pool[i])->as.heap.ptr);
       }
       mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
     }
@@ -169,19 +169,19 @@ mrb_str_pool(mrb_state *mrb, mrb_value str)
   ns->tt = MRB_TT_STRING;
   ns->c = mrb->string_class;
 
-  len = s->len;
-  ns->len = len;
+  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);
+    if (s->as.heap.ptr) {
+      memcpy(ns->as.heap.ptr, s->as.heap.ptr, len);
     }
-    ns->ptr[len] = '\0';
+    ns->as.heap.ptr[len] = '\0';
   }
   return mrb_obj_value(ns);
 }

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);
   }
 }
 

test/driver.c

@@ -67,8 +67,8 @@ t_printstr(mrb_state *mrb, mrb_value obj)
    
   if (mrb_string_p(obj)) {
     str = mrb_str_ptr(obj);
-    s = str->ptr;
-    len = str->len;
+    s = str->as.heap.ptr;
+    len = str->as.heap.len;
     fwrite(s, len, 1, stdout);
   }
 }