diff --git a/ChangeLog b/ChangeLog
index b51fed5bdd..d52b3d1a0e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+Thu Aug 31 18:23:00 2006  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* ruby.h (struct RString): embed small strings.
+	  (RSTRING_LEN): defined for accessing string members.
+	  (RSTRING_PTR): ditto.
+
+	* string.c: use RSTRING_LEN and RSTRING_PTR.
+
 Thu Aug 31 17:16:19 2006  Yukihiro Matsumoto  <matz@ruby-lang.org>
 
 	* array.c (rb_ary_shuffle_bang): new method.
diff --git a/bignum.c b/bignum.c
index 8a5dd41782..dd29124995 100644
--- a/bignum.c
+++ b/bignum.c
@@ -494,10 +494,10 @@ rb_str_to_inum(VALUE str, int base, int badcheck)
 	s = StringValueCStr(str);
     }
     else {
-	s = RSTRING(str)->ptr;
+	s = RSTRING_PTR(str);
     }
     if (s) {
-	len = RSTRING(str)->len;
+	len = RSTRING_LEN(str);
 	if (s[len]) {		/* no sentinel somehow */
 	    char *p = ALLOCA_N(char, len+1);
 
@@ -631,7 +631,7 @@ rb_big2str(VALUE x, int base)
     t = rb_big_clone(x);
     ds = BDIGITS(t);
     ss = rb_str_new(0, j);
-    s = RSTRING(ss)->ptr;
+    s = RSTRING_PTR(ss);
 
     s[0] = RBIGNUM(x)->sign ? '+' : '-';
     while (i && j) {
@@ -653,9 +653,9 @@ rb_big2str(VALUE x, int base)
 	}
     }
     while (s[j] == '0') j++;
-    RSTRING(ss)->len -= RBIGNUM(x)->sign?j:j-1;
-    memmove(RBIGNUM(x)->sign?s:s+1, s+j, RSTRING(ss)->len);
-    s[RSTRING(ss)->len] = '\0';
+    i = RSTRING_LEN(ss)-(RBIGNUM(x)->sign?j:j-1);
+    memmove(RBIGNUM(x)->sign?s:s+1, s+j, i);
+    rb_str_set_len(ss, i);
 
     return ss;
 }
diff --git a/dir.c b/dir.c
index 3a8eb61b1c..90b23c67cd 100644
--- a/dir.c
+++ b/dir.c
@@ -394,17 +394,17 @@ dir_initialize(VALUE dir, VALUE dirname)
     if (dp->path) free(dp->path);
     dp->dir = NULL;
     dp->path = NULL;
-    dp->dir = opendir(RSTRING(dirname)->ptr);
+    dp->dir = opendir(RSTRING_PTR(dirname));
     if (dp->dir == NULL) {
 	if (errno == EMFILE || errno == ENFILE) {
 	    rb_gc();
-	    dp->dir = opendir(RSTRING(dirname)->ptr);
+	    dp->dir = opendir(RSTRING_PTR(dirname));
 	}
 	if (dp->dir == NULL) {
-	    rb_sys_fail(RSTRING(dirname)->ptr);
+	    rb_sys_fail(RSTRING_PTR(dirname));
 	}
     }
-    dp->path = strdup(RSTRING(dirname)->ptr);
+    dp->path = strdup(RSTRING_PTR(dirname));
 
     return dir;
 }
@@ -470,7 +470,7 @@ dir_inspect(VALUE dir)
 	char *c = rb_obj_classname(dir);
 	int len = strlen(c) + strlen(dirp->path) + 4;
 	VALUE s = rb_str_new(0, len);
-	snprintf(RSTRING(s)->ptr, len+1, "#<%s:%s>", c, dirp->path);
+	snprintf(RSTRING_PTR(s), len+1, "#<%s:%s>", c, dirp->path);
 	return s;
     }
     return rb_funcall(dir, rb_intern("to_s"), 0, 0);
@@ -688,8 +688,8 @@ dir_close(VALUE dir)
 static void
 dir_chdir(VALUE path)
 {
-    if (chdir(RSTRING(path)->ptr) < 0)
-	rb_sys_fail(RSTRING(path)->ptr);
+    if (chdir(RSTRING_PTR(path)) < 0)
+	rb_sys_fail(RSTRING_PTR(path));
 }
 
 static int chdir_blocking = 0;
@@ -831,7 +831,7 @@ check_dirname(volatile VALUE *dir)
 
     rb_secure(2);
     FilePathValue(*dir);
-    path = RSTRING(*dir)->ptr;
+    path = RSTRING_PTR(*dir);
     if (path && *(pend = rb_path_end(rb_path_skip_prefix(path)))) {
 	*dir = rb_str_new(path, pend - path);
     }
@@ -852,8 +852,8 @@ dir_s_chroot(VALUE dir, VALUE path)
 #if defined(HAVE_CHROOT) && !defined(__CHECKER__)
     check_dirname(&path);
 
-    if (chroot(RSTRING(path)->ptr) == -1)
-	rb_sys_fail(RSTRING(path)->ptr);
+    if (chroot(RSTRING_PTR(path)) == -1)
+	rb_sys_fail(RSTRING_PTR(path));
 
     return INT2FIX(0);
 #else
@@ -889,8 +889,8 @@ dir_s_mkdir(int argc, VALUE *argv, VALUE obj)
     }
 
     check_dirname(&path);
-    if (mkdir(RSTRING(path)->ptr, mode) == -1)
-	rb_sys_fail(RSTRING(path)->ptr);
+    if (mkdir(RSTRING_PTR(path), mode) == -1)
+	rb_sys_fail(RSTRING_PTR(path));
 
     return INT2FIX(0);
 }
@@ -908,8 +908,8 @@ static VALUE
 dir_s_rmdir(VALUE obj, VALUE dir)
 {
     check_dirname(&dir);
-    if (rmdir(RSTRING(dir)->ptr) < 0)
-	rb_sys_fail(RSTRING(dir)->ptr);
+    if (rmdir(RSTRING_PTR(dir)) < 0)
+	rb_sys_fail(RSTRING_PTR(dir));
 
     return INT2FIX(0);
 }
@@ -1501,17 +1501,17 @@ rb_push_glob(VALUE str, int flags) /* '\0' is delimiter */
 
     ary = rb_ary_new();
 
-    while (offset < RSTRING(str)->len) {
-	int status = push_glob(ary, RSTRING(str)->ptr + offset, flags);
+    while (offset < RSTRING_LEN(str)) {
+	int status = push_glob(ary, RSTRING_PTR(str) + offset, flags);
 	char *p, *pend;
 	if (status) rb_jump_tag(status);
-	if (offset >= RSTRING(str)->len) break;
-	p = RSTRING(str)->ptr + offset;
+	if (offset >= RSTRING_LEN(str)) break;
+	p = RSTRING_PTR(str) + offset;
 	p += strlen(p) + 1;
-	pend = RSTRING(str)->ptr + RSTRING(str)->len;
+	pend = RSTRING_PTR(str) + RSTRING_LEN(str);
 	while (p < pend && !*p)
 	    p++;
-	offset = p - RSTRING(str)->ptr;
+	offset = p - RSTRING_PTR(str);
     }
 
     return ary;
@@ -1527,7 +1527,7 @@ dir_globs(long argc, VALUE *argv, int flags)
 	int status;
 	VALUE str = argv[i];
 	FilePathValue(str);
-	status = push_glob(ary, RSTRING(str)->ptr, flags);
+	status = push_glob(ary, RSTRING_PTR(str), flags);
 	if (status) rb_jump_tag(status);
     }
 
@@ -1797,7 +1797,7 @@ file_s_fnmatch(int argc, VALUE *argv, VALUE obj)
     StringValue(pattern);
     StringValue(path);
 
-    if (fnmatch(RSTRING(pattern)->ptr, RSTRING(path)->ptr, flags) == 0)
+    if (fnmatch(RSTRING_PTR(pattern), RSTRING_PTR(path), flags) == 0)
 	return Qtrue;
 
     return Qfalse;
diff --git a/error.c b/error.c
index cdb1b327a7..38d96ba4e7 100644
--- a/error.c
+++ b/error.c
@@ -221,7 +221,7 @@ rb_check_type(VALUE x, int t)
 		    etype = "Symbol";
 		}
 		else if (rb_special_const_p(x)) {
-		    etype = RSTRING(rb_obj_as_string(x))->ptr;
+		    etype = RSTRING_PTR(rb_obj_as_string(x));
 		}
 		else {
 		    etype = rb_obj_classname(x);
@@ -378,7 +378,7 @@ exc_inspect(VALUE exc)
 
     klass = CLASS_OF(exc);
     exc = rb_obj_as_string(exc);
-    if (RSTRING(exc)->len == 0) {
+    if (RSTRING_LEN(exc) == 0) {
 	return rb_str_dup(rb_class_name(klass));
     }
 
@@ -699,10 +699,10 @@ name_err_mesg_to_str(VALUE obj)
 	    break;
 	  default:
 	    d = rb_protect(rb_inspect, obj, 0);
-	    if (NIL_P(d) || RSTRING(d)->len > 65) {
+	    if (NIL_P(d) || RSTRING_LEN(d) > 65) {
 		d = rb_any_to_s(obj);
 	    }
-	    desc = RSTRING(d)->ptr;
+	    desc = RSTRING_PTR(d);
 	    break;
 	}
 	if (desc && desc[0] != '#') {
@@ -745,7 +745,7 @@ rb_invalid_str(const char *str, const char *type)
 {
     VALUE s = rb_str_inspect(rb_str_new2(str));
 
-    rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING(s)->ptr);
+    rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING_PTR(s));
 }
 
 /* 
@@ -856,7 +856,7 @@ syserr_initialize(int argc, VALUE *argv, VALUE self)
 
 	StringValue(str);
 	mesg = rb_sprintf("%s - %.*s", err,
-			  (int)RSTRING(str)->len, RSTRING(str)->ptr);
+			  (int)RSTRING_LEN(str), RSTRING_PTR(str));
     }
     else {
 	mesg = rb_str_new2(err);
diff --git a/eval.c b/eval.c
index 7729337eb4..63e3c36250 100644
--- a/eval.c
+++ b/eval.c
@@ -1246,7 +1246,7 @@ error_print(void)
 
 	if (NIL_P(mesg)) error_pos();
 	else {
-	    warn_print2(RSTRING(mesg)->ptr, RSTRING(mesg)->len);
+	    warn_print2(RSTRING_PTR(mesg), RSTRING_LEN(mesg));
 	}
     }
 
@@ -1254,8 +1254,8 @@ error_print(void)
     if (EXEC_TAG() == 0) {
 	e = rb_funcall(ruby_errinfo, rb_intern("message"), 0, 0);
 	StringValue(e);
-	einfo = RSTRING(e)->ptr;
-	elen = RSTRING(e)->len;
+	einfo = RSTRING_PTR(e);
+	elen = RSTRING_LEN(e);
     }
     else {
 	einfo = "";
@@ -1271,14 +1271,14 @@ error_print(void)
 	epath = rb_class_name(eclass);
 	if (elen == 0) {
 	    warn_print(": ");
-	    warn_print2(RSTRING(epath)->ptr, RSTRING(epath)->len);
+	    warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath));
 	    warn_print("\n");
 	}
 	else {
 	    char *tail  = 0;
 	    long len = elen;
 
-	    if (RSTRING(epath)->ptr[0] == '#') epath = 0;
+	    if (RSTRING_PTR(epath)[0] == '#') epath = 0;
 	    if (tail = memchr(einfo, '\n', elen)) {
 		len = tail - einfo;
 		tail++;		/* skip newline */
@@ -1287,7 +1287,7 @@ error_print(void)
 	    warn_print2(einfo, len);
 	    if (epath) {
 		warn_print(" (");
-		warn_print2(RSTRING(epath)->ptr, RSTRING(epath)->len);
+		warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath));
 		warn_print(")\n");
 	    }
 	    if (tail) {
@@ -1307,7 +1307,7 @@ error_print(void)
 	ep = RARRAY(errat);
 	for (i=1; i<ep->len; i++) {
 	    if (TYPE(ep->ptr[i]) == T_STRING) {
-		warn_printf("\tfrom %s\n", RSTRING(ep->ptr[i])->ptr);
+		warn_printf("\tfrom %s\n", RSTRING_PTR(ep->ptr[i]));
 	    }
 	    if (i == TRACE_HEAD && ep->len > TRACE_MAX) {
 		warn_printf("\t ... %ld levels...\n",
@@ -2642,7 +2642,7 @@ class_prefix(VALUE self, NODE *cpath)
 	    break;
 	  default:
 	    rb_raise(rb_eTypeError, "%s is not a class/module",
-		     RSTRING(rb_obj_as_string(c))->ptr);
+		     RSTRING_PTR(rb_obj_as_string(c)));
 	}
 	return c;
     }
@@ -3568,7 +3568,7 @@ rb_eval(VALUE self, NODE *n)
 		    break;
 		  default:
 		    rb_raise(rb_eTypeError, "%s is not a class/module",
-			     RSTRING(rb_obj_as_string(klass))->ptr);
+			     RSTRING_PTR(rb_obj_as_string(klass)));
 		    break;
 		}
 	    }
@@ -3666,7 +3666,10 @@ rb_eval(VALUE self, NODE *n)
 	break;
 
       case NODE_EVSTR:
-	result = rb_obj_as_string(rb_eval(self, node->nd_body));
+	if (!node->nd_body) result = rb_str_new(0,0);
+	else {
+	    result = rb_obj_as_string(rb_eval(self, node->nd_body));
+	}
 	break;
 
       case NODE_DSTR:
@@ -3696,11 +3699,11 @@ rb_eval(VALUE self, NODE *n)
 	    }
 	    switch (nd_type(node)) {
 	      case NODE_DREGX:
-		result = rb_reg_new(RSTRING(str)->ptr, RSTRING(str)->len,
+		result = rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str),
 				    node->nd_cflag);
 		break;
 	      case NODE_DREGX_ONCE:	/* regexp expand once */
-		result = rb_reg_new(RSTRING(str)->ptr, RSTRING(str)->len,
+		result = rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str),
 				    node->nd_cflag);
 		nd_set_type(node, NODE_LIT);
 		node->nd_lit = result;
@@ -4404,7 +4407,7 @@ rb_longjmp(int tag, VALUE mesg)
 	    warn_printf("Exception `%s' at %s:%d - %s\n",
 			rb_obj_classname(ruby_errinfo),
 			ruby_sourcefile, ruby_sourceline,
-			RSTRING(e)->ptr);
+			RSTRING_PTR(e));
 	}
 	POP_TAG();
 	if (status == TAG_FATAL && ruby_errinfo == exception_error) {
@@ -6228,7 +6231,7 @@ rb_backtrace(void)
 
     ary = backtrace(-1);
     for (i=0; i<RARRAY(ary)->len; i++) {
-	printf("\tfrom %s\n", RSTRING(RARRAY(ary)->ptr[i])->ptr);
+	printf("\tfrom %s\n", RSTRING_PTR(RARRAY(ary)->ptr[i]));
     }
 }
 
@@ -6421,7 +6424,7 @@ rb_f_eval(int argc, VALUE *argv, VALUE self)
 	line = NUM2INT(vline);
     }
 
-    if (!NIL_P(vfile)) file = RSTRING(vfile)->ptr;
+    if (!NIL_P(vfile)) file = RSTRING_PTR(vfile);
     if (NIL_P(scope) && ruby_frame->prev) {
 	struct FRAME *prev;
 	VALUE val;
@@ -6750,7 +6753,7 @@ rb_load(VALUE fname, int wrap)
 	ruby_in_eval++;
 	critical = rb_thread_critical;
 	rb_thread_critical = Qtrue;
-	rb_load_file(RSTRING(fname)->ptr);
+	rb_load_file(RSTRING_PTR(fname));
 	ruby_in_eval--;
 	node = ruby_eval_tree;
 	rb_thread_critical = critical;
@@ -6899,7 +6902,7 @@ rb_provided(const char *feature)
 	}
     }
     if (search_required(rb_str_new2(feature), &fname)) {
-	feature = RSTRING(fname)->ptr;
+	feature = RSTRING_PTR(fname);
 	if (rb_feature_p(feature, 0, Qfalse))
 	    return Qtrue;
 	if (loading_tbl && st_lookup(loading_tbl, (st_data_t)feature, 0))
@@ -6970,13 +6973,13 @@ search_required(VALUE fname, VALUE *path)
     int type, ft = 0;
 
     *path = 0;
-    ext = strrchr(ftptr = RSTRING(fname)->ptr, '.');
+    ext = strrchr(ftptr = RSTRING_PTR(fname), '.');
     if (ext && !strchr(ext, '/')) {
 	if (strcmp(".rb", ext) == 0) {
 	    if (rb_feature_p(ftptr, ext, Qtrue)) return 'r';
 	    if (tmp = rb_find_file(fname)) {
 		tmp = rb_file_expand_path(tmp, Qnil);
-		ext = strrchr(ftptr = RSTRING(tmp)->ptr, '.');
+		ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
 		if (!rb_feature_p(ftptr, ext, Qtrue))
 		    *path = tmp;
 		return 'r';
@@ -6985,7 +6988,7 @@ search_required(VALUE fname, VALUE *path)
 	}
 	else if (IS_SOEXT(ext)) {
 	    if (rb_feature_p(ftptr, ext, Qfalse)) return 's';
-	    tmp = rb_str_new(RSTRING(fname)->ptr, ext-RSTRING(fname)->ptr);
+	    tmp = rb_str_new(RSTRING_PTR(fname), ext-RSTRING_PTR(fname));
 #ifdef DLEXT2
 	    OBJ_FREEZE(tmp);
 	    if (rb_find_file_ext(&tmp, loadable_ext+1)) {
@@ -7000,7 +7003,7 @@ search_required(VALUE fname, VALUE *path)
 	    OBJ_FREEZE(tmp);
 	    if (tmp = rb_find_file(tmp)) {
 		tmp = rb_file_expand_path(tmp, Qnil);
-		ext = strrchr(ftptr = RSTRING(tmp)->ptr, '.');
+		ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
 		if (!rb_feature_p(ftptr, ext, Qfalse))
 		    *path = tmp;
 		return 's';
@@ -7011,7 +7014,7 @@ search_required(VALUE fname, VALUE *path)
 	    if (rb_feature_p(ftptr, ext, Qfalse)) return 's';
 	    if (tmp = rb_find_file(fname)) {
 		tmp = rb_file_expand_path(tmp, Qnil);
-		ext = strrchr(ftptr = RSTRING(tmp)->ptr, '.');
+		ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
 		if (!rb_feature_p(ftptr, ext, Qfalse))
 		    *path = tmp;
 		return 's';
@@ -7026,14 +7029,14 @@ search_required(VALUE fname, VALUE *path)
     tmp = rb_file_expand_path(tmp, Qnil);
     switch (type) {
       case 0:
-	ftptr = RSTRING(tmp)->ptr;
+	ftptr = RSTRING_PTR(tmp);
 	if (ft) break;
 	return rb_feature_p(ftptr, 0, Qfalse);
 
       default:
 	if (ft) break;
       case 1:
-	ext = strrchr(ftptr = RSTRING(tmp)->ptr, '.');
+	ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
 	if (rb_feature_p(ftptr, ext, !--type)) break;
 	*path = tmp;
     }
@@ -7043,7 +7046,7 @@ search_required(VALUE fname, VALUE *path)
 static void
 load_failed(VALUE fname)
 {
-    rb_raise(rb_eLoadError, "no such file to load -- %s", RSTRING(fname)->ptr);
+    rb_raise(rb_eLoadError, "no such file to load -- %s", RSTRING_PTR(fname));
 }
 
 VALUE
@@ -7078,7 +7081,7 @@ rb_require_safe(VALUE fname, int safe)
 	*(volatile VALUE *)&fname = rb_str_new4(fname);
 	found = search_required(fname, &path);
 	if (found) {
-	    if (!path || load_wait(RSTRING(path)->ptr)) {
+	    if (!path || load_wait(RSTRING_PTR(path))) {
 		result = Qfalse;
 	    }
 	    else {
@@ -7090,19 +7093,19 @@ rb_require_safe(VALUE fname, int safe)
 			loading_tbl = st_init_strtable();
 		    }
 		    /* partial state */
-		    ftptr = ruby_strdup(RSTRING(path)->ptr);
+		    ftptr = ruby_strdup(RSTRING_PTR(path));
 		    st_insert(loading_tbl, (st_data_t)ftptr, (st_data_t)curr_thread);
 		    rb_load(path, 0);
 		    break;
 
 		  case 's':
 		    ruby_current_node = 0;
-		    ruby_sourcefile = rb_source_filename(RSTRING(path)->ptr);
+		    ruby_sourcefile = rb_source_filename(RSTRING_PTR(path));
 		    ruby_sourceline = 0;
 		    ruby_frame->callee = 0;
 		    ruby_frame->this_func = 0;
 		    VIS_SET(VIS_PUBLIC);
-		    handle = (long)dln_load(RSTRING(path)->ptr);
+		    handle = (long)dln_load(RSTRING_PTR(path));
 		    rb_ary_push(ruby_dln_librefs, LONG2NUM(handle));
 		    break;
 		}
@@ -7975,7 +7978,7 @@ rb_mod_autoload(VALUE mod, VALUE sym, VALUE file)
     ID id = rb_to_id(sym);
 
     Check_SafeStr(file);
-    rb_autoload(mod, id, RSTRING(file)->ptr);
+    rb_autoload(mod, id, RSTRING_PTR(file));
     return Qnil;
 }
 
diff --git a/file.c b/file.c
index 195c9fdc32..9482613b69 100644
--- a/file.c
+++ b/file.c
@@ -743,7 +743,7 @@ rb_file_s_lstat(VALUE klass, VALUE fname)
     rb_secure(2);
     FilePathValue(fname);
     if (lstat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING(fname)->ptr);
+	rb_sys_fail(RSTRING_PTR(fname));
     }
     return stat_new(&st);
 #else
@@ -1545,7 +1545,7 @@ rb_file_s_ftype(VALUE klass, VALUE fname)
     rb_secure(2);
     FilePathValue(fname);
     if (lstat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING(fname)->ptr);
+	rb_sys_fail(RSTRING_PTR(fname));
     }
 
     return rb_file_ftype(&st);
@@ -1611,7 +1611,7 @@ rb_file_s_mtime(VALUE klass, VALUE fname)
     struct stat st;
 
     if (rb_stat(fname, &st) < 0)
-	rb_sys_fail(RSTRING(fname)->ptr);
+	rb_sys_fail(RSTRING_PTR(fname));
     return rb_time_new(st.st_mtime, 0);
 }
 
@@ -1656,7 +1656,7 @@ rb_file_s_ctime(VALUE klass, VALUE fname)
     struct stat st;
 
     if (rb_stat(fname, &st) < 0)
-	rb_sys_fail(RSTRING(fname)->ptr);
+	rb_sys_fail(RSTRING_PTR(fname));
     return rb_time_new(st.st_ctime, 0);
 }
 
@@ -2022,9 +2022,9 @@ sys_fail2(VALUE s1, VALUE s2)
     char *buf;
     int len;
 
-    len = RSTRING(s1)->len + RSTRING(s2)->len + 5;
+    len = RSTRING_LEN(s1) + RSTRING_LEN(s2) + 5;
     buf = ALLOCA_N(char, len);
-    snprintf(buf, len, "(%s, %s)", RSTRING(s1)->ptr, RSTRING(s2)->ptr);
+    snprintf(buf, len, "(%s, %s)", RSTRING_PTR(s1), RSTRING_PTR(s2));
     rb_sys_fail(buf);
 }
 
@@ -2111,7 +2111,7 @@ rb_file_s_readlink(VALUE klass, VALUE path)
     rb_secure(2);
     FilePathValue(path);
     buf = xmalloc(size);
-    while ((rv = readlink(RSTRING(path)->ptr, buf, size)) == size
+    while ((rv = readlink(RSTRING_PTR(path), buf, size)) == size
 #ifdef _AIX
 	    || (rv < 0 && errno == ERANGE) /* quirky behavior of GPFS */
 #endif
@@ -2121,7 +2121,7 @@ rb_file_s_readlink(VALUE klass, VALUE path)
     }
     if (rv < 0) {
 	free(buf);
-	rb_sys_fail(RSTRING(path)->ptr);
+	rb_sys_fail(RSTRING_PTR(path));
     }
     v = rb_tainted_str_new(buf, rv);
     free(buf);
@@ -2390,14 +2390,14 @@ rb_path_end(const char *path)
 	buflen *= 2;\
     }\
     rb_str_resize(result, buflen);\
-    buf = RSTRING(result)->ptr;\
+    buf = RSTRING_PTR(result);\
     p = buf + bdiff;\
     pend = buf + buflen;\
 } while (0)
 
 #define BUFINIT() (\
-    p = buf = RSTRING(result)->ptr,\
-    buflen = RSTRING(result)->len,\
+    p = buf = RSTRING_PTR(result),\
+    buflen = RSTRING_LEN(result),\
     pend = p + buflen)
 
 #if !defined(TOLOWER)
@@ -2601,8 +2601,7 @@ file_expand_path(VALUE fname, VALUE dname, VALUE result)
     if (p == skiproot(buf) - 1) p++;
 
     if (tainted) OBJ_TAINT(result);
-    RSTRING(result)->len = p - buf;
-    *p = '\0';
+    rb_str_set_len(result, p - buf);
     return result;
 }
 
@@ -2692,7 +2691,7 @@ rb_file_s_basename(int argc, VALUE *argv)
 	StringValue(fext);
     }
     StringValue(fname);
-    if (RSTRING(fname)->len == 0 || !*(name = RSTRING(fname)->ptr))
+    if (RSTRING_LEN(fname) == 0 || !*(name = RSTRING_PTR(fname)))
 	return fname;
     name = skipprefix(name);
 #if defined DOSISH_DRIVE_LETTER || defined DOSISH_UNC
@@ -2723,7 +2722,7 @@ rb_file_s_basename(int argc, VALUE *argv)
     else if (!(p = strrdirsep(name))) {
 	if (NIL_P(fext) || !(f = rmext(name, StringValueCStr(fext)))) {
 	    f = chompdirsep(name) - name;
-	    if (f == RSTRING(fname)->len) return fname;
+	    if (f == RSTRING_LEN(fname)) return fname;
 	}
 	p = name;
     }
@@ -2881,7 +2880,7 @@ rb_file_join(VALUE ary, VALUE sep)
     len = 1;
     for (i=0; i<RARRAY(ary)->len; i++) {
 	if (TYPE(RARRAY(ary)->ptr[i]) == T_STRING) {
-	    len += RSTRING(RARRAY(ary)->ptr[i])->len;
+	    len += RSTRING_LEN(RARRAY(ary)->ptr[i]);
 	}
 	else {
 	    len += 10;
@@ -2889,7 +2888,7 @@ rb_file_join(VALUE ary, VALUE sep)
     }
     if (!NIL_P(sep)) {
 	StringValue(sep);
-	len += RSTRING(sep)->len * RARRAY(ary)->len - 1;
+	len += RSTRING_LEN(sep) * RARRAY(ary)->len - 1;
     }
     result = rb_str_buf_new(len);
     OBJ_INFECT(result, ary);
@@ -2913,8 +2912,8 @@ rb_file_join(VALUE ary, VALUE sep)
 	name = StringValueCStr(result);
 	if (i > 0 && !NIL_P(sep)) {
 	    tail = chompdirsep(name);
-	    if (RSTRING(tmp)->ptr && isdirsep(RSTRING(tmp)->ptr[0])) {
-		RSTRING(result)->len = tail - name;
+	    if (RSTRING_PTR(tmp) && isdirsep(RSTRING_PTR(tmp)[0])) {
+		rb_str_set_len(result, tail - name);
 	    }
 	    else if (!*tail) {
 		rb_str_buf_append(result, sep);
@@ -2968,7 +2967,7 @@ rb_file_s_truncate(VALUE klass, VALUE path, VALUE len)
     FilePathValue(path);
 #ifdef HAVE_TRUNCATE
     if (truncate(StringValueCStr(path), pos) < 0)
-	rb_sys_fail(RSTRING(path)->ptr);
+	rb_sys_fail(RSTRING_PTR(path));
 #else
 # ifdef HAVE_CHSIZE
     {
@@ -3334,7 +3333,7 @@ rb_f_test(int argc, VALUE *argv)
 
 	CHECK(1);
 	if (rb_stat(argv[1], &st) == -1) {
-	    rb_sys_fail(RSTRING(argv[1])->ptr);
+	    rb_sys_fail(RSTRING_PTR(argv[1]));
 	}
 
 	switch (cmd) {
@@ -3417,7 +3416,7 @@ rb_stat_init(VALUE obj, VALUE fname)
     rb_secure(2);
     FilePathValue(fname);
     if (stat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING(fname)->ptr);
+	rb_sys_fail(RSTRING_PTR(fname));
     }
     if (DATA_PTR(obj)) {
 	free(DATA_PTR(obj));
@@ -4145,7 +4144,7 @@ int
 rb_find_file_ext(VALUE *filep, const char *const *ext)
 {
     char *path, *found;
-    char *f = RSTRING(*filep)->ptr;
+    char *f = RSTRING_PTR(*filep);
     VALUE fname;
     long i, j;
 
@@ -4179,8 +4178,8 @@ rb_find_file_ext(VALUE *filep, const char *const *ext)
 	VALUE str = RARRAY(rb_load_path)->ptr[i];
 
 	FilePathValue(str);
-	if (RSTRING(str)->len == 0) continue;
-	path = RSTRING(str)->ptr;
+	if (RSTRING_LEN(str) == 0) continue;
+	path = RSTRING_PTR(str);
 	for (j=0; ext[j]; j++) {
 	    fname = rb_str_dup(*filep);
 	    rb_str_cat2(fname, ext[j]);
@@ -4239,16 +4238,16 @@ rb_find_file(VALUE path)
 	for (i=0;i<RARRAY(rb_load_path)->len;i++) {
 	    VALUE str = RARRAY(rb_load_path)->ptr[i];
 	    FilePathValue(str);
-	    if (RSTRING(str)->len > 0) {
+	    if (RSTRING_LEN(str) > 0) {
 		rb_ary_push(tmp, str);
 	    }
 	}
 	tmp = rb_ary_join(tmp, rb_str_new2(PATH_SEP));
-	if (RSTRING(tmp)->len == 0) {
+	if (RSTRING_LEN(tmp) == 0) {
 	    lpath = 0;
 	}
 	else {
-	    lpath = RSTRING(tmp)->ptr;
+	    lpath = RSTRING_PTR(tmp);
 	    if (rb_safe_level() >= 1 && !rb_path_check(lpath)) {
 		rb_raise(rb_eSecurityError, "loading from unsafe path %s", lpath);
 	    }
diff --git a/gc.c b/gc.c
index db16d6c841..9bd44f30cb 100644
--- a/gc.c
+++ b/gc.c
@@ -945,9 +945,10 @@ gc_mark_children(VALUE ptr, int lev)
 	goto again;
 
       case T_STRING:
+#define STR_NOEMBED FL_USER1 /* copied from string.c */
 #define STR_ASSOC FL_USER3   /* copied from string.c */
-	if (FL_TEST(obj, ELTS_SHARED|STR_ASSOC)) {
-	    ptr = obj->as.string.aux.shared;
+	if (FL_TEST(obj, STR_NOEMBED) && FL_ANY(obj, ELTS_SHARED|STR_ASSOC)) {
+	    ptr = obj->as.string.as.heap.aux.shared;
 	    goto again;
 	}
 	break;
@@ -1174,8 +1175,9 @@ obj_free(VALUE obj)
 	}
 	break;
       case T_STRING:
-	if (RANY(obj)->as.string.ptr && !FL_TEST(obj, ELTS_SHARED)) {
-	    RUBY_CRITICAL(free(RANY(obj)->as.string.ptr));
+	if (FL_TEST(obj, STR_NOEMBED) &&
+	    RANY(obj)->as.string.as.heap.ptr && !FL_TEST(obj, ELTS_SHARED)) {
+	    RUBY_CRITICAL(free(RANY(obj)->as.string.as.heap.ptr));
 	}
 	break;
       case T_ARRAY:
diff --git a/hash.c b/hash.c
index 7a3035f6df..6a9ad90eab 100644
--- a/hash.c
+++ b/hash.c
@@ -1117,7 +1117,7 @@ inspect_i(VALUE key, VALUE value, VALUE str)
     VALUE str2;
 
     if (key == Qundef) return ST_CONTINUE;
-    if (RSTRING(str)->len > 1) {
+    if (RSTRING_LEN(str) > 1) {
 	rb_str_cat2(str, ", ");
     }
     str2 = rb_inspect(key);
@@ -1540,8 +1540,8 @@ env_delete(VALUE obj, VALUE name)
 
     rb_secure(4);
     SafeStringValue(name);
-    nam = RSTRING(name)->ptr;
-    if (strlen(nam) != RSTRING(name)->len) {
+    nam = RSTRING_PTR(name);
+    if (strlen(nam) != RSTRING_LEN(name)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     val = getenv(nam);
@@ -1579,8 +1579,8 @@ rb_f_getenv(VALUE obj, VALUE name)
 
     rb_secure(4);
     SafeStringValue(name);
-    nam = RSTRING(name)->ptr;
-    if (strlen(nam) != RSTRING(name)->len) {
+    nam = RSTRING_PTR(name);
+    if (strlen(nam) != RSTRING_LEN(name)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     env = getenv(nam);
@@ -1615,8 +1615,8 @@ env_fetch(int argc, VALUE *argv)
 	rb_warn("block supersedes default value argument");
     }
     SafeStringValue(key);
-    nam = RSTRING(key)->ptr;
-    if (strlen(nam) != RSTRING(key)->len) {
+    nam = RSTRING_PTR(key);
+    if (strlen(nam) != RSTRING_LEN(key)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     env = getenv(nam);
@@ -1774,11 +1774,11 @@ env_aset(VALUE obj, VALUE nm, VALUE val)
     }
     StringValue(nm);
     StringValue(val);
-    name = RSTRING(nm)->ptr;
-    value = RSTRING(val)->ptr;
-    if (strlen(name) != RSTRING(nm)->len)
+    name = RSTRING_PTR(nm);
+    value = RSTRING_PTR(val);
+    if (strlen(name) != RSTRING_LEN(nm))
 	rb_raise(rb_eArgError, "bad environment variable name");
-    if (strlen(value) != RSTRING(val)->len)
+    if (strlen(value) != RSTRING_LEN(val))
 	rb_raise(rb_eArgError, "bad environment variable value");
 
     ruby_setenv(name, value);
@@ -2101,7 +2101,7 @@ env_has_key(VALUE env, VALUE key)
 
     rb_secure(4);
     s = StringValuePtr(key);
-    if (strlen(s) != RSTRING(key)->len)
+    if (strlen(s) != RSTRING_LEN(key))
 	rb_raise(rb_eArgError, "bad environment variable name");
     if (getenv(s)) return Qtrue;
     return Qfalse;
@@ -2119,7 +2119,7 @@ env_has_value(VALUE dmy, VALUE value)
 	char *s = strchr(*env, '=');
 	if (s++) {
 	    long len = strlen(s);
-	    if (RSTRING(value)->len == len && strncmp(s, RSTRING(value)->ptr, len) == 0) {
+	    if (RSTRING_LEN(value) == len && strncmp(s, RSTRING_PTR(value), len) == 0) {
 		FREE_ENVIRON(environ);
 		return Qtrue;
 	    }
@@ -2143,7 +2143,7 @@ env_key(VALUE dmy, VALUE value)
 	char *s = strchr(*env, '=');
 	if (s++) {
 	    long len = strlen(s);
-	    if (RSTRING(value)->len == len && strncmp(s, RSTRING(value)->ptr, len) == 0) {
+	    if (RSTRING_LEN(value) == len && strncmp(s, RSTRING_PTR(value), len) == 0) {
 		str = env_str_new(*env, s-*env-1);
 		FREE_ENVIRON(environ);
 		return str;
@@ -2200,7 +2200,7 @@ env_shift(void)
 	char *s = strchr(*env, '=');
 	if (s) {
 	    VALUE key = env_str_new(*env, s-*env);
-	    VALUE val = env_str_new2(getenv(RSTRING(key)->ptr));
+	    VALUE val = env_str_new2(getenv(RSTRING_PTR(key)));
 	    env_delete(Qnil, key);
 	    return rb_assoc_new(key, val);
 	}
diff --git a/io.c b/io.c
index b265444135..9f90104f80 100644
--- a/io.c
+++ b/io.c
@@ -543,7 +543,7 @@ io_fwrite(VALUE str, OpenFile *fptr)
 {
     long len, n, r, l, offset = 0;
 
-    len = RSTRING(str)->len;
+    len = RSTRING_LEN(str);
     if ((n = len) <= 0) return n;
     if (fptr->wbuf == NULL && !(fptr->mode & FMODE_SYNC)) {
         fptr->wbuf_off = 0;
@@ -553,14 +553,14 @@ io_fwrite(VALUE str, OpenFile *fptr)
     }
     if ((fptr->mode & FMODE_SYNC) ||
         (fptr->wbuf && fptr->wbuf_capa <= fptr->wbuf_len + len) ||
-        ((fptr->mode & FMODE_TTY) && memchr(RSTRING(str)->ptr+offset, '\n', len))) {
+        ((fptr->mode & FMODE_TTY) && memchr(RSTRING_PTR(str)+offset, '\n', len))) {
         /* xxx: use writev to avoid double write if available */
         if (fptr->wbuf_len && fptr->wbuf_len+len <= fptr->wbuf_capa) {
             if (fptr->wbuf_capa < fptr->wbuf_off+fptr->wbuf_len+len) {
                 MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len);
                 fptr->wbuf_off = 0;
             }
-            MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING(str)->ptr+offset, char, len);
+            MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len);
             fptr->wbuf_len += len;
             n = 0;
         }
@@ -582,7 +582,7 @@ io_fwrite(VALUE str, OpenFile *fptr)
             l = PIPE_BUF;
         }
         TRAP_BEG;
-	r = write(fptr->fd, RSTRING(str)->ptr+offset, l);
+	r = write(fptr->fd, RSTRING_PTR(str)+offset, l);
         TRAP_END; /* xxx: signal handler may modify given string. */
         if (r == n) return len;
         if (0 <= r) {
@@ -592,7 +592,7 @@ io_fwrite(VALUE str, OpenFile *fptr)
         }
         if (rb_io_wait_writable(fptr->fd)) {
             rb_io_check_closed(fptr);
-	    if (offset < RSTRING(str)->len)
+	    if (offset < RSTRING_LEN(str))
 		goto retry;
         }
         return -1L;
@@ -603,7 +603,7 @@ io_fwrite(VALUE str, OpenFile *fptr)
             MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len);
         fptr->wbuf_off = 0;
     }
-    MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING(str)->ptr+offset, char, len);
+    MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len);
     fptr->wbuf_len += len;
     return len;
 }
@@ -653,7 +653,7 @@ io_write(VALUE io, VALUE str)
 	return rb_funcall(io, id_write, 1, str);
     }
     io = tmp;
-    if (RSTRING(str)->len == 0) return INT2FIX(0);
+    if (RSTRING_LEN(str) == 0) return INT2FIX(0);
 
     GetOpenFile(io, fptr);
     rb_io_check_writable(fptr);
@@ -1138,12 +1138,12 @@ read_buffered_data(char *ptr, long len, OpenFile *fptr)
 static long
 io_fread(VALUE str, long offset, OpenFile *fptr)
 {
-    long len = RSTRING(str)->len - offset;
+    long len = RSTRING_LEN(str) - offset;
     long n = len;
     int c;
 
     while (n > 0) {
-	c = read_buffered_data(RSTRING(str)->ptr+offset, n, fptr);
+	c = read_buffered_data(RSTRING_PTR(str)+offset, n, fptr);
 	if (c > 0) {
 	    offset += c;
 	    if ((n -= c) <= 0) break;
@@ -1154,8 +1154,8 @@ io_fread(VALUE str, long offset, OpenFile *fptr)
 	if (c < 0) {
 	    break;
 	}
-	RSTRING(str)->ptr[offset++] = c;
-	if (offset > RSTRING(str)->len) break;
+	RSTRING_PTR(str)[offset++] = c;
+	if (offset > RSTRING_LEN(str)) break;
 	n--;
     }
     return len - n;
@@ -1173,7 +1173,7 @@ rb_io_fread(char *ptr, long len, FILE *f)
     of.mode = FMODE_READABLE;
     str = rb_str_new(ptr, len);
     n = io_fread(str, 0, &of);
-    MEMCPY(ptr, RSTRING(str)->ptr, char, n);
+    MEMCPY(ptr, RSTRING_PTR(str), char, n);
     return n;
 }
 
@@ -1287,21 +1287,21 @@ io_getpartial(int argc, VALUE *argv, VALUE io, int nonblock)
 
     if (!nonblock)
         READ_CHECK(fptr);
-    if (RSTRING(str)->len != len) {
+    if (RSTRING_LEN(str) != len) {
       modified:
 	rb_raise(rb_eRuntimeError, "buffer string modified");
     }
-    n = read_buffered_data(RSTRING(str)->ptr, len, fptr);
+    n = read_buffered_data(RSTRING_PTR(str), len, fptr);
     if (n <= 0) {
       again:
-	if (RSTRING(str)->len != len) goto modified;
+	if (RSTRING_LEN(str) != len) goto modified;
         if (nonblock) {
             rb_io_set_nonblock(fptr);
-            n = read(fptr->fd, RSTRING(str)->ptr, len);
+            n = read(fptr->fd, RSTRING_PTR(str), len);
         }
         else {
             TRAP_BEG;
-            n = read(fptr->fd, RSTRING(str)->ptr, len);
+            n = read(fptr->fd, RSTRING_PTR(str), len);
             TRAP_END;
         }
         if (n < 0) {
@@ -1456,7 +1456,7 @@ rb_io_write_nonblock(VALUE io, VALUE str)
     io_fflush(fptr);
 
     rb_io_set_nonblock(fptr);
-    n = write(fptr->fd, RSTRING(str)->ptr, RSTRING(str)->len);
+    n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str));
 
     if (n == -1) rb_sys_fail(fptr->path);
 
@@ -1519,7 +1519,7 @@ io_read(int argc, VALUE *argv, VALUE io)
     if (len == 0) return str;
 
     READ_CHECK(fptr);
-    if (RSTRING(str)->len != len) {
+    if (RSTRING_LEN(str) != len) {
 	rb_raise(rb_eRuntimeError, "buffer string modified");
     }
     n = io_fread(str, 0, fptr);
@@ -1529,8 +1529,6 @@ io_read(int argc, VALUE *argv, VALUE io)
         return Qnil;
     }
     rb_str_resize(str, n);
-    RSTRING(str)->len = n;
-    RSTRING(str)->ptr[n] = '\0';
     OBJ_TAINT(str);
 
     return str;
@@ -1551,18 +1549,17 @@ appendline(OpenFile *fptr, int delim, VALUE *strp)
 	    if (e) pending = e - p + 1;
 	    len += pending;
 	    if (!NIL_P(str)) {
-		last = RSTRING(str)->len;
+		last = RSTRING_LEN(str);
 		rb_str_resize(str, last + len);
 	    }
 	    else {
 		*strp = str = rb_str_buf_new(len);
-		RSTRING(str)->len = len;
-		RSTRING(str)->ptr[len] = '\0';
+		rb_str_set_len(str, len);
 	    }
 	    if (c != EOF) {
-		RSTRING(str)->ptr[last++] = c;
+		RSTRING_PTR(str)[last++] = c;
 	    }
-	    read_buffered_data(RSTRING(str)->ptr + last, pending, fptr); /* must not fail */
+	    read_buffered_data(RSTRING_PTR(str) + last, pending, fptr); /* must not fail */
 	    if (e) return delim;
 	}
 	else if (c != EOF) {
@@ -1572,7 +1569,8 @@ appendline(OpenFile *fptr, int delim, VALUE *strp)
 	    }
 	    else {
 		*strp = str = rb_str_buf_new(1);
-		RSTRING(str)->ptr[RSTRING(str)->len++] = c;
+		rb_str_resize(str, 1);
+		RSTRING_PTR(str)[0] = c;
 	    }
 	}
 	rb_thread_wait_fd(fptr->fd);
@@ -1645,7 +1643,7 @@ rb_io_getline_fast(OpenFile *fptr, unsigned char delim)
 static int
 rscheck(const char *rsptr, long rslen, VALUE rs)
 {
-    if (RSTRING(rs)->ptr != rsptr && RSTRING(rs)->len != rslen)
+    if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
 	rb_raise(rb_eRuntimeError, "rs modified");
     return 0;
 }
@@ -1660,7 +1658,7 @@ rb_io_getline(VALUE rs, VALUE io)
     rb_io_check_readable(fptr);
     if (NIL_P(rs)) {
 	str = read_all(fptr, 0, Qnil);
-	if (RSTRING(str)->len == 0) return Qnil;
+	if (RSTRING_LEN(str) == 0) return Qnil;
     }
     else if (rs == rb_default_rs) {
 	return rb_io_getline_fast(fptr, '\n');
@@ -1671,7 +1669,7 @@ rb_io_getline(VALUE rs, VALUE io)
 	long rslen;
 	int rspara = 0;
 
-	rslen = RSTRING(rs)->len;
+	rslen = RSTRING_LEN(rs);
 	if (rslen == 0) {
 	    rsptr = "\n\n";
 	    rslen = 2;
@@ -1679,18 +1677,18 @@ rb_io_getline(VALUE rs, VALUE io)
 	    swallow(fptr, '\n');
 	}
 	else if (rslen == 1) {
-	    return rb_io_getline_fast(fptr, (unsigned char)RSTRING(rs)->ptr[0]);
+	    return rb_io_getline_fast(fptr, (unsigned char)RSTRING_PTR(rs)[0]);
 	}
 	else {
-	    rsptr = RSTRING(rs)->ptr;
+	    rsptr = RSTRING_PTR(rs);
 	}
 	newline = rsptr[rslen - 1];
 
 	while ((c = appendline(fptr, newline, &str)) != EOF) {
 	    if (c == newline) {
-		if (RSTRING(str)->len < rslen) continue;
+		if (RSTRING_LEN(str) < rslen) continue;
 		if (!rspara) rscheck(rsptr, rslen, rs);
-		if (memcmp(RSTRING(str)->ptr + RSTRING(str)->len - rslen,
+		if (memcmp(RSTRING_PTR(str) + RSTRING_LEN(str) - rslen,
 			   rsptr, rslen) == 0) break;
 	    }
 	}
@@ -2077,10 +2075,10 @@ rb_io_ungetc(VALUE io, VALUE c)
     }
     else {
 	SafeStringValue(c);
-	if (RSTRING(c)->len > 1) {
+	if (RSTRING_LEN(c) > 1) {
 	    rb_warn("IO#ungetc pushes back only one byte");
 	}
-	cc = (unsigned char)RSTRING(c)->ptr[0];
+	cc = (unsigned char)RSTRING_PTR(c)[0];
     }
     if (io_ungetc(cc, fptr) == EOF && cc != EOF) {
 	rb_raise(rb_eIOError, "ungetc failed");
@@ -2427,7 +2425,7 @@ rb_io_syswrite(VALUE io, VALUE str)
         rb_io_check_closed(fptr);
     }
     TRAP_BEG;
-    n = write(fptr->fd, RSTRING(str)->ptr, RSTRING(str)->len);
+    n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str));
     TRAP_END;
 
     if (n == -1) rb_sys_fail(fptr->path);
@@ -2481,22 +2479,21 @@ rb_io_sysread(int argc, VALUE *argv, VALUE io)
     n = fptr->fd;
     rb_thread_wait_fd(fptr->fd);
     rb_io_check_closed(fptr);
-    if (RSTRING(str)->len != ilen) {
+    if (RSTRING_LEN(str) != ilen) {
 	rb_raise(rb_eRuntimeError, "buffer string modified");
     }
     TRAP_BEG;
-    n = read(fptr->fd, RSTRING(str)->ptr, ilen);
+    n = read(fptr->fd, RSTRING_PTR(str), ilen);
     TRAP_END;
 
     if (n == -1) {
 	rb_sys_fail(fptr->path);
     }
-    rb_str_resize(str, n);
+    rb_str_set_len(str, n);
     if (n == 0 && ilen > 0) {
 	rb_eof_error();
     }
-    RSTRING(str)->len = n;
-    RSTRING(str)->ptr[n] = '\0';
+    rb_str_resize(str, n);
     OBJ_TAINT(str);
 
     return str;
@@ -3209,15 +3206,15 @@ rb_open_file(int argc, VALUE *argv, VALUE io)
 	}
 	else {
 	    SafeStringValue(vmode);
-	    flags = rb_io_mode_modenum(RSTRING(vmode)->ptr);
+	    flags = rb_io_mode_modenum(RSTRING_PTR(vmode));
 	}
 	fmode = NIL_P(perm) ? 0666 :  NUM2INT(perm);
 
-	rb_file_sysopen_internal(io, RSTRING(fname)->ptr, flags, fmode);
+	rb_file_sysopen_internal(io, RSTRING_PTR(fname), flags, fmode);
     }
     else {
 	mode = NIL_P(vmode) ? "r" : StringValuePtr(vmode);
-	rb_file_open_internal(io, RSTRING(fname)->ptr, mode);
+	rb_file_open_internal(io, RSTRING_PTR(fname), mode);
     }
     return io;
 }
@@ -3272,13 +3269,13 @@ rb_io_s_sysopen(int argc, VALUE *argv)
     else if (FIXNUM_P(vmode)) flags = FIX2INT(vmode);
     else {
 	SafeStringValue(vmode);
-	flags = rb_io_mode_modenum(RSTRING(vmode)->ptr);
+	flags = rb_io_mode_modenum(RSTRING_PTR(vmode));
     }
     if (NIL_P(perm)) fmode = 0666;
     else             fmode = NUM2INT(perm);
 
-    path = ALLOCA_N(char, strlen(RSTRING(fname)->ptr)+1);
-    strcpy(path, RSTRING(fname)->ptr);
+    path = ALLOCA_N(char, strlen(RSTRING_PTR(fname))+1);
+    strcpy(path, RSTRING_PTR(fname));
     fd = rb_sysopen(path, flags, fmode);
     return INT2NUM(fd);
 }
@@ -3384,7 +3381,7 @@ rb_f_open(int argc, VALUE *argv)
 	    if (!NIL_P(tmp)) {
 		char *str = StringValuePtr(tmp);
 		if (str && str[0] == '|') {
-		    argv[0] = rb_str_new(str+1, RSTRING(tmp)->len-1);
+		    argv[0] = rb_str_new(str+1, RSTRING_LEN(tmp)-1);
 		    OBJ_INFECT(argv[0], tmp);
 		    return rb_io_s_popen(argc, argv, rb_cIO);
 		}
@@ -3550,7 +3547,7 @@ rb_io_reopen(int argc, VALUE *argv, VALUE file)
 	fptr->path = 0;
     }
 
-    fptr->path = strdup(RSTRING(fname)->ptr);
+    fptr->path = strdup(RSTRING_PTR(fname));
     mode = rb_io_flags_mode(fptr->mode);
     if (fptr->fd < 0) {
         fptr->fd = rb_sysopen(fptr->path, rb_io_mode_modenum(mode), 0666);
@@ -3563,7 +3560,7 @@ rb_io_reopen(int argc, VALUE *argv, VALUE file)
     }
 
     if (fptr->stdio_file) {
-        if (freopen(RSTRING(fname)->ptr, mode, fptr->stdio_file) == 0) {
+        if (freopen(RSTRING_PTR(fname), mode, fptr->stdio_file) == 0) {
             rb_sys_fail(fptr->path);
         }
         fptr->fd = fileno(fptr->stdio_file);
@@ -3829,20 +3826,15 @@ rb_io_puts(int argc, VALUE *argv, VALUE out)
 	return Qnil;
     }
     for (i=0; i<argc; i++) {
-	if (NIL_P(argv[i])) {
-	    line = rb_str_new2("nil");
-	}
-	else {
-	    line = rb_check_array_type(argv[i]);
-	    if (!NIL_P(line)) {
-		rb_exec_recursive(io_puts_ary, line, out);
-		continue;
-	    }
-	    line = rb_obj_as_string(argv[i]);
+	line = rb_check_array_type(argv[i]);
+	if (!NIL_P(line)) {
+	    rb_exec_recursive(io_puts_ary, line, out);
+	    continue;
 	}
+	line = rb_obj_as_string(argv[i]);
 	rb_io_write(out, line);
-	if (RSTRING(line)->len == 0 ||
-            RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n') {
+	if (RSTRING_LEN(line) == 0 ||
+            RSTRING_PTR(line)[RSTRING_LEN(line)-1] != '\n') {
 	    rb_io_write(out, rb_default_rs);
 	}
     }
@@ -4066,7 +4058,7 @@ rb_io_initialize(int argc, VALUE *argv, VALUE io)
 	}
 	else {
 	    SafeStringValue(mode);
-	    flags = rb_io_mode_modenum(RSTRING(mode)->ptr);
+	    flags = rb_io_mode_modenum(RSTRING_PTR(mode));
 	}
     }
     orig = rb_io_check_io(fnum);
@@ -4101,7 +4093,7 @@ rb_io_initialize(int argc, VALUE *argv, VALUE io)
 		    rb_raise(rb_eArgError, "incompatible mode 0%o", flags);
 		}
 		else {
-		    rb_raise(rb_eArgError, "incompatible mode \"%s\"", RSTRING(mode)->ptr);
+		    rb_raise(rb_eArgError, "incompatible mode \"%s\"", RSTRING_PTR(mode));
 		}
 	    }
 	}
@@ -4285,13 +4277,13 @@ next_argv(void)
 #endif
 #ifdef NO_SAFE_RENAME
 			(void)close(fr);
-			(void)unlink(RSTRING(str)->ptr);
-			(void)rename(fn, RSTRING(str)->ptr);
-			fr = rb_sysopen(RSTRING(str)->ptr, O_RDONLY, 0);
+			(void)unlink(RSTRING_PTR(str));
+			(void)rename(fn, RSTRING_PTR(str));
+			fr = rb_sysopen(RSTRING_PTR(str), O_RDONLY, 0);
 #else
-			if (rename(fn, RSTRING(str)->ptr) < 0) {
+			if (rename(fn, RSTRING_PTR(str)) < 0) {
 			    rb_warn("Can't rename %s to %s: %s, skipping file",
-				    fn, RSTRING(str)->ptr, strerror(errno));
+				    fn, RSTRING_PTR(str), strerror(errno));
 			    close(fr);
 			    goto retry;
 			}
@@ -4782,20 +4774,20 @@ rb_io_ctl(VALUE io, VALUE req, VALUE arg, int io_p)
 #endif
 	    rb_str_modify(arg);
 
-	    if (len <= RSTRING(arg)->len) {
-		len = RSTRING(arg)->len;
+	    if (len <= RSTRING_LEN(arg)) {
+		len = RSTRING_LEN(arg);
 	    }
-	    if (RSTRING(arg)->len < len) {
+	    if (RSTRING_LEN(arg) < len) {
 		rb_str_resize(arg, len+1);
 	    }
-	    RSTRING(arg)->ptr[len] = 17;	/* a little sanity check here */
-	    narg = (long)RSTRING(arg)->ptr;
+	    RSTRING_PTR(arg)[len] = 17;	/* a little sanity check here */
+	    narg = (long)RSTRING_PTR(arg);
 	}
     }
     GetOpenFile(io, fptr);
     retval = io_cntl(fptr->fd, cmd, narg, io_p);
     if (retval < 0) rb_sys_fail(fptr->path);
-    if (TYPE(arg) == T_STRING && RSTRING(arg)->ptr[len] != 17) {
+    if (TYPE(arg) == T_STRING && RSTRING_PTR(arg)[len] != 17) {
 	rb_raise(rb_eArgError, "return value overflowed string");
     }
 
@@ -4912,7 +4904,7 @@ rb_f_syscall(int argc, VALUE *argv)
 	if (!NIL_P(v)) {
 	    StringValue(v);
 	    rb_str_modify(v);
-	    arg[i] = (unsigned long)RSTRING(v)->ptr;
+	    arg[i] = (unsigned long)RSTRING_PTR(v);
 	}
 	else {
 	    arg[i] = (unsigned long)NUM2LONG(*argv);
@@ -5110,7 +5102,7 @@ rb_io_s_foreach(int argc, VALUE *argv, VALUE self)
     else if (!NIL_P(arg.sep)) {
 	StringValue(arg.sep);
     }
-    arg.io = rb_io_open(RSTRING(fname)->ptr, "r");
+    arg.io = rb_io_open(RSTRING_PTR(fname), "r");
     if (NIL_P(arg.io)) return Qnil;
 
     return rb_ensure(io_s_foreach, (VALUE)&arg, rb_io_close, arg.io);
@@ -5144,7 +5136,7 @@ rb_io_s_readlines(int argc, VALUE *argv, VALUE io)
     rb_scan_args(argc, argv, "11", &fname, &arg.sep);
     FilePathValue(fname);
     arg.argc = argc - 1;
-    arg.io = rb_io_open(RSTRING(fname)->ptr, "r");
+    arg.io = rb_io_open(RSTRING_PTR(fname), "r");
     if (NIL_P(arg.io)) return Qnil;
     return rb_ensure(io_s_readlines, (VALUE)&arg, rb_io_close, arg.io);
 }
@@ -5177,7 +5169,7 @@ rb_io_s_read(int argc, VALUE *argv, VALUE io)
     rb_scan_args(argc, argv, "12", &fname, &arg.sep, &offset);
     FilePathValue(fname);
     arg.argc = argc ? 1 : 0;
-    arg.io = rb_io_open(RSTRING(fname)->ptr, "r");
+    arg.io = rb_io_open(RSTRING_PTR(fname), "r");
     if (NIL_P(arg.io)) return Qnil;
     if (!NIL_P(offset)) {
 	rb_io_seek(arg.io, offset, SEEK_SET);
@@ -5292,8 +5284,8 @@ argf_read(int argc, VALUE *argv)
 	}
     }
     else if (argc >= 1) {
-	if (RSTRING(str)->len < len) {
-	    len -= RSTRING(str)->len;
+	if (RSTRING_LEN(str) < len) {
+	    len -= RSTRING_LEN(str);
 	    argv[0] = INT2NUM(len);
 	    goto retry;
 	}
@@ -5490,7 +5482,7 @@ opt_i_set(VALUE val)
     StringValue(val);
     if (ruby_inplace_mode) free(ruby_inplace_mode);
     ruby_inplace_mode = 0;
-    ruby_inplace_mode = strdup(RSTRING(val)->ptr);
+    ruby_inplace_mode = strdup(RSTRING_PTR(val));
 }
 
 /*
diff --git a/marshal.c b/marshal.c
index aa6a5943d8..2e69af00ed 100644
--- a/marshal.c
+++ b/marshal.c
@@ -100,7 +100,7 @@ static VALUE
 class2path(VALUE klass)
 {
     VALUE path = rb_class_path(klass);
-    char *n = RSTRING(path)->ptr;
+    char *n = RSTRING_PTR(path);
 
     if (n[0] == '#') {
 	rb_raise(rb_eTypeError, "can't dump anonymous %s %s",
@@ -120,7 +120,7 @@ w_nbyte(const char *s, int n, struct dump_arg *arg)
 {
     VALUE buf = arg->str;
     rb_str_buf_cat(buf, s, n);
-    if (arg->dest && RSTRING(buf)->len >= BUFSIZ) {
+    if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) {
 	if (arg->taint) OBJ_TAINT(buf);
 	rb_io_write(arg->dest, buf);
 	rb_str_resize(buf, 0);
@@ -365,7 +365,7 @@ w_class(char type, VALUE obj, struct dump_arg *arg, int check)
     VALUE klass = CLASS_OF(obj);
     w_extended(klass, arg, check);
     w_byte(type, arg);
-    path = RSTRING(class2path(rb_class_real(klass)))->ptr;
+    path = RSTRING_PTR(class2path(rb_class_real(klass)));
     w_unique(path, arg);
 }
 
@@ -378,7 +378,7 @@ w_uclass(VALUE obj, VALUE base_klass, struct dump_arg *arg)
     klass = rb_class_real(klass);
     if (klass != base_klass) {
 	w_byte(TYPE_UCLASS, arg);
-	w_unique(RSTRING(class2path(klass))->ptr, arg);
+	w_unique(RSTRING_PTR(class2path(klass)), arg);
     }
 }
 
@@ -476,7 +476,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
 		w_byte(TYPE_IVAR, arg);
 	    }
 	    w_class(TYPE_USERDEF, obj, arg, Qfalse);
-	    w_bytes(RSTRING(v)->ptr, RSTRING(v)->len, arg);
+	    w_bytes(RSTRING_PTR(v), RSTRING_LEN(v), arg);
 	    if (ivtbl) {
 		w_ivar(ivtbl, &c_arg);
 	    }
@@ -491,7 +491,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
 	    w_byte(TYPE_CLASS, arg);
 	    {
 		VALUE path = class2path(obj);
-		w_bytes(RSTRING(path)->ptr, RSTRING(path)->len, arg);
+		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
 	    }
 	    break;
 
@@ -499,7 +499,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
 	    w_byte(TYPE_MODULE, arg);
 	    {
 		VALUE path = class2path(obj);
-		w_bytes(RSTRING(path)->ptr, RSTRING(path)->len, arg);
+		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
 	    }
 	    break;
 
@@ -538,7 +538,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
 	  case T_STRING:
 	    w_uclass(obj, rb_cString, arg);
 	    w_byte(TYPE_STRING, arg);
-	    w_bytes(RSTRING(obj)->ptr, RSTRING(obj)->len, arg);
+	    w_bytes(RSTRING_PTR(obj), RSTRING_LEN(obj), arg);
 	    break;
 
 	  case T_REGEXP:
@@ -746,8 +746,8 @@ r_byte(struct load_arg *arg)
     int c;
 
     if (TYPE(arg->src) == T_STRING) {
-	if (RSTRING(arg->src)->len > arg->offset) {
-	    c = (unsigned char)RSTRING(arg->src)->ptr[arg->offset++];
+	if (RSTRING_LEN(arg->src) > arg->offset) {
+	    c = (unsigned char)RSTRING_PTR(arg->src)[arg->offset++];
 	}
 	else {
 	    rb_raise(rb_eArgError, "marshal data too short");
@@ -819,8 +819,8 @@ r_bytes0(long len, struct load_arg *arg)
 
     if (len == 0) return rb_str_new(0, 0);
     if (TYPE(arg->src) == T_STRING) {
-	if (RSTRING(arg->src)->len > arg->offset) {
-	    str = rb_str_new(RSTRING(arg->src)->ptr+arg->offset, len);
+	if (RSTRING_LEN(arg->src) > arg->offset) {
+	    str = rb_str_new(RSTRING_PTR(arg->src)+arg->offset, len);
 	    arg->offset += len;
 	}
 	else {
@@ -834,7 +834,7 @@ r_bytes0(long len, struct load_arg *arg)
 	str = rb_funcall2(src, s_read, 1, &n);
 	if (NIL_P(str)) goto too_short;
 	StringValue(str);
-	if (RSTRING(str)->len != len) goto too_short;
+	if (RSTRING_LEN(str) != len) goto too_short;
 	if (OBJ_TAINTED(str)) arg->taint = Qtrue;
     }
     return str;
@@ -856,8 +856,9 @@ static ID
 r_symreal(struct load_arg *arg)
 {
     ID id;
+    volatile VALUE s = r_bytes(arg);
 
-    id = rb_intern(RSTRING(r_bytes(arg))->ptr);
+    id = rb_intern(RSTRING_PTR(s));
     st_insert(arg->symbols, arg->symbols->num_entries, id);
 
     return id;
@@ -1013,7 +1014,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
 	{
 	    double d, t = 0.0;
 	    VALUE str = r_bytes(arg);
-	    const char *ptr = RSTRING(str)->ptr;
+	    const char *ptr = RSTRING_PTR(str);
 
 	    if (strcmp(ptr, "nan") == 0) {
 		d = t / t;
@@ -1027,7 +1028,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
 	    else {
 		char *e;
 		d = strtod(ptr, &e);
-		d = load_mantissa(d, e, RSTRING(str)->len - (e - ptr));
+		d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr));
 	    }
 	    v = rb_float_new(d);
 	    r_entry(v, arg);
@@ -1051,7 +1052,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
 	    big->len = (len + 1) * 2 / sizeof(BDIGIT);
 #endif
 	    big->digits = digits = ALLOC_N(BDIGIT, big->len);
-	    MEMCPY(digits, RSTRING(data)->ptr, char, len * 2);
+	    MEMCPY(digits, RSTRING_PTR(data), char, len * 2);
 #if SIZEOF_BDIGITS > SIZEOF_SHORT
 	    MEMZERO((char *)digits + len * 2, char,
 		    big->len * sizeof(BDIGIT) - len * 2);
@@ -1087,7 +1088,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
 	{
 	    volatile VALUE str = r_bytes(arg);
 	    int options = r_byte(arg);
-	    v = r_entry(rb_reg_new(RSTRING(str)->ptr, RSTRING(str)->len, options), arg);
+	    v = r_entry(rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str), options), arg);
 	}
 	break;
 
@@ -1240,7 +1241,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = rb_path2class(RSTRING(str)->ptr);
+	    v = rb_path2class(RSTRING_PTR(str));
 	    r_entry(v, arg);
 	}
 	break;
@@ -1249,7 +1250,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = path2class(RSTRING(str)->ptr);
+	    v = path2class(RSTRING_PTR(str));
 	    r_entry(v, arg);
 	}
 	break;
@@ -1258,7 +1259,7 @@ r_object0(struct load_arg *arg, VALUE proc, int *ivp, VALUE extmod)
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = path2module(RSTRING(str)->ptr);
+	    v = path2module(RSTRING_PTR(str));
 	    r_entry(v, arg);
 	}
 	break;
diff --git a/numeric.c b/numeric.c
index 255b6b52b4..a330cf0905 100644
--- a/numeric.c
+++ b/numeric.c
@@ -117,7 +117,7 @@ coerce_rescue(VALUE *x)
 
     rb_raise(rb_eTypeError, "%s can't be coerced into %s",
 	     rb_special_const_p(x[1])?
-	     RSTRING(v)->ptr:
+	     RSTRING_PTR(v):
 	     rb_obj_classname(x[1]),
 	     rb_obj_classname(x[0]));
     return Qnil;		/* dummy */
diff --git a/object.c b/object.c
index a396da0913..d04cf0b4d8 100644
--- a/object.c
+++ b/object.c
@@ -272,8 +272,8 @@ inspect_i(ID id, VALUE value, VALUE str)
     /* need not to show internal data */
     if (CLASS_OF(value) == 0) return ST_CONTINUE;
     if (!rb_is_instance_id(id)) return ST_CONTINUE;
-    if (RSTRING(str)->ptr[0] == '-') { /* first element */
-	RSTRING(str)->ptr[0] = '#';
+    if (RSTRING_PTR(str)[0] == '-') { /* first element */
+	RSTRING_PTR(str)[0] = '#';
 	rb_str_cat2(str, " ");
     }
     else {
@@ -299,7 +299,7 @@ inspect_obj(VALUE obj, VALUE str, int recur)
 	st_foreach_safe(ROBJECT(obj)->iv_tbl, inspect_i, str);
     }
     rb_str_cat2(str, ">");
-    RSTRING(str)->ptr[0] = '#';
+    RSTRING_PTR(str)[0] = '#';
     OBJ_INFECT(str, obj);
 
     return str;
@@ -1009,11 +1009,11 @@ sym_inspect(VALUE sym)
 
     name = rb_id2name(id);
     str = rb_str_new(0, strlen(name)+1);
-    RSTRING(str)->ptr[0] = ':';
-    strcpy(RSTRING(str)->ptr+1, name);
+    RSTRING_PTR(str)[0] = ':';
+    strcpy(RSTRING_PTR(str)+1, name);
     if (!rb_symname_p(name)) {
 	str = rb_str_dump(str);
-	strncpy(RSTRING(str)->ptr, ":\"", 2);
+	strncpy(RSTRING_PTR(str), ":\"", 2);
     }
     return str;
 }
@@ -1476,13 +1476,13 @@ rb_class_superclass(VALUE klass)
 static ID
 str_to_id(VALUE str)
 {
-    if (!RSTRING(str)->ptr || RSTRING(str)->len == 0) {
+    if (!RSTRING_PTR(str) || RSTRING_LEN(str) == 0) {
 	rb_raise(rb_eArgError, "empty symbol string");
     }
-    if (RSTRING(str)->len != strlen(RSTRING(str)->ptr)) {
+    if (RSTRING_LEN(str) != strlen(RSTRING_PTR(str))) {
 	rb_raise(rb_eArgError, "Symbols should not contain NUL (\\0)");
     }
-    return rb_intern(RSTRING(str)->ptr);
+    return rb_intern(RSTRING_PTR(str));
 }
 
 ID
@@ -1509,7 +1509,7 @@ rb_to_id(VALUE name)
 	if (!NIL_P(tmp)) {
 	    return str_to_id(tmp);
 	}
-	rb_raise(rb_eTypeError, "%s is not a symbol", RSTRING(rb_inspect(name))->ptr);
+	rb_raise(rb_eTypeError, "%s is not a symbol", RSTRING_PTR(rb_inspect(name)));
     }
     return id;
 }
@@ -2112,8 +2112,8 @@ rb_str_to_dbl(VALUE str, int badcheck)
     long len;
 
     StringValue(str);
-    s = RSTRING(str)->ptr;
-    len = RSTRING(str)->len;
+    s = RSTRING_PTR(str);
+    len = RSTRING_LEN(str);
     if (s) {
 	if (s[len]) {		/* no sentinel somehow */
 	    char *p = ALLOCA_N(char, len+1);
@@ -2204,11 +2204,11 @@ char*
 rb_str2cstr(VALUE str, long *len)
 {
     StringValue(str);
-    if (len) *len = RSTRING(str)->len;
-    else if (RTEST(ruby_verbose) && RSTRING(str)->len != strlen(RSTRING(str)->ptr)) {
+    if (len) *len = RSTRING_LEN(str);
+    else if (RTEST(ruby_verbose) && RSTRING_LEN(str) != strlen(RSTRING_PTR(str))) {
 	rb_warn("string contains \\0 character");
     }
-    return RSTRING(str)->ptr;
+    return RSTRING_PTR(str);
 }
 
 VALUE
diff --git a/pack.c b/pack.c
index 8bdef7ce07..4a567ddce8 100644
--- a/pack.c
+++ b/pack.c
@@ -448,8 +448,8 @@ pack_pack(VALUE ary, VALUE fmt)
 #endif
 
     StringValue(fmt);
-    p = RSTRING(fmt)->ptr;
-    pend = p + RSTRING(fmt)->len;
+    p = RSTRING_PTR(fmt);
+    pend = p + RSTRING_LEN(fmt);
     res = rb_str_buf_new(0);
 
     items = RARRAY(ary)->len;
@@ -460,7 +460,7 @@ pack_pack(VALUE ary, VALUE fmt)
 #define NEXTFROM (items-- > 0 ? RARRAY(ary)->ptr[idx++] : TOO_FEW)
 
     while (p < pend) {
-	if (RSTRING(fmt)->ptr + RSTRING(fmt)->len != pend) {
+	if (RSTRING_PTR(fmt) + RSTRING_LEN(fmt) != pend) {
 	    rb_raise(rb_eRuntimeError, "format string modified");
 	}
 	type = *p++;		/* get data type */
@@ -510,8 +510,8 @@ pack_pack(VALUE ary, VALUE fmt)
 	    }
 	    else {
 		StringValue(from);
-		ptr = RSTRING(from)->ptr;
-		plen = RSTRING(from)->len;
+		ptr = RSTRING_PTR(from);
+		plen = RSTRING_LEN(from);
 		OBJ_INFECT(res, from);
 	    }
 
@@ -843,15 +843,14 @@ pack_pack(VALUE ary, VALUE fmt)
 
 	  case 'X':		/* back up byte */
 	  shrink:
-	    plen = RSTRING(res)->len;
+	    plen = RSTRING_LEN(res);
 	    if (plen < len)
 		rb_raise(rb_eArgError, "X outside of string");
-	    RSTRING(res)->len = plen - len;
-	    RSTRING(res)->ptr[plen - len] = '\0';
+	    rb_str_set_len(res, plen - len);
 	    break;
 
 	  case '@':		/* null fill to absolute position */
-	    len -= RSTRING(res)->len;
+	    len -= RSTRING_LEN(res);
 	    if (len > 0) goto grow;
 	    len = -len;
 	    if (len > 0) goto shrink;
@@ -882,8 +881,8 @@ pack_pack(VALUE ary, VALUE fmt)
 	  case 'm':		/* base64 encoded string */
 	    from = NEXTFROM;
 	    StringValue(from);
-	    ptr = RSTRING(from)->ptr;
-	    plen = RSTRING(from)->len;
+	    ptr = RSTRING_PTR(from);
+	    plen = RSTRING_LEN(from);
 
 	    if (len <= 2)
 		len = 45;
@@ -913,9 +912,9 @@ pack_pack(VALUE ary, VALUE fmt)
 	    from = THISFROM;
 	    if (!NIL_P(from)) {
 		StringValue(from);
-		if (RSTRING(from)->len < len) {
+		if (RSTRING_LEN(from) < len) {
 		    rb_raise(rb_eArgError, "too short buffer for P(%ld for %ld)",
-			     RSTRING(from)->len, len);
+			     RSTRING_LEN(from), len);
 		}
 	    }
 	    len = 1;
@@ -970,16 +969,16 @@ pack_pack(VALUE ary, VALUE fmt)
 		    ul >>=  7;
 		}
 
-		if (RSTRING(buf)->len) {
-		    bufs = RSTRING(buf)->ptr;
-		    bufe = bufs + RSTRING(buf)->len - 1;
+		if (RSTRING_LEN(buf)) {
+		    bufs = RSTRING_PTR(buf);
+		    bufe = bufs + RSTRING_LEN(buf) - 1;
 		    *bufs &= 0x7f; /* clear continue bit */
 		    while (bufs < bufe) { /* reverse */
 			c = *bufs;
 			*bufs++ = *bufe;
 			*bufe-- = c;
 		    }
-		    rb_str_buf_cat(res, RSTRING(buf)->ptr, RSTRING(buf)->len);
+		    rb_str_buf_cat(res, RSTRING_PTR(buf), RSTRING_LEN(buf));
 		}
 		else {
 		    c = 0;
@@ -1050,8 +1049,8 @@ qpencode(VALUE str, VALUE from, long len)
 {
     char buff[1024];
     long i = 0, n = 0, prev = EOF;
-    unsigned char *s = (unsigned char*)RSTRING(from)->ptr;
-    unsigned char *send = s + RSTRING(from)->len;
+    unsigned char *s = (unsigned char*)RSTRING_PTR(from);
+    unsigned char *send = s + RSTRING_LEN(from);
 
     while (s < send) {
         if ((*s > 126) ||
@@ -1301,10 +1300,10 @@ pack_unpack(VALUE str, VALUE fmt)
 
     StringValue(str);
     StringValue(fmt);
-    s = RSTRING(str)->ptr;
-    send = s + RSTRING(str)->len;
-    p = RSTRING(fmt)->ptr;
-    pend = p + RSTRING(fmt)->len;
+    s = RSTRING_PTR(str);
+    send = s + RSTRING_LEN(str);
+    p = RSTRING_PTR(fmt);
+    pend = p + RSTRING_LEN(fmt);
 
     ary = rb_ary_new();
     while (p < pend) {
@@ -1398,7 +1397,7 @@ pack_unpack(VALUE str, VALUE fmt)
 		    len = (send - s) * 8;
 		bits = 0;
 		rb_ary_push(ary, bitstr = rb_str_new(0, len));
-		t = RSTRING(bitstr)->ptr;
+		t = RSTRING_PTR(bitstr);
 		for (i=0; i<len; i++) {
 		    if (i & 7) bits >>= 1;
 		    else bits = *s++;
@@ -1418,7 +1417,7 @@ pack_unpack(VALUE str, VALUE fmt)
 		    len = (send - s) * 8;
 		bits = 0;
 		rb_ary_push(ary, bitstr = rb_str_new(0, len));
-		t = RSTRING(bitstr)->ptr;
+		t = RSTRING_PTR(bitstr);
 		for (i=0; i<len; i++) {
 		    if (i & 7) bits <<= 1;
 		    else bits = *s++;
@@ -1438,7 +1437,7 @@ pack_unpack(VALUE str, VALUE fmt)
 		    len = (send - s) * 2;
 		bits = 0;
 		rb_ary_push(ary, bitstr = rb_str_new(0, len));
-		t = RSTRING(bitstr)->ptr;
+		t = RSTRING_PTR(bitstr);
 		for (i=0; i<len; i++) {
 		    if (i & 1)
 			bits >>= 4;
@@ -1460,7 +1459,7 @@ pack_unpack(VALUE str, VALUE fmt)
 		    len = (send - s) * 2;
 		bits = 0;
 		rb_ary_push(ary, bitstr = rb_str_new(0, len));
-		t = RSTRING(bitstr)->ptr;
+		t = RSTRING_PTR(bitstr);
 		for (i=0; i<len; i++) {
 		    if (i & 1)
 			bits <<= 4;
@@ -1714,7 +1713,7 @@ pack_unpack(VALUE str, VALUE fmt)
 	  case 'u':
 	    {
 		VALUE buf = infected_str_new(0, (send - s)*3/4, str);
-		char *ptr = RSTRING(buf)->ptr;
+		char *ptr = RSTRING_PTR(buf);
 		long total = 0;
 
 		while (s < send && *s > ' ' && *s < 'a') {
@@ -1724,9 +1723,9 @@ pack_unpack(VALUE str, VALUE fmt)
 		    hunk[3] = '\0';
 		    len = (*s++ - ' ') & 077;
 		    total += len;
-		    if (total > RSTRING(buf)->len) {
-			len -= total - RSTRING(buf)->len;
-			total = RSTRING(buf)->len;
+		    if (total > RSTRING_LEN(buf)) {
+			len -= total - RSTRING_LEN(buf);
+			total = RSTRING_LEN(buf);
 		    }
 
 		    while (len > 0) {
@@ -1760,9 +1759,8 @@ pack_unpack(VALUE str, VALUE fmt)
 		    else if (s < send && (s+1 == send || s[1] == '\n'))
 			s += 2;	/* possible checksum byte */
 		}
-		
-		RSTRING(buf)->ptr[total] = '\0';
-		RSTRING(buf)->len = total;
+
+		rb_str_set_len(buf, total);
 		rb_ary_push(ary, buf);
 	    }
 	    break;
@@ -1770,7 +1768,7 @@ pack_unpack(VALUE str, VALUE fmt)
 	  case 'm':
 	    {
 		VALUE buf = infected_str_new(0, (send - s)*3/4, str);
-		char *ptr = RSTRING(buf)->ptr;
+		char *ptr = RSTRING_PTR(buf);
 		int a = -1,b = -1,c = 0,d;
 		static int first = 1;
 		static int b64_xtable[256];
@@ -1805,8 +1803,7 @@ pack_unpack(VALUE str, VALUE fmt)
 			*ptr++ = b << 4 | c >> 2;
 		    }
 		}
-		*ptr = '\0';
-		RSTRING(buf)->len = ptr - RSTRING(buf)->ptr;
+		rb_str_set_len(buf, ptr - RSTRING_PTR(buf));
 		rb_ary_push(ary, buf);
 	    }
 	    break;
@@ -1814,7 +1811,7 @@ pack_unpack(VALUE str, VALUE fmt)
 	  case 'M':
 	    {
 		VALUE buf = infected_str_new(0, send - s, str);
-		char *ptr = RSTRING(buf)->ptr;
+		char *ptr = RSTRING_PTR(buf);
 		int c1, c2;
 
 		while (s < send) {
@@ -1834,20 +1831,19 @@ pack_unpack(VALUE str, VALUE fmt)
 		    }
 		    s++;
 		}
-		*ptr = '\0';
-		RSTRING(buf)->len = ptr - RSTRING(buf)->ptr;
+		rb_str_set_len(buf, ptr - RSTRING_PTR(buf));
 		rb_ary_push(ary, buf);
 	    }
 	    break;
 
 	  case '@':
-	    if (len > RSTRING(str)->len)
+	    if (len > RSTRING_LEN(str))
 		rb_raise(rb_eArgError, "@ outside of string");
-	    s = RSTRING(str)->ptr + len;
+	    s = RSTRING_PTR(str) + len;
 	    break;
 
 	  case 'X':
-	    if (len > s - RSTRING(str)->ptr)
+	    if (len > s - RSTRING_PTR(str))
 		rb_raise(rb_eArgError, "X outside of string");
 	    s -= len;
 	    break;
@@ -1875,8 +1871,8 @@ pack_unpack(VALUE str, VALUE fmt)
 		    p = RARRAY(a)->ptr;
 		    pend = p + RARRAY(a)->len;
 		    while (p < pend) {
-			if (TYPE(*p) == T_STRING && RSTRING(*p)->ptr == t) {
-			    if (len < RSTRING(*p)->len) {
+			if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
+			    if (len < RSTRING_LEN(*p)) {
 				tmp = rb_tainted_str_new(t, len);
 				rb_str_associate(tmp, a);
 			    }
@@ -1920,7 +1916,7 @@ pack_unpack(VALUE str, VALUE fmt)
 			p = RARRAY(a)->ptr;
 			pend = p + RARRAY(a)->len;
 			while (p < pend) {
-			    if (TYPE(*p) == T_STRING && RSTRING(*p)->ptr == t) {
+			    if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
 				tmp = *p;
 				break;
 			    }
diff --git a/parse.y b/parse.y
index 7139ee6b42..49756f1902 100644
--- a/parse.y
+++ b/parse.y
@@ -3550,8 +3550,8 @@ regexp		: tREGEXP_BEG xstring_contents tREGEXP_END
 			    {
 				VALUE src = node->nd_lit;
 				nd_set_type(node, NODE_LIT);
-				node->nd_lit = rb_reg_compile(RSTRING(src)->ptr,
-							      RSTRING(src)->len,
+				node->nd_lit = rb_reg_compile(RSTRING_PTR(src),
+							      RSTRING_LEN(src),
 							      options & ~RE_OPTION_ONCE);
 			    }
 			    break;
@@ -3792,12 +3792,12 @@ dsym		: tSYMBEG xstring_contents tSTRING_END
 				break;
 			      case NODE_STR:
 				lit = $$->nd_lit;
-				if (RSTRING(lit)->len == 0) {
+				if (RSTRING_LEN(lit) == 0) {
 				    yyerror("empty symbol literal");
 				    break;
 				}
-				if (strlen(RSTRING(lit)->ptr) == RSTRING(lit)->len) {
-				    $$->nd_lit = ID2SYM(rb_intern(RSTRING($$->nd_lit)->ptr));
+				if (strlen(RSTRING_PTR(lit)) == RSTRING_LEN(lit)) {
+				    $$->nd_lit = ID2SYM(rb_intern(RSTRING_PTR($$->nd_lit)));
 				    nd_set_type($$, NODE_LIT);
 				    break;
 				}
@@ -4601,17 +4601,17 @@ lex_get_str(struct parser_params *parser, VALUE s)
 {
     char *beg, *end, *pend;
 
-    beg = RSTRING(s)->ptr;
+    beg = RSTRING_PTR(s);
     if (lex_gets_ptr) {
-	if (RSTRING(s)->len == lex_gets_ptr) return Qnil;
+	if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
 	beg += lex_gets_ptr;
     }
-    pend = RSTRING(s)->ptr + RSTRING(s)->len;
+    pend = RSTRING_PTR(s) + RSTRING_LEN(s);
     end = beg;
     while (end < pend) {
 	if (*end++ == '\n') break;
     }
-    lex_gets_ptr = end - RSTRING(s)->ptr;
+    lex_gets_ptr = end - RSTRING_PTR(s);
     return rb_str_new(beg, end - beg);
 }
 
@@ -4727,8 +4727,8 @@ parser_nextc(struct parser_params *parser)
 	    }
 	    ruby_sourceline++;
 	    parser->line_count++;
-	    lex_pbeg = lex_p = RSTRING(v)->ptr;
-	    lex_pend = lex_p + RSTRING(v)->len;
+	    lex_pbeg = lex_p = RSTRING_PTR(v);
+	    lex_pend = lex_p + RSTRING_LEN(v);
 #ifdef RIPPER
 	    ripper_flush(parser);
 #endif
@@ -5028,7 +5028,8 @@ enum string_type {
 static void
 dispose_string(VALUE str)
 {
-    xfree(RSTRING(str)->ptr);
+    if (RBASIC(str)->flags & RSTRING_NOEMBED)
+	xfree(RSTRING_PTR(str));
     rb_gc_force_recycle(str);
 }
 
@@ -5270,8 +5271,8 @@ parser_heredoc_restore(struct parser_params *parser, NODE *here)
 #endif
     line = here->nd_orig;
     lex_lastline = line;
-    lex_pbeg = RSTRING(line)->ptr;
-    lex_pend = lex_pbeg + RSTRING(line)->len;
+    lex_pbeg = RSTRING_PTR(line);
+    lex_pend = lex_pbeg + RSTRING_LEN(line);
     lex_p = lex_pbeg + here->nd_nth;
     heredoc_end = ruby_sourceline;
     ruby_sourceline = nd_line(here);
@@ -5306,8 +5307,8 @@ parser_here_document(struct parser_params *parser, NODE *here)
     long len;
     VALUE str = 0;
 
-    eos = RSTRING(here->nd_lit)->ptr;
-    len = RSTRING(here->nd_lit)->len - 1;
+    eos = RSTRING_PTR(here->nd_lit);
+    len = RSTRING_LEN(here->nd_lit) - 1;
     indent = (func = *eos++) & STR_FUNC_INDENT;
 
     if ((c = nextc()) == -1) {
@@ -5324,7 +5325,7 @@ parser_here_document(struct parser_params *parser, NODE *here)
 
     if (!(func & STR_FUNC_EXPAND)) {
 	do {
-	    p = RSTRING(lex_lastline)->ptr;
+	    p = RSTRING_PTR(lex_lastline);
 	    pend = lex_pend;
 	    if (pend > p) {
 		switch (pend[-1]) {
@@ -5469,7 +5470,7 @@ parser_pragma(struct parser_params *parser, const char *str, int len)
     const char *beg, *end, *vbeg, *vend;
 #define str_copy(_s, _p, _n) ((_s) \
 	? (rb_str_resize((_s), (_n)), \
-	   MEMCPY(RSTRING(_s)->ptr, (_p), char, (_n)), (_s)) \
+	   MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
 	: ((_s) = rb_str_new((_p), (_n))))
 
     if (len <= 7) return Qfalse;
@@ -5532,9 +5533,9 @@ parser_pragma(struct parser_params *parser, const char *str, int len)
 	rb_funcall(name, rb_intern("downcase!"), 0);
 #ifndef RIPPER
 	do {
-	    if (strncmp(p->name, RSTRING(name)->ptr, n) == 0) {
+	    if (strncmp(p->name, RSTRING_PTR(name), n) == 0) {
 		str_copy(val, vbeg, vend - vbeg);
-		(*p->func)(parser, RSTRING(name)->ptr, RSTRING(val)->ptr);
+		(*p->func)(parser, RSTRING_PTR(name), RSTRING_PTR(val));
 		break;
 	    }
 	} while (++p < pragmas + sizeof(pragmas) / sizeof(*p));
@@ -9218,7 +9219,7 @@ ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
 {
     StringValue(msg);
     if (obj == Qundef) {
-	rb_raise(rb_eArgError, RSTRING(msg)->ptr);
+	rb_raise(rb_eArgError, RSTRING_PTR(msg));
     }
     return Qnil;
 }
diff --git a/process.c b/process.c
index a07b0db4e0..ab8a9a3f70 100644
--- a/process.c
+++ b/process.c
@@ -974,7 +974,7 @@ rb_proc_exec_n(int argc, VALUE *argv, const char *prog)
 
     args = ALLOCA_N(char*, argc+1);
     for (i=0; i<argc; i++) {
-	args[i] = RSTRING(argv[i])->ptr;
+	args[i] = RSTRING_PTR(argv[i]);
     }
     args[i] = 0;
     if (args[0]) {
@@ -1177,7 +1177,7 @@ rb_check_argv(int argc, VALUE *argv)
     for (i = 0; i < argc; i++) {
 	SafeStringValue(argv[i]);
     }
-    security(RSTRING(prog ? prog : argv[0])->ptr);
+    security(RSTRING_PTR(prog ? prog : argv[0]));
     return prog;
 }
 
@@ -1219,12 +1219,12 @@ rb_f_exec(int argc, VALUE *argv)
     if (!prog && argc == 1) {
 	e.argc = 0;
 	e.argv = 0;
-	e.prog = RSTRING(argv[0])->ptr;
+	e.prog = RSTRING_PTR(argv[0]);
     }
     else {
 	e.argc = argc;
 	e.argv = argv;
-	e.prog = prog ? RSTRING(prog)->ptr : 0;
+	e.prog = prog ? RSTRING_PTR(prog) : 0;
     }
     rb_exec(&e);
     rb_sys_fail(e.prog);
@@ -1533,7 +1533,7 @@ rb_spawn(int argc, VALUE *argv)
 #if defined HAVE_FORK
     earg.argc = argc;
     earg.argv = argv;
-    earg.prog = prog ? RSTRING(prog)->ptr : 0;
+    earg.prog = prog ? RSTRING_PTR(prog) : 0;
     status = rb_fork(&status, (int (*)(void*))rb_exec, &earg);
     if (prog && argc) argv[0] = prog;
 #elif defined HAVE_SPAWNV
@@ -1598,7 +1598,7 @@ rb_f_system(int argc, VALUE *argv)
     signal(SIGCHLD, chfunc);
 #endif
     if (status < 0) {
-	rb_sys_fail(RSTRING(argv[0])->ptr);
+	rb_sys_fail(RSTRING_PTR(argv[0]));
     }
     status = NUM2INT(rb_last_status);
     if (status == EXIT_SUCCESS) return Qtrue;
@@ -1619,7 +1619,7 @@ rb_f_spawn(int argc, VALUE *argv)
     int pid;
 
     pid = rb_spawn(argc, argv);
-    if (pid == -1) rb_sys_fail(RSTRING(argv[0])->ptr);
+    if (pid == -1) rb_sys_fail(RSTRING_PTR(argv[0]));
 #if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
     return INT2NUM(pid);
 #else
@@ -2666,10 +2666,10 @@ proc_setgroups(VALUE obj, VALUE ary)
 		groups[i] = NUM2INT(g);
 	    }
 	    else {
-		gr = getgrnam(RSTRING(tmp)->ptr);
+		gr = getgrnam(RSTRING_PTR(tmp));
 		if (gr == NULL)
 		    rb_raise(rb_eArgError,
-			     "can't find group for %s", RSTRING(tmp)->ptr);
+			     "can't find group for %s", RSTRING_PTR(tmp));
 		groups[i] = gr->gr_gid;
 	    }
 	}
diff --git a/re.c b/re.c
index b3c4c1a49f..dd000140dd 100644
--- a/re.c
+++ b/re.c
@@ -597,9 +597,9 @@ rb_reg_raise(const char *s, long len, const char *err, VALUE re, int ce)
     VALUE desc = rb_reg_desc(s, len, re);
 
     if (ce)
-	rb_compile_error("%s: %s", err, RSTRING(desc)->ptr);
+	rb_compile_error("%s: %s", err, RSTRING_PTR(desc));
     else
-	rb_raise(rb_eRegexpError, "%s: %s", err, RSTRING(desc)->ptr);
+	rb_raise(rb_eRegexpError, "%s: %s", err, RSTRING_PTR(desc));
 }
 
 
@@ -949,13 +949,13 @@ rb_reg_adjust_startpos(VALUE re, VALUE str, long pos, long reverse)
 	range = -pos;
     }
     else {
-	range = RSTRING(str)->len - pos;
+	range = RSTRING_LEN(str) - pos;
     }
 
     enc = (RREGEXP(re)->ptr)->enc;
 
-    if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING(str)->len) {
-	 string = (UChar*)RSTRING(str)->ptr;
+    if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) {
+	 string = (UChar*)RSTRING_PTR(str);
 
 	 if (range > 0) {
 	      p = onigenc_get_right_adjust_char_head(enc, string, string + pos);
@@ -977,7 +977,7 @@ rb_reg_search(VALUE re, VALUE str, long pos, long reverse)
     static struct re_registers regs;
     long range;
 
-    if (pos > RSTRING(str)->len || pos < 0) {
+    if (pos > RSTRING_LEN(str) || pos < 0) {
 	rb_backref_set(Qnil);
 	return -1;
     }
@@ -994,14 +994,14 @@ rb_reg_search(VALUE re, VALUE str, long pos, long reverse)
 	range = -pos;
     }
     else {
-	range = RSTRING(str)->len - pos;
+	range = RSTRING_LEN(str) - pos;
     }
 
     result = onig_search(RREGEXP(re)->ptr,
-			 (UChar*)(RSTRING(str)->ptr),
-			 ((UChar*)(RSTRING(str)->ptr) + RSTRING(str)->len),
-			 ((UChar*)(RSTRING(str)->ptr) + pos),
-			 ((UChar*)(RSTRING(str)->ptr) + pos + range),
+			 (UChar*)(RSTRING_PTR(str)),
+			 ((UChar*)(RSTRING_PTR(str)) + RSTRING_LEN(str)),
+			 ((UChar*)(RSTRING_PTR(str)) + pos),
+			 ((UChar*)(RSTRING_PTR(str)) + pos + range),
 			 &regs, ONIG_OPTION_NONE);
 
     if (FL_TEST(re, KCODE_FIXED))
@@ -1130,7 +1130,7 @@ rb_reg_match_post(VALUE match)
     if (RMATCH(match)->BEG(0) == -1) return Qnil;
     str = RMATCH(match)->str;
     pos = RMATCH(match)->END(0);
-    str = rb_str_substr(str, pos, RSTRING(str)->len - pos);
+    str = rb_str_substr(str, pos, RSTRING_LEN(str) - pos);
     if (OBJ_TAINTED(match)) OBJ_TAINT(str);
     return str;
 }
@@ -1509,15 +1509,15 @@ VALUE
 rb_reg_regcomp(VALUE str)
 {
     volatile VALUE save_str = str;
-    if (reg_cache && RREGEXP(reg_cache)->len == RSTRING(str)->len
+    if (reg_cache && RREGEXP(reg_cache)->len == RSTRING_LEN(str)
 	&& case_cache == ruby_ignorecase
 	&& kcode_cache == reg_kcode
-	&& memcmp(RREGEXP(reg_cache)->str, RSTRING(str)->ptr, RSTRING(str)->len) == 0)
+	&& memcmp(RREGEXP(reg_cache)->str, RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
 	return reg_cache;
 
     case_cache = ruby_ignorecase;
     kcode_cache = reg_kcode;
-    return reg_cache = rb_reg_new(RSTRING(str)->ptr, RSTRING(str)->len,
+    return reg_cache = rb_reg_new(RSTRING_PTR(str), RSTRING_LEN(str),
 				  ruby_ignorecase);
 }
 
@@ -1595,7 +1595,7 @@ rb_reg_match_pos(VALUE re, VALUE str, long pos)
     StringValue(str);
     if (pos != 0) {
 	if (pos < 0) {
-	    pos += RSTRING(str)->len;
+	    pos += RSTRING_LEN(str);
 	    if (pos < 0) {
 		return Qnil;
 	    }
@@ -1796,7 +1796,7 @@ rb_reg_initialize_m(int argc, VALUE *argv, VALUE self)
 	    flags |= char_to_arg_kcode((int )kcode[0]);
 	}
 	s = StringValuePtr(argv[0]);
-	len = RSTRING(argv[0])->len;
+	len = RSTRING_LEN(argv[0]);
     }
     rb_reg_initialize(self, s, len, flags, Qfalse);
     return self;
@@ -1809,8 +1809,8 @@ rb_reg_quote(VALUE str)
     VALUE tmp;
     int c;
 
-    s = RSTRING(str)->ptr;
-    send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str);
+    send = s + RSTRING_LEN(str);
     for (; s < send; s++) {
 	c = *s;
 	if (ismbchar(*s)) {
@@ -1834,11 +1834,11 @@ rb_reg_quote(VALUE str)
     return str;
 
   meta_found:
-    tmp = rb_str_new(0, RSTRING(str)->len*2);
-    t = RSTRING(tmp)->ptr;
+    tmp = rb_str_new(0, RSTRING_LEN(str)*2);
+    t = RSTRING_PTR(tmp);
     /* copy upto metacharacter */
-    memcpy(t, RSTRING(str)->ptr, s - RSTRING(str)->ptr);
-    t += s - RSTRING(str)->ptr;
+    memcpy(t, RSTRING_PTR(str), s - RSTRING_PTR(str));
+    t += s - RSTRING_PTR(str);
 
     for (; s < send; s++) {
 	c = *s;
@@ -1881,7 +1881,7 @@ rb_reg_quote(VALUE str)
 	}
 	*t++ = c;
     }
-    rb_str_resize(tmp, t - RSTRING(tmp)->ptr);
+    rb_str_resize(tmp, t - RSTRING_PTR(tmp));
     OBJ_INFECT(tmp, str);
     return tmp;
 }
@@ -2003,7 +2003,7 @@ rb_reg_s_union(int argc, VALUE *argv)
                         str1 = rb_inspect(kcode_re);
                         str2 = rb_inspect(v);
                         rb_raise(rb_eArgError, "mixed kcode: %s and %s",
-                            RSTRING(str1)->ptr, RSTRING(str2)->ptr);
+                            RSTRING_PTR(str1), RSTRING_PTR(str2));
                     }
                 }
                 v = rb_reg_to_s(v);
@@ -2062,8 +2062,8 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp)
     int no;
 
 
-    p = s = RSTRING(str)->ptr;
-    e = s + RSTRING(str)->len;
+    p = s = RSTRING_PTR(str);
+    e = s + RSTRING_LEN(str);
 
     while (s < e) {
 	char *ss = s;
@@ -2125,11 +2125,11 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp)
 	    break;
 
 	  case '`':
-	    rb_str_buf_cat(val, RSTRING(src)->ptr, BEG(0));
+	    rb_str_buf_cat(val, RSTRING_PTR(src), BEG(0));
 	    continue;
 
 	  case '\'':
-	    rb_str_buf_cat(val, RSTRING(src)->ptr+END(0), RSTRING(src)->len-END(0));
+	    rb_str_buf_cat(val, RSTRING_PTR(src)+END(0), RSTRING_LEN(src)-END(0));
 	    continue;
 
 	  case '+':
@@ -2150,7 +2150,7 @@ rb_reg_regsub(VALUE str, VALUE src, struct re_registers *regs, VALUE regexp)
 	if (no >= 0) {
 	    if (no >= regs->num_regs) continue;
 	    if (BEG(no) == -1) continue;
-	    rb_str_buf_cat(val, RSTRING(src)->ptr+BEG(no), END(no)-BEG(no));
+	    rb_str_buf_cat(val, RSTRING_PTR(src)+BEG(no), END(no)-BEG(no));
 	}
     }
 
diff --git a/ruby.c b/ruby.c
index 1fa10e1f00..4ce58abaab 100644
--- a/ruby.c
+++ b/ruby.c
@@ -217,7 +217,7 @@ ruby_incpush(const char *path)
 static VALUE
 expand_include_path(VALUE path)
 {
-    char *p = RSTRING(path)->ptr;
+    char *p = RSTRING_PTR(path);
     if (!p) return path;
     if (*p == '.' && p[1] == '/') return path;
     return rb_file_expand_path(path, Qnil);
@@ -883,10 +883,10 @@ load_file(const char *fname, int script)
 	    xflag = Qfalse;
 	    while (!NIL_P(line = rb_io_gets(f))) {
 		line_start++;
-		if (RSTRING(line)->len > 2
-		    && RSTRING(line)->ptr[0] == '#'
-		    && RSTRING(line)->ptr[1] == '!') {
-		    if ((p = strstr(RSTRING(line)->ptr, "ruby")) != 0) {
+		if (RSTRING_LEN(line) > 2
+		    && RSTRING_PTR(line)[0] == '#'
+		    && RSTRING_PTR(line)[1] == '!') {
+		    if ((p = strstr(RSTRING_PTR(line), "ruby")) != 0) {
 			goto start_read;
 		    }
 		}
@@ -901,13 +901,13 @@ load_file(const char *fname, int script)
 		line = rb_io_gets(f);
 		if (NIL_P(line)) return;
 
-		if ((p = strstr(RSTRING(line)->ptr, "ruby")) == 0) {
+		if ((p = strstr(RSTRING_PTR(line), "ruby")) == 0) {
 		    /* not ruby script, kick the program */
 		    char **argv;
 		    char *path;
-		    char *pend = RSTRING(line)->ptr + RSTRING(line)->len;
+		    char *pend = RSTRING_PTR(line) + RSTRING_LEN(line);
 
-		    p = RSTRING(line)->ptr;	/* skip `#!' */
+		    p = RSTRING_PTR(line);	/* skip `#!' */
 		    if (pend[-1] == '\n') pend--; /* chomp line */
 		    if (pend[-1] == '\r') pend--;
 		    *pend = '\0';
@@ -935,9 +935,9 @@ load_file(const char *fname, int script)
 
 	      start_read:
 		p += 4;
-		RSTRING(line)->ptr[RSTRING(line)->len-1] = '\0';
-		if (RSTRING(line)->ptr[RSTRING(line)->len-2] == '\r')
-		    RSTRING(line)->ptr[RSTRING(line)->len-2] = '\0';
+		RSTRING_PTR(line)[RSTRING_LEN(line)-1] = '\0';
+		if (RSTRING_PTR(line)[RSTRING_LEN(line)-2] == '\r')
+		    RSTRING_PTR(line)[RSTRING_LEN(line)-2] = '\0';
 		if ((p = strstr(p, " -")) != 0) {
 		    p++;	/* skip space before `-' */
 		    while (*p == '-') {
@@ -1032,14 +1032,14 @@ set_arg0(VALUE val, ID id)
 
     if (origargv == 0) rb_raise(rb_eRuntimeError, "$0 not initialized");
     StringValue(val);
-    s = RSTRING(val)->ptr;
-    i = RSTRING(val)->len;
+    s = RSTRING_PTR(val);
+    i = RSTRING_LEN(val);
 #if defined(PSTAT_SETCMD)
     if (i >= PST_CLEN) {
 	union pstun j;
 	j.pst_command = s;
 	i = PST_CLEN;
-	RSTRING(val)->len = i;
+	RSTRING_LEN(val) = i;
 	*(s + i) = '\0';
 	pstat(PSTAT_SETCMD, j, PST_CLEN, 0, 0);
     }
diff --git a/ruby.h b/ruby.h
index 48de854e75..e0025083e5 100644
--- a/ruby.h
+++ b/ruby.h
@@ -317,8 +317,8 @@ char *rb_str2cstr(VALUE,long*);
 /* obsolete API - use StringValuePtr() */
 #define STR2CSTR(x) rb_str2cstr((VALUE)(x),0)
 
-#define NUM2CHR(x) (((TYPE(x) == T_STRING)&&(RSTRING(x)->len>=1))?\
-                     RSTRING(x)->ptr[0]:(char)(NUM2INT(x)&0xff))
+#define NUM2CHR(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\
+                     RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff))
 #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
 
 VALUE rb_newobj(void);
@@ -362,15 +362,33 @@ struct RFloat {
 
 #define ELTS_SHARED FL_USER2
 
+#define RSTRING_EMBED_LEN_MAX ((sizeof(VALUE)*3)/sizeof(char)-1)
 struct RString {
     struct RBasic basic;
-    long len;
-    char *ptr;
     union {
-	long capa;
-	VALUE shared;
-    } aux;
+	struct {
+	    long len;
+	    char *ptr;
+	    union {
+		long capa;
+		VALUE shared;
+	    } aux;
+	} heap;
+	char ary[RSTRING_EMBED_LEN_MAX];
+    } as;
 };
+#define RSTRING_NOEMBED FL_USER1
+#define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5)
+#define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
+#define RSTRING_LEN(str) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
+            (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) : \
+     RSTRING(str)->as.heap.len)
+#define RSTRING_PTR(str) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     RSTRING(str)->as.ary : \
+     RSTRING(str)->as.heap.ptr)
 
 struct RArray {
     struct RBasic basic;
@@ -446,8 +464,8 @@ struct RStruct {
 #define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
 #define RSTRUCT_LEN(st) \
     ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
-     (RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
-     (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT) : \
+     (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
+            (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
      RSTRUCT(st)->as.heap.len)
 #define RSTRUCT_PTR(st) \
     ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
@@ -499,6 +517,8 @@ struct RBignum {
 
 #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
 #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
+#define FL_ANY(x,f) FL_TEST(x,f)
+#define FL_ALL(x,f) (FL_TEST(x,f) == (f))
 #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
 #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
 #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
diff --git a/signal.c b/signal.c
index 8e76090487..1a46bac910 100644
--- a/signal.c
+++ b/signal.c
@@ -242,7 +242,7 @@ rb_f_kill(int argc, VALUE *argv)
 	goto str_signal;
 
       case T_STRING:
-	s = RSTRING(argv[0])->ptr;
+	s = RSTRING_PTR(argv[0]);
 	if (s[0] == '-') {
 	    negative++;
 	    s++;
@@ -263,7 +263,7 @@ rb_f_kill(int argc, VALUE *argv)
 
 	    str = rb_check_string_type(argv[0]);
 	    if (!NIL_P(str)) {
-		s = RSTRING(str)->ptr;
+		s = RSTRING_PTR(str);
 		goto str_signal;
 	    }
 	    rb_raise(rb_eArgError, "bad signal type %s",
@@ -574,28 +574,28 @@ trap(struct trap_arg *arg)
 	command = rb_check_string_type(arg->cmd);
 	if (!NIL_P(command)) {
 	    SafeStringValue(command);	/* taint check */
-	    switch (RSTRING(command)->len) {
+	    switch (RSTRING_LEN(command)) {
 	      case 0:
 		func = SIG_IGN;
 		break;
 	      case 7:
-		if (strncmp(RSTRING(command)->ptr, "SIG_IGN", 7) == 0) {
+		if (strncmp(RSTRING_PTR(command), "SIG_IGN", 7) == 0) {
 		    func = SIG_IGN;
 		}
-		else if (strncmp(RSTRING(command)->ptr, "SIG_DFL", 7) == 0) {
+		else if (strncmp(RSTRING_PTR(command), "SIG_DFL", 7) == 0) {
 		    func = SIG_DFL;
 		}
-		else if (strncmp(RSTRING(command)->ptr, "DEFAULT", 7) == 0) {
+		else if (strncmp(RSTRING_PTR(command), "DEFAULT", 7) == 0) {
 		    func = SIG_DFL;
 		}
 		break;
 	      case 6:
-		if (strncmp(RSTRING(command)->ptr, "IGNORE", 6) == 0) {
+		if (strncmp(RSTRING_PTR(command), "IGNORE", 6) == 0) {
 		    func = SIG_IGN;
 		}
 		break;
 	      case 4:
-		if (strncmp(RSTRING(command)->ptr, "EXIT", 4) == 0) {
+		if (strncmp(RSTRING_PTR(command), "EXIT", 4) == 0) {
 		    arg->cmd = Qundef;
 		}
 		break;
@@ -620,7 +620,7 @@ trap(struct trap_arg *arg)
 	goto str_signal;
 
       case T_STRING:
-	s = RSTRING(arg->sig)->ptr;
+	s = RSTRING_PTR(arg->sig);
 
       str_signal:
 	if (strncmp("SIG", s, 3) == 0)
diff --git a/sprintf.c b/sprintf.c
index 4c5e56843c..585db5b718 100644
--- a/sprintf.c
+++ b/sprintf.c
@@ -85,7 +85,7 @@ sign_bits(int base, const char *p)
 	bsiz*=2;\
     }\
     rb_str_resize(result, bsiz);\
-    buf = RSTRING(result)->ptr;\
+    buf = RSTRING_PTR(result);\
 } while (0)
 
 #define PUSH(s, l) do { \
@@ -268,12 +268,12 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
     if (OBJ_TAINTED(fmt)) tainted = 1;
     StringValue(fmt);
     fmt = rb_str_new4(fmt);
-    p = RSTRING(fmt)->ptr;
-    end = p + RSTRING(fmt)->len;
+    p = RSTRING_PTR(fmt);
+    end = p + RSTRING_LEN(fmt);
     blen = 0;
     bsiz = 120;
     result = rb_str_buf_new(bsiz);
-    buf = RSTRING(result)->ptr;
+    buf = RSTRING_PTR(result);
 
     for (; p < end; p++) {
 	const char *t;
@@ -404,10 +404,10 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 
 		tmp = rb_check_string_type(val);
 		if (!NIL_P(tmp)) {
-		    if (RSTRING(tmp)->len != 1) {
+		    if (RSTRING_LEN(tmp) != 1) {
 			rb_raise(rb_eArgError, "%%c requires a character");
 		    }
-		    c = RSTRING(tmp)->ptr[0];
+		    c = RSTRING_PTR(tmp)[0];
 		}
 		else {
 		    c = NUM2INT(val) & 0xff;
@@ -431,7 +431,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 		if (*p == 'p') arg = rb_inspect(arg);
 		str = rb_obj_as_string(arg);
 		if (OBJ_TAINTED(str)) tainted = 1;
-		len = RSTRING(str)->len;
+		len = RSTRING_LEN(str);
 		if (flags&FPREC) {
 		    if (prec < len) {
 			len = prec;
@@ -447,7 +447,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 				buf[blen++] = ' ';
 			    }
 			}
-			memcpy(&buf[blen], RSTRING(str)->ptr, len);
+			memcpy(&buf[blen], RSTRING_PTR(str), len);
 			blen += len;
 			if (flags&FMINUS) {
 			    while (width--) {
@@ -457,7 +457,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 			break;
 		    }
 		}
-		PUSH(RSTRING(str)->ptr, len);
+		PUSH(RSTRING_PTR(str), len);
 	    }
 	    break;
 
@@ -606,7 +606,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 		else {
 		    if (sign) {
 			tmp = rb_big2str(val, base);
-			s = RSTRING(tmp)->ptr;
+			s = RSTRING_PTR(tmp);
 			if (s[0] == '-') {
 			    s++;
 			    sc = '-';
@@ -628,14 +628,14 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 			    rb_big_2comp(val);
 			}
 			tmp1 = tmp = rb_big2str(val, base);
-			s = RSTRING(tmp)->ptr;
+			s = RSTRING_PTR(tmp);
 			if (*s == '-') {
 			    if (base == 10) {
 				rb_warning("negative number for %%u specifier");
 			    }
 			    remove_sign_bits(++s, base);
 			    tmp = rb_str_new(0, 3+strlen(s));
-			    t = RSTRING(tmp)->ptr;
+			    t = RSTRING_PTR(tmp);
 			    if (!(flags&(FPREC|FZERO))) {
 				strcpy(t, "..");
 				t += 2;
@@ -649,7 +649,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
 				if (s[0] != '1') strcpy(t++, "1"); break;
 			    }
 			    strcpy(t, s);
-			    s  = RSTRING(tmp)->ptr;
+			    s  = RSTRING_PTR(tmp);
 			}
 		    }
 		}
@@ -864,7 +864,7 @@ ruby__sfvwrite(register rb_printf_buffer *fp, register struct __suio *uio)
     VALUE result = (VALUE)fp->_bf._base;
     char *buf = (char*)fp->_p;
     size_t len, n;
-    int blen = buf - RSTRING(result)->ptr, bsiz = fp->_w;
+    int blen = buf - RSTRING_PTR(result), bsiz = fp->_w;
 
     if (RBASIC(result)->klass) {
 	rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
@@ -894,12 +894,12 @@ rb_vsprintf(const char *fmt, va_list ap)
     f._w = 120;
     result = rb_str_buf_new(f._w);
     f._bf._base = (unsigned char *)result;
-    f._p = (unsigned char *)RSTRING(result)->ptr;
+    f._p = (unsigned char *)RSTRING_PTR(result);
     RBASIC(result)->klass = 0;
     f.vwrite = ruby__sfvwrite;
     BSD_vfprintf(&f, fmt, ap);
     RBASIC(result)->klass = rb_cString;
-    rb_str_resize(result, (char *)f._p - RSTRING(result)->ptr);
+    rb_str_resize(result, (char *)f._p - RSTRING_PTR(result));
 
     return result;
 }
diff --git a/string.c b/string.c
index f6eda3745b..d28b2da2e1 100644
--- a/string.c
+++ b/string.c
@@ -27,22 +27,78 @@
 
 VALUE rb_cString;
 
-#define STR_TMPLOCK FL_USER1
+#define STR_TMPLOCK FL_USER7
+#define STR_NOEMBED FL_USER1
 #define STR_ASSOC   FL_USER3
-#define STR_NOCAPA  (ELTS_SHARED|STR_ASSOC)
-
-#define RESIZE_CAPA(str,capacity) do {\
-    REALLOC_N(RSTRING(str)->ptr, char, (capacity)+1);\
-    if (!FL_TEST(str, STR_NOCAPA))\
-        RSTRING(str)->aux.capa = (capacity);\
+#define STR_SHARED_P(s) FL_ALL(s, STR_NOEMBED|ELTS_SHARED)
+#define STR_ASSOC_P(s)  FL_ALL(s, STR_NOEMBED|STR_ASSOC)
+#define STR_NOCAPA  (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
+#define STR_NOCAPA_P(s) (FL_TEST(s,STR_NOEMBED) && FL_ANY(s,ELTS_SHARED|STR_ASSOC))
+#define STR_UNSET_NOCAPA(s) do {\
+    if (FL_TEST(s,STR_NOEMBED)) FL_UNSET(s,(ELTS_SHARED|STR_ASSOC));\
 } while (0)
+				    
+
+#define STR_SET_NOEMBED(str) do {\
+    FL_SET(str, STR_NOEMBED);\
+    STR_SET_EMBED_LEN(str, 0);\
+} while (0)
+#define STR_EMBED_P(str) (!FL_TEST(str, STR_NOEMBED))
+#define STR_SET_EMBED_LEN(str, n) do { \
+    long tmp_n = (n);\
+    RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\
+    RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\
+} while (0)
+
+#define STR_SET_LEN(str, n) do { \
+    if (STR_EMBED_P(str)) {\
+	STR_SET_EMBED_LEN(str, n);\
+    }\
+    else {\
+	RSTRING(str)->as.heap.len = (n);\
+    }\
+} while (0) 
+
+#define STR_DEC_LEN(str) do {\
+    if (STR_EMBED_P(str)) {\
+	long n = RSTRING_LEN(str);\
+	n--;\
+	STR_SET_EMBED_LEN(str, n);\
+    }\
+    else {\
+	RSTRING(str)->as.heap.len--;\
+    }\
+} while (0)
+    
+#define RESIZE_CAPA(str,capacity) do {\
+    if (STR_EMBED_P(str)) {\
+	if ((capacity) > RSTRING_EMBED_LEN_MAX) {\
+	    char *tmp = ALLOC_N(char, capacity+1);\
+	    memcpy(tmp, RSTRING_PTR(str), RSTRING_LEN(str));\
+	    RSTRING(str)->as.heap.ptr = tmp;\
+	    RSTRING(str)->as.heap.len = RSTRING_LEN(str);\
+            STR_SET_NOEMBED(str);\
+	    RSTRING(str)->as.heap.aux.capa = (capacity);\
+	}\
+    }\
+    else {\
+	REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+1);\
+	if (!STR_NOCAPA_P(str))\
+	    RSTRING(str)->as.heap.aux.capa = (capacity);\
+    }\
+} while (0)
+
+char *
+rb_str_ptr(VALUE str) {
+    return RSTRING_PTR(str);
+}
 
 VALUE rb_fs;
 
 static inline void
 str_mod_check(VALUE s, char *p, long len)
 {
-    if (RSTRING(s)->ptr != p || RSTRING(s)->len != len){
+    if (RSTRING_PTR(s) != p || RSTRING_LEN(s) != len){
 	rb_raise(rb_eRuntimeError, "string modified");
     }
 }
@@ -61,9 +117,9 @@ str_alloc(VALUE klass)
     NEWOBJ(str, struct RString);
     OBJSETUP(str, klass, T_STRING);
 
-    str->ptr = 0;
-    str->len = 0;
-    str->aux.capa = 0;
+    str->as.heap.ptr = 0;
+    str->as.heap.len = 0;
+    str->as.heap.aux.capa = 0;
 
     return (VALUE)str;
 }
@@ -78,13 +134,16 @@ str_new(VALUE klass, const char *ptr, long len)
     }
 
     str = str_alloc(klass);
-    RSTRING(str)->len = len;
-    RSTRING(str)->aux.capa = len;
-    RSTRING(str)->ptr = ALLOC_N(char,len+1);
-    if (ptr) {
-	memcpy(RSTRING(str)->ptr, ptr, len);
+    if (len > RSTRING_EMBED_LEN_MAX) {
+	RSTRING(str)->as.heap.aux.capa = len;
+	RSTRING(str)->as.heap.ptr = ALLOC_N(char,len+1);
+	STR_SET_NOEMBED(str);
     }
-    RSTRING(str)->ptr[len] = '\0';
+    if (ptr) {
+	memcpy(RSTRING_PTR(str), ptr, len);
+    }
+    STR_SET_LEN(str, len);
+    RSTRING_PTR(str)[len] = '\0';
     return str;
 }
 
@@ -126,9 +185,10 @@ str_new3(VALUE klass, VALUE str)
 {
     VALUE str2 = str_alloc(klass);
 
-    RSTRING(str2)->len = RSTRING(str)->len;
-    RSTRING(str2)->ptr = RSTRING(str)->ptr;
-    RSTRING(str2)->aux.shared = str;
+    FL_SET(str2, STR_NOEMBED);
+    RSTRING(str2)->as.heap.len = RSTRING_LEN(str);
+    RSTRING(str2)->as.heap.ptr = RSTRING_PTR(str);
+    RSTRING(str2)->as.heap.aux.shared = str;
     FL_SET(str2, ELTS_SHARED);
     OBJ_INFECT(str2, str);
 
@@ -144,19 +204,21 @@ rb_str_new3(VALUE str)
 static VALUE
 str_new4(VALUE klass, VALUE str)
 {
-    VALUE str2 = str_alloc(klass);
+    VALUE str2;
 
-    RSTRING(str2)->len = RSTRING(str)->len;
-    RSTRING(str2)->ptr = RSTRING(str)->ptr;
-    if (FL_TEST(str, ELTS_SHARED)) {
+    str2 = str_alloc(klass);
+    STR_SET_NOEMBED(str2);
+    RSTRING(str2)->as.heap.len = RSTRING_LEN(str);
+    RSTRING(str2)->as.heap.ptr = RSTRING_PTR(str);
+    if (STR_SHARED_P(str)) {
 	FL_SET(str2, ELTS_SHARED);
-	RSTRING(str2)->aux.shared = RSTRING(str)->aux.shared;
+	RSTRING(str2)->as.heap.aux.shared = RSTRING(str)->as.heap.aux.shared;
     }
     else {
 	FL_SET(str, ELTS_SHARED);
-	RSTRING(str)->aux.shared = str2;
+	RSTRING(str)->as.heap.aux.shared = str2;
     }
-
+    OBJ_INFECT(str2, str);
     return str2;
 }
 
@@ -167,17 +229,18 @@ rb_str_new4(VALUE orig)
 
     if (OBJ_FROZEN(orig)) return orig;
     klass = rb_obj_class(orig);
-    if (FL_TEST(orig, ELTS_SHARED) && (str = RSTRING(orig)->aux.shared) && klass == RBASIC(str)->klass) {
+    if (STR_SHARED_P(orig) && (str = RSTRING(orig)->as.heap.aux.shared)
+	&& klass == RBASIC(str)->klass) {
 	long ofs;
-	ofs = RSTRING(str)->len - RSTRING(orig)->len;
+	ofs = RSTRING_LEN(str) - RSTRING_LEN(orig);
 	if (ofs > 0) {
 	    str = str_new3(klass, str);
-	    RSTRING(str)->ptr += ofs;
-	    RSTRING(str)->len -= ofs;
+	    RSTRING(str)->as.heap.ptr += ofs;
+	    RSTRING(str)->as.heap.len -= ofs;
 	}
     }
-    else if (FL_TEST(orig, STR_ASSOC)) {
-	str = str_new(klass, RSTRING(orig)->ptr, RSTRING(orig)->len);
+    else if (STR_ASSOC_P(orig) || STR_EMBED_P(orig)) {
+	str = str_new(klass, RSTRING_PTR(orig), RSTRING_LEN(orig));
     }
     else {
 	str = str_new4(klass, orig);
@@ -203,11 +266,10 @@ rb_str_buf_new(long capa)
     if (capa < STR_BUF_MIN_SIZE) {
 	capa = STR_BUF_MIN_SIZE;
     }
-    RSTRING(str)->ptr = 0;
-    RSTRING(str)->len = 0;
-    RSTRING(str)->aux.capa = capa;
-    RSTRING(str)->ptr = ALLOC_N(char, capa+1);
-    RSTRING(str)->ptr[0] = '\0';
+    FL_SET(str, STR_NOEMBED);
+    RSTRING(str)->as.heap.aux.capa = capa;
+    RSTRING(str)->as.heap.ptr = ALLOC_N(char, capa+1);
+    RSTRING(str)->as.heap.ptr[0] = '\0';
 
     return str;
 }
@@ -235,22 +297,31 @@ rb_str_shared_replace(VALUE str, VALUE str2)
 {
     if (str == str2) return;
     rb_str_modify(str);
-    if (!FL_TEST(str, ELTS_SHARED)) free(RSTRING(str)->ptr);
-    RSTRING(str)->ptr = RSTRING(str2)->ptr;
-    RSTRING(str)->len = RSTRING(str2)->len;
-    FL_UNSET(str, STR_NOCAPA);
-    if (FL_TEST(str2, STR_NOCAPA)) {
+    if (OBJ_TAINTED(str2)) OBJ_TAINT(str);
+    if (RSTRING_LEN(str2) <= RSTRING_EMBED_LEN_MAX) {
+	FL_UNSET(str, STR_NOEMBED);
+	memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1);
+	STR_SET_EMBED_LEN(str, RSTRING_LEN(str2));
+	return;
+    }
+    STR_SET_NOEMBED(str);
+    if (!STR_SHARED_P(str) && !STR_EMBED_P(str)) {
+	free(RSTRING_PTR(str));
+    }
+    STR_UNSET_NOCAPA(str);
+    RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
+    RSTRING(str)->as.heap.len = RSTRING_LEN(str2);
+    if (STR_NOCAPA_P(str2)) {
 	FL_SET(str, RBASIC(str2)->flags & STR_NOCAPA);
-	RSTRING(str)->aux.shared = RSTRING(str2)->aux.shared;
+	RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared;
     }
     else {
-	RSTRING(str)->aux.capa = RSTRING(str2)->aux.capa;
+	RSTRING(str)->as.heap.aux.capa = RSTRING(str2)->as.heap.aux.capa;
     }
-    RSTRING(str2)->ptr = 0;	/* abandon str2 */
-    RSTRING(str2)->len = 0;
-    RSTRING(str2)->aux.capa = 0;
-    FL_UNSET(str2, STR_NOCAPA);
-    if (OBJ_TAINTED(str2)) OBJ_TAINT(str);
+    RSTRING(str2)->as.heap.ptr = 0;	/* abandon str2 */
+    RSTRING(str2)->as.heap.len = 0;
+    RSTRING(str2)->as.heap.aux.capa = 0;
+    STR_UNSET_NOCAPA(str2);
 }
 
 static ID id_to_s;
@@ -308,7 +379,8 @@ rb_str_init(int argc, VALUE *argv, VALUE str)
 static VALUE
 rb_str_length(VALUE str)
 {
-    return LONG2NUM(RSTRING(str)->len);
+    long len = RSTRING_LEN(str);
+    return LONG2NUM(len);
 }
 
 /*
@@ -324,7 +396,7 @@ rb_str_length(VALUE str)
 static VALUE
 rb_str_empty(VALUE str)
 {
-    if (RSTRING(str)->len == 0)
+    if (RSTRING_LEN(str) == 0)
 	return Qtrue;
     return Qfalse;
 }
@@ -345,11 +417,11 @@ rb_str_plus(VALUE str1, VALUE str2)
     VALUE str3;
 
     StringValue(str2);
-    str3 = rb_str_new(0, RSTRING(str1)->len+RSTRING(str2)->len);
-    memcpy(RSTRING(str3)->ptr, RSTRING(str1)->ptr, RSTRING(str1)->len);
-    memcpy(RSTRING(str3)->ptr + RSTRING(str1)->len,
-	   RSTRING(str2)->ptr, RSTRING(str2)->len);
-    RSTRING(str3)->ptr[RSTRING(str3)->len] = '\0';
+    str3 = rb_str_new(0, RSTRING_LEN(str1)+RSTRING_LEN(str2));
+    memcpy(RSTRING_PTR(str3), RSTRING_PTR(str1), RSTRING_LEN(str1));
+    memcpy(RSTRING_PTR(str3) + RSTRING_LEN(str1),
+	   RSTRING_PTR(str2), RSTRING_LEN(str2));
+    RSTRING_PTR(str3)[RSTRING_LEN(str3)] = '\0';
 
     if (OBJ_TAINTED(str1) || OBJ_TAINTED(str2))
 	OBJ_TAINT(str3);
@@ -376,16 +448,16 @@ rb_str_times(VALUE str, VALUE times)
     if (len < 0) {
 	rb_raise(rb_eArgError, "negative argument");
     }
-    if (len && LONG_MAX/len <  RSTRING(str)->len) {
+    if (len && LONG_MAX/len <  RSTRING_LEN(str)) {
 	rb_raise(rb_eArgError, "argument too big");
     }
 
-    str2 = rb_str_new5(str,0, len *= RSTRING(str)->len);
-    for (i = 0; i < len; i += RSTRING(str)->len) {
-	memcpy(RSTRING(str2)->ptr + i,
-	       RSTRING(str)->ptr, RSTRING(str)->len);
+    str2 = rb_str_new5(str,0, len *= RSTRING_LEN(str));
+    for (i = 0; i < len; i += RSTRING_LEN(str)) {
+	memcpy(RSTRING_PTR(str2) + i,
+	       RSTRING_PTR(str), RSTRING_LEN(str));
     }
-    RSTRING(str2)->ptr[RSTRING(str2)->len] = '\0';
+    RSTRING_PTR(str2)[RSTRING_LEN(str2)] = '\0';
 
     OBJ_INFECT(str2, str);
 
@@ -424,7 +496,8 @@ str_independent(VALUE str)
     if (OBJ_FROZEN(str)) rb_error_frozen("string");
     if (!OBJ_TAINTED(str) && rb_safe_level() >= 4)
 	rb_raise(rb_eSecurityError, "Insecure: can't modify string");
-    if (!FL_TEST(str, ELTS_SHARED)) return 1;
+    if (!STR_SHARED_P(str)) return 1;
+    if (STR_EMBED_P(str)) return 1;
     return 0;
 }
 
@@ -432,15 +505,17 @@ static void
 str_make_independent(VALUE str)
 {
     char *ptr;
+    long len = RSTRING_LEN(str);
 
-    ptr = ALLOC_N(char, RSTRING(str)->len+1);
-    if (RSTRING(str)->ptr) {
-	memcpy(ptr, RSTRING(str)->ptr, RSTRING(str)->len);
+    ptr = ALLOC_N(char, len+1);
+    if (RSTRING_PTR(str)) {
+	memcpy(ptr, RSTRING_PTR(str), len);
     }
-    ptr[RSTRING(str)->len] = 0;
-    RSTRING(str)->ptr = ptr;
-    RSTRING(str)->aux.capa = RSTRING(str)->len;
-    FL_UNSET(str, STR_NOCAPA);
+    STR_SET_NOEMBED(str);
+    ptr[len] = 0;
+    RSTRING(str)->as.heap.ptr = ptr;
+    RSTRING(str)->as.heap.aux.capa = len;
+    STR_UNSET_NOCAPA(str);
 }
 
 void
@@ -453,33 +528,31 @@ rb_str_modify(VALUE str)
 void
 rb_str_associate(VALUE str, VALUE add)
 {
-    if (FL_TEST(str, STR_ASSOC)) {
+    if (STR_ASSOC_P(str)) {
 	/* already associated */
-	rb_ary_concat(RSTRING(str)->aux.shared, add);
+	rb_ary_concat(RSTRING(str)->as.heap.aux.shared, add);
     }
     else {
-	if (FL_TEST(str, ELTS_SHARED)) {
+	if (STR_SHARED_P(str) || STR_EMBED_P(str)) {
 	    str_make_independent(str);
 	}
-	else if (RSTRING(str)->aux.capa != RSTRING(str)->len) {
-	    RESIZE_CAPA(str, RSTRING(str)->len);
+	else if (RSTRING(str)->as.heap.aux.capa != RSTRING_LEN(str)) {
+	    RESIZE_CAPA(str, RSTRING_LEN(str));
 	}
-	RSTRING(str)->aux.shared = add;
 	FL_SET(str, STR_ASSOC);
+	RSTRING(str)->as.heap.aux.shared = add;
     }
 }
 
 VALUE
 rb_str_associated(VALUE str)
 {
-    if (FL_TEST(str, STR_ASSOC)) {
-	return RSTRING(str)->aux.shared;
+    if (STR_ASSOC_P(str)) {
+	return RSTRING(str)->as.heap.aux.shared;
     }
     return Qfalse;
 }
 
-static char *null_str = "";
-
 VALUE
 rb_string_value(volatile VALUE *ptr)
 {
@@ -488,26 +561,22 @@ rb_string_value(volatile VALUE *ptr)
 	s = rb_str_to_str(s);
 	*ptr = s;
     }
-    if (!RSTRING(s)->ptr) {
-	FL_SET(s, ELTS_SHARED);
-	RSTRING(s)->ptr = null_str;
-    }
     return s;
 }
 
 char *
 rb_string_value_ptr(volatile VALUE *ptr)
 {
-    return RSTRING(rb_string_value(ptr))->ptr;
+    return RSTRING_PTR(rb_string_value(ptr));
 }
 
 char *
 rb_string_value_cstr(volatile VALUE *ptr)
 {
     VALUE str = rb_string_value(ptr);
-    char *s = RSTRING(str)->ptr;
+    char *s = RSTRING_PTR(str);
 
-    if (!s || RSTRING(str)->len != strlen(s)) {
+    if (!s || RSTRING_LEN(str) != strlen(s)) {
 	rb_raise(rb_eArgError, "string contains null byte");
     }
     return s;
@@ -517,10 +586,6 @@ VALUE
 rb_check_string_type(VALUE str)
 {
     str = rb_check_convert_type(str, T_STRING, "String", "to_str");
-    if (!NIL_P(str) && !RSTRING(str)->ptr) {
-	FL_SET(str, ELTS_SHARED);
-	RSTRING(str)->ptr = null_str;
-    }
     return str;
 }
 
@@ -530,13 +595,13 @@ rb_str_substr(VALUE str, long beg, long len)
     VALUE str2;
 
     if (len < 0) return Qnil;
-    if (beg > RSTRING(str)->len) return Qnil;
+    if (beg > RSTRING_LEN(str)) return Qnil;
     if (beg < 0) {
-	beg += RSTRING(str)->len;
+	beg += RSTRING_LEN(str);
 	if (beg < 0) return Qnil;
     }
-    if (beg + len > RSTRING(str)->len) {
-	len = RSTRING(str)->len - beg;
+    if (beg + len > RSTRING_LEN(str)) {
+	len = RSTRING_LEN(str) - beg;
     }
     if (len < 0) {
 	len = 0;
@@ -544,14 +609,14 @@ rb_str_substr(VALUE str, long beg, long len)
     if (len == 0) {
 	str2 = rb_str_new5(str,0,0);
     }
-    else if (len > sizeof(struct RString)/2 &&
-	beg + len == RSTRING(str)->len && !FL_TEST(str, STR_ASSOC)) {
+    else if (len > RSTRING_EMBED_LEN_MAX &&
+	     beg + len == RSTRING_LEN(str) && !STR_ASSOC_P(str)) {
 	str2 = rb_str_new3(rb_str_new4(str));
-	RSTRING(str2)->ptr += RSTRING(str2)->len - len;
-	RSTRING(str2)->len = len;
+	RSTRING(str2)->as.heap.ptr += RSTRING_LEN(str2) - len;
+	RSTRING(str2)->as.heap.len = len;
     }
     else {
-	str2 = rb_str_new5(str, RSTRING(str)->ptr+beg, len);
+	str2 = rb_str_new5(str, RSTRING_PTR(str)+beg, len);
     }
     OBJ_INFECT(str2, str);
 
@@ -567,9 +632,9 @@ rb_str_freeze(VALUE str)
 VALUE
 rb_str_dup_frozen(VALUE str)
 {
-    if (FL_TEST(str, ELTS_SHARED) && RSTRING(str)->aux.shared) {
-	VALUE shared = RSTRING(str)->aux.shared;
-	if (RSTRING(shared)->len == RSTRING(str)->len) {
+    if (STR_SHARED_P(str) && RSTRING(str)->as.heap.aux.shared) {
+	VALUE shared = RSTRING(str)->as.heap.aux.shared;
+	if (RSTRING_LEN(shared) == RSTRING_LEN(str)) {
 	    OBJ_FREEZE(shared);
 	    return shared;
 	}
@@ -600,6 +665,13 @@ rb_str_unlocktmp(VALUE str)
     return str;
 }
 
+void
+rb_str_set_len(VALUE str, long len)
+{
+    STR_SET_LEN(str, len);
+    RSTRING_PTR(str)[len] = '\0';
+}
+
 VALUE
 rb_str_resize(VALUE str, long len)
 {
@@ -608,15 +680,24 @@ rb_str_resize(VALUE str, long len)
     }
 
     rb_str_modify(str);
-    if (len != RSTRING(str)->len) {
-	if (RSTRING(str)->len < len || RSTRING(str)->len - len > 1024) {
-	    REALLOC_N(RSTRING(str)->ptr, char, len+1);
-	    if (!FL_TEST(str, STR_NOCAPA)) {
-		RSTRING(str)->aux.capa = len;
+    if (len != RSTRING_LEN(str)) {
+	if (STR_EMBED_P(str)) {
+	    if (len <= RSTRING_EMBED_LEN_MAX) {
+		STR_SET_EMBED_LEN(str, len);
+		RSTRING_PTR(str)[len] = '\0';
+		return str;
 	    }
+	    RSTRING(str)->as.heap.ptr = ALLOC_N(char,len+1);
+	    STR_SET_NOEMBED(str);
 	}
-	RSTRING(str)->len = len;
-	RSTRING(str)->ptr[len] = '\0';	/* sentinel */
+	else if (RSTRING_LEN(str) < len || RSTRING_LEN(str) - len > 1024) {
+	    REALLOC_N(RSTRING(str)->as.heap.ptr, char, len+1);
+	}
+	if (!STR_NOCAPA_P(str)) {
+	    RSTRING(str)->as.heap.aux.capa = len;
+	}
+	RSTRING(str)->as.heap.len = len;
+	RSTRING(str)->as.heap.ptr[len] = '\0';	/* sentinel */
     }
     return str;
 }
@@ -631,23 +712,26 @@ rb_str_buf_cat(VALUE str, const char *ptr, long len)
 	rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
     rb_str_modify(str);
-    if (FL_TEST(str, STR_ASSOC)) {
+    if (STR_ASSOC_P(str)) {
 	FL_UNSET(str, STR_ASSOC);
-	capa = RSTRING(str)->aux.capa = RSTRING(str)->len;
+	capa = RSTRING(str)->as.heap.aux.capa = RSTRING_LEN(str);
+    }
+    else if (STR_EMBED_P(str)) {
+	capa = RSTRING_EMBED_LEN_MAX;
     }
     else {
-	capa = RSTRING(str)->aux.capa;
+	capa = RSTRING(str)->as.heap.aux.capa;
     }
-    total = RSTRING(str)->len+len;
+    total = RSTRING_LEN(str)+len;
     if (capa <= total) {
 	while (total > capa) {
 	    capa = (capa + 1) * 2;
 	}
 	RESIZE_CAPA(str, capa);
     }
-    memcpy(RSTRING(str)->ptr + RSTRING(str)->len, ptr, len);
-    RSTRING(str)->len = total;
-    RSTRING(str)->ptr[total] = '\0'; /* sentinel */
+    memcpy(RSTRING_PTR(str) + RSTRING_LEN(str), ptr, len);
+    STR_SET_LEN(str, total);
+    RSTRING_PTR(str)[total] = '\0'; /* sentinel */
 
     return str;
 }
@@ -664,12 +748,13 @@ rb_str_cat(VALUE str, const char *ptr, long len)
     if (len < 0) {
 	rb_raise(rb_eArgError, "negative string size (or size too big)");
     }
-    if (FL_TEST(str, STR_ASSOC)) {
+    if (STR_ASSOC_P(str)) {
 	rb_str_modify(str);
-	REALLOC_N(RSTRING(str)->ptr, char, RSTRING(str)->len+len);
-	memcpy(RSTRING(str)->ptr + RSTRING(str)->len, ptr, len);
-	RSTRING(str)->len += len;
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0'; /* sentinel */
+	if (STR_EMBED_P(str)) str_make_independent(str);
+	REALLOC_N(RSTRING(str)->as.heap.ptr, char, RSTRING(str)->as.heap.len+len);
+	memcpy(RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len, ptr, len);
+	RSTRING(str)->as.heap.len += len;
+	RSTRING(str)->as.heap.ptr[RSTRING(str)->as.heap.len] = '\0'; /* sentinel */
 	return str;
     }
 
@@ -688,24 +773,26 @@ rb_str_buf_append(VALUE str, VALUE str2)
     long capa, len;
 
     rb_str_modify(str);
-    if (FL_TEST(str, STR_ASSOC)) {
+    if (STR_ASSOC_P(str)) {
 	FL_UNSET(str, STR_ASSOC);
-	capa = RSTRING(str)->aux.capa = RSTRING(str)->len;
+	capa = RSTRING(str)->as.heap.aux.capa = RSTRING_LEN(str);
+    }
+    else if (STR_EMBED_P(str)) {
+	capa = RSTRING_EMBED_LEN_MAX;
     }
     else {
-	capa = RSTRING(str)->aux.capa;
+	capa = RSTRING(str)->as.heap.aux.capa;
     }
-    len = RSTRING(str)->len+RSTRING(str2)->len;
+    len = RSTRING_LEN(str)+RSTRING_LEN(str2);
     if (capa <= len) {
 	while (len > capa) {
 	    capa = (capa + 1) * 2;
 	}
 	RESIZE_CAPA(str, capa);
     }
-    memcpy(RSTRING(str)->ptr + RSTRING(str)->len,
-	   RSTRING(str2)->ptr, RSTRING(str2)->len);
-    RSTRING(str)->len += RSTRING(str2)->len;
-    RSTRING(str)->ptr[RSTRING(str)->len] = '\0'; /* sentinel */
+    memcpy(RSTRING_PTR(str) + RSTRING_LEN(str),
+	   RSTRING_PTR(str2), RSTRING_LEN(str2)+1);
+    STR_SET_LEN(str, len);
     OBJ_INFECT(str, str2);
 
     return str;
@@ -716,14 +803,13 @@ rb_str_append(VALUE str, VALUE str2)
 {
     StringValue(str2);
     rb_str_modify(str);
-    if (RSTRING(str2)->len > 0) {
-	if (FL_TEST(str, STR_ASSOC)) {
-	    long len = RSTRING(str)->len+RSTRING(str2)->len;
-	    REALLOC_N(RSTRING(str)->ptr, char, len+1);
-	    memcpy(RSTRING(str)->ptr + RSTRING(str)->len,
-		   RSTRING(str2)->ptr, RSTRING(str2)->len);
-	    RSTRING(str)->ptr[len] = '\0'; /* sentinel */
-	    RSTRING(str)->len = len;
+    if (RSTRING_LEN(str2) > 0) {
+	if (STR_ASSOC_P(str)) {
+	    long len = RSTRING_LEN(str)+RSTRING_LEN(str2);
+	    REALLOC_N(RSTRING(str)->as.heap.ptr, char, len+1);
+	    memcpy(RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len,
+		   RSTRING_PTR(str2), RSTRING_LEN(str2)+1);
+	    RSTRING(str)->as.heap.len = len;
 	}
 	else {
 	    return rb_str_buf_append(str, str2);
@@ -760,9 +846,7 @@ rb_str_concat(VALUE str1, VALUE str2)
 	    return rb_str_cat(str1, &c, 1);
 	}
     }
-    str1 = rb_str_append(str1, str2);
-
-    return str1;
+    return rb_str_append(str1, str2);
 }
 
 /*
@@ -866,7 +950,7 @@ rb_memhash(const void *ptr, long len)
 int
 rb_str_hash(VALUE str)
 {
-    return rb_memhash(RSTRING(str)->ptr, RSTRING(str)->len);
+    return rb_memhash(RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
 /*
@@ -891,11 +975,11 @@ rb_str_cmp(VALUE str1, VALUE str2)
     long len;
     int retval;
 
-    len = lesser(RSTRING(str1)->len, RSTRING(str2)->len);
-    retval = rb_memcmp(RSTRING(str1)->ptr, RSTRING(str2)->ptr, len);
+    len = lesser(RSTRING_LEN(str1), RSTRING_LEN(str2));
+    retval = rb_memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len);
     if (retval == 0) {
-	if (RSTRING(str1)->len == RSTRING(str2)->len) return 0;
-	if (RSTRING(str1)->len > RSTRING(str2)->len) return 1;
+	if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return 0;
+	if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return 1;
 	return -1;
     }
     if (retval > 0) return 1;
@@ -922,7 +1006,7 @@ rb_str_equal(VALUE str1, VALUE str2)
 	}
 	return rb_equal(str2, str1);
     }
-    if (RSTRING(str1)->len == RSTRING(str2)->len &&
+    if (RSTRING_LEN(str1) == RSTRING_LEN(str2) &&
 	rb_str_cmp(str1, str2) == 0) {
 	return Qtrue;
     }
@@ -939,11 +1023,11 @@ rb_str_equal(VALUE str1, VALUE str2)
 static VALUE
 rb_str_eql(VALUE str1, VALUE str2)
 {
-    if (TYPE(str2) != T_STRING || RSTRING(str1)->len != RSTRING(str2)->len)
+    if (TYPE(str2) != T_STRING || RSTRING_LEN(str1) != RSTRING_LEN(str2))
 	return Qfalse;
 
-    if (memcmp(RSTRING(str1)->ptr, RSTRING(str2)->ptr,
-	       lesser(RSTRING(str1)->len, RSTRING(str2)->len)) == 0)
+    if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2),
+	       lesser(RSTRING_LEN(str1), RSTRING_LEN(str2))) == 0)
 	return Qtrue;
 
     return Qfalse;
@@ -1021,11 +1105,11 @@ rb_str_casecmp(VALUE str1, VALUE str2)
     int retval;
 
     StringValue(str2);
-    len = lesser(RSTRING(str1)->len, RSTRING(str2)->len);
-    retval = rb_memcicmp(RSTRING(str1)->ptr, RSTRING(str2)->ptr, len);
+    len = lesser(RSTRING_LEN(str1), RSTRING_LEN(str2));
+    retval = rb_memcicmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len);
     if (retval == 0) {
-	if (RSTRING(str1)->len == RSTRING(str2)->len) return INT2FIX(0);
-	if (RSTRING(str1)->len > RSTRING(str2)->len) return INT2FIX(1);
+	if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0);
+	if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1);
 	return INT2FIX(-1);
     }
     if (retval == 0) return INT2FIX(0);
@@ -1039,13 +1123,13 @@ rb_str_index(VALUE str, VALUE sub, long offset)
     long pos;
 
     if (offset < 0) {
-	offset += RSTRING(str)->len;
+	offset += RSTRING_LEN(str);
 	if (offset < 0) return -1;
     }
-    if (RSTRING(str)->len - offset < RSTRING(sub)->len) return -1;
-    if (RSTRING(sub)->len == 0) return offset;
-    pos = rb_memsearch(RSTRING(sub)->ptr, RSTRING(sub)->len,
-		       RSTRING(str)->ptr+offset, RSTRING(str)->len-offset);
+    if (RSTRING_LEN(str) - offset < RSTRING_LEN(sub)) return -1;
+    if (RSTRING_LEN(sub) == 0) return offset;
+    pos = rb_memsearch(RSTRING_PTR(sub), RSTRING_LEN(sub),
+		       RSTRING_PTR(str)+offset, RSTRING_LEN(str)-offset);
     if (pos < 0) return pos;
     return pos + offset;
 }
@@ -1083,7 +1167,7 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
 	pos = 0;
     }
     if (pos < 0) {
-	pos += RSTRING(str)->len;
+	pos += RSTRING_LEN(str);
 	if (pos < 0) {
 	    if (TYPE(sub) == T_REGEXP) {
 		rb_backref_set(Qnil);
@@ -1101,8 +1185,8 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
       case T_FIXNUM:
       {
 	  int c = FIX2INT(sub);
-	  long len = RSTRING(str)->len;
-	  char *p = RSTRING(str)->ptr;
+	  long len = RSTRING_LEN(str);
+	  char *p = RSTRING_PTR(str);
 
 	  for (;pos<len;pos++) {
 	      if ((unsigned char)p[pos] == c) return LONG2NUM(pos);
@@ -1133,21 +1217,21 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str)
 static long
 rb_str_rindex(VALUE str, VALUE sub, long pos)
 {
-    long len = RSTRING(sub)->len;
+    long len = RSTRING_LEN(sub);
     char *s, *sbeg, *t;
 
     /* substring longer than string */
-    if (RSTRING(str)->len < len) return -1;
-    if (RSTRING(str)->len - pos < len) {
-	pos = RSTRING(str)->len - len;
+    if (RSTRING_LEN(str) < len) return -1;
+    if (RSTRING_LEN(str) - pos < len) {
+	pos = RSTRING_LEN(str) - len;
     }
-    sbeg = RSTRING(str)->ptr;
-    s = RSTRING(str)->ptr + pos;
-    t = RSTRING(sub)->ptr;
+    sbeg = RSTRING_PTR(str);
+    s = RSTRING_PTR(str) + pos;
+    t = RSTRING_PTR(sub);
     if (len) {
 	while (sbeg <= s) {
 	    if (rb_memcmp(s, t, len) == 0) {
-		return s - RSTRING(str)->ptr;
+		return s - RSTRING_PTR(str);
 	    }
 	    s--;
 	}
@@ -1188,7 +1272,7 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
     if (rb_scan_args(argc, argv, "11", &sub, &position) == 2) {
 	pos = NUM2LONG(position);
 	if (pos < 0) {
-	    pos += RSTRING(str)->len;
+	    pos += RSTRING_LEN(str);
 	    if (pos < 0) {
 		if (TYPE(sub) == T_REGEXP) {
 		    rb_backref_set(Qnil);
@@ -1196,10 +1280,10 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
 		return Qnil;
 	    }
 	}
-	if (pos > RSTRING(str)->len) pos = RSTRING(str)->len;
+	if (pos > RSTRING_LEN(str)) pos = RSTRING_LEN(str);
     }
     else {
-	pos = RSTRING(str)->len;
+	pos = RSTRING_LEN(str);
     }
 
     switch (TYPE(sub)) {
@@ -1219,16 +1303,16 @@ rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
       case T_FIXNUM:
       {
 	  int c = FIX2INT(sub);
-	  char *p = RSTRING(str)->ptr + pos;
-	  char *pbeg = RSTRING(str)->ptr;
+	  char *p = RSTRING_PTR(str) + pos;
+	  char *pbeg = RSTRING_PTR(str);
 
-	  if (pos == RSTRING(str)->len) {
+	  if (pos == RSTRING_LEN(str)) {
 	      if (pos == 0) return Qnil;
 	      --p;
 	  }
 	  while (pbeg <= p) {
 	      if ((unsigned char)*p == c)
-		  return LONG2NUM((char*)p - RSTRING(str)->ptr);
+		  return LONG2NUM((char*)p - RSTRING_PTR(str));
 	      p--;
 	  }
 	  return Qnil;
@@ -1358,11 +1442,11 @@ rb_str_succ(VALUE orig)
     int c = -1;
     long n = 0;
 
-    str = rb_str_new5(orig, RSTRING(orig)->ptr, RSTRING(orig)->len);
+    str = rb_str_new5(orig, RSTRING_PTR(orig), RSTRING_LEN(orig));
     OBJ_INFECT(str, orig);
-    if (RSTRING(str)->len == 0) return str;
+    if (RSTRING_LEN(str) == 0) return str;
 
-    sbeg = RSTRING(str)->ptr; s = sbeg + RSTRING(str)->len - 1;
+    sbeg = RSTRING_PTR(str); s = sbeg + RSTRING_LEN(str) - 1;
 
     while (sbeg <= s) {
 	if (ISALNUM(*s)) {
@@ -1372,7 +1456,7 @@ rb_str_succ(VALUE orig)
 	s--;
     }
     if (c == -1) {		/* str contains no alnum */
-	sbeg = RSTRING(str)->ptr; s = sbeg + RSTRING(str)->len - 1;
+	sbeg = RSTRING_PTR(str); s = sbeg + RSTRING_LEN(str) - 1;
 	c = '\001';
 	while (sbeg <= s) {
 	    if ((*s += 1) != 0) break;
@@ -1380,12 +1464,12 @@ rb_str_succ(VALUE orig)
 	}
     }
     if (s < sbeg) {
-	RESIZE_CAPA(str, RSTRING(str)->len + 1);
-	s = RSTRING(str)->ptr + n;
-	memmove(s+1, s, RSTRING(str)->len - n);
+	RESIZE_CAPA(str, RSTRING_LEN(str) + 1);
+	s = RSTRING_PTR(str) + n;
+	memmove(s+1, s, RSTRING_LEN(str) - n);
 	*s = c;
-	RSTRING(str)->len += 1;
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	STR_SET_LEN(str, RSTRING_LEN(str) + 1);
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
     }
 
     return str;
@@ -1428,7 +1512,7 @@ rb_str_upto(VALUE beg, VALUE end, int excl)
 	StringValue(current);
 	if (excl && rb_str_equal(current, end)) break;
 	StringValue(current);
-	if (RSTRING(current)->len > RSTRING(end)->len)
+	if (RSTRING_LEN(current) > RSTRING_LEN(end))
 	    break;
     }
 
@@ -1482,9 +1566,9 @@ rb_str_aref(VALUE str, VALUE indx)
 
       num_index:
 	if (idx < 0) {
-	    idx = RSTRING(str)->len + idx;
+	    idx = RSTRING_LEN(str) + idx;
 	}
-	if (idx < 0 || RSTRING(str)->len <= idx) {
+	if (idx < 0 || RSTRING_LEN(str) <= idx) {
 	    return Qnil;
 	}
 	return rb_str_substr(str, idx, 1);
@@ -1503,7 +1587,7 @@ rb_str_aref(VALUE str, VALUE indx)
 	    long beg, len;
 	    VALUE tmp;
 
-	    switch (rb_range_beg_len(indx, &beg, &len, RSTRING(str)->len, 0)) {
+	    switch (rb_range_beg_len(indx, &beg, &len, RSTRING_LEN(str), 0)) {
 	      case Qfalse:
 		break;
 	      case Qnil:
@@ -1591,39 +1675,39 @@ rb_str_splice(VALUE str, long beg, long len, VALUE val)
     StringValue(val);
     rb_str_modify(str);
 
-    if (RSTRING(str)->len < beg) {
+    if (RSTRING_LEN(str) < beg) {
       out_of_range:
 	rb_raise(rb_eIndexError, "index %ld out of string", beg);
     }
     if (beg < 0) {
-	if (-beg > RSTRING(str)->len) {
+	if (-beg > RSTRING_LEN(str)) {
 	    goto out_of_range;
 	}
-	beg += RSTRING(str)->len;
+	beg += RSTRING_LEN(str);
     }
-    if (RSTRING(str)->len < beg + len) {
-	len = RSTRING(str)->len - beg;
+    if (RSTRING_LEN(str) < beg + len) {
+	len = RSTRING_LEN(str) - beg;
     }
 
-    if (len < RSTRING(val)->len) {
+    if (len < RSTRING_LEN(val)) {
 	/* expand string */
-	RESIZE_CAPA(str, RSTRING(str)->len + RSTRING(val)->len - len + 1);
+	RESIZE_CAPA(str, RSTRING_LEN(str) + RSTRING_LEN(val) - len + 1);
     }
 
-    if (RSTRING(val)->len != len) {
-	memmove(RSTRING(str)->ptr + beg + RSTRING(val)->len,
-		RSTRING(str)->ptr + beg + len,
-		RSTRING(str)->len - (beg + len));
+    if (RSTRING_LEN(val) != len) {
+	memmove(RSTRING_PTR(str) + beg + RSTRING_LEN(val),
+		RSTRING_PTR(str) + beg + len,
+		RSTRING_LEN(str) - (beg + len));
     }
-    if (RSTRING(str)->len < beg && len < 0) {
-	MEMZERO(RSTRING(str)->ptr + RSTRING(str)->len, char, -len);
+    if (RSTRING_LEN(str) < beg && len < 0) {
+	MEMZERO(RSTRING_PTR(str) + RSTRING_LEN(str), char, -len);
     }
-    if (RSTRING(val)->len > 0) {
-	memmove(RSTRING(str)->ptr+beg, RSTRING(val)->ptr, RSTRING(val)->len);
+    if (RSTRING_LEN(val) > 0) {
+	memmove(RSTRING_PTR(str)+beg, RSTRING_PTR(val), RSTRING_LEN(val));
     }
-    RSTRING(str)->len += RSTRING(val)->len - len;
-    if (RSTRING(str)->ptr) {
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+    STR_SET_LEN(str, RSTRING_LEN(str) + RSTRING_LEN(val) - len);
+    if (RSTRING_PTR(str)) {
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
     }
     OBJ_INFECT(str, val);
 }
@@ -1673,14 +1757,14 @@ rb_str_aset(VALUE str, VALUE indx, VALUE val)
       case T_FIXNUM:
       num_index:
 	idx = FIX2LONG(indx);
-	if (RSTRING(str)->len <= idx) {
+	if (RSTRING_LEN(str) <= idx) {
 	  out_of_range:
 	    rb_raise(rb_eIndexError, "index %ld out of string", idx);
 	}
 	if (idx < 0) {
-	    if (-idx > RSTRING(str)->len)
+	    if (-idx > RSTRING_LEN(str))
 		goto out_of_range;
-	    idx += RSTRING(str)->len;
+	    idx += RSTRING_LEN(str);
 	}
 	rb_str_splice(str, idx, 1, val);
 	return val;
@@ -1694,14 +1778,14 @@ rb_str_aset(VALUE str, VALUE indx, VALUE val)
 	if (beg < 0) {
 	    rb_raise(rb_eIndexError, "string not matched");
 	}
-	rb_str_splice(str, beg, RSTRING(indx)->len, val);
+	rb_str_splice(str, beg, RSTRING_LEN(indx), val);
 	return val;
 
       default:
 	/* check if indx is Range */
 	{
 	    long beg, len;
-	    if (rb_range_beg_len(indx, &beg, &len, RSTRING(str)->len, 2)) {
+	    if (rb_range_beg_len(indx, &beg, &len, RSTRING_LEN(str), 2)) {
 		rb_str_splice(str, beg, len, val);
 		return val;
 	    }
@@ -1776,7 +1860,7 @@ rb_str_insert(VALUE str, VALUE idx, VALUE str2)
     long pos = NUM2LONG(idx);
 
     if (pos == -1) {
-	pos = RSTRING(str)->len;
+	pos = RSTRING_LEN(str);
     }
     else if (pos < 0) {
 	pos++;
@@ -1895,7 +1979,7 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
 	regs = RMATCH(match)->regs;
 
 	if (iter) {
-	    char *p = RSTRING(str)->ptr; long len = RSTRING(str)->len;
+	    char *p = RSTRING_PTR(str); long len = RSTRING_LEN(str);
 
 	    rb_match_busy(match);
 	    repl = rb_obj_as_string(rb_yield(rb_reg_nth_match(0, match)));
@@ -1908,18 +1992,18 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
 	}
 	if (OBJ_TAINTED(repl)) tainted = 1;
 	plen = END(0) - BEG(0);
-	if (RSTRING(repl)->len > plen) {
-	    RESIZE_CAPA(str, RSTRING(str)->len + RSTRING(repl)->len - plen);
+	if (RSTRING_LEN(repl) > plen) {
+	    RESIZE_CAPA(str, RSTRING_LEN(str) + RSTRING_LEN(repl) - plen);
 	}
-	if (RSTRING(repl)->len != plen) {
-	    memmove(RSTRING(str)->ptr + BEG(0) + RSTRING(repl)->len,
-		    RSTRING(str)->ptr + BEG(0) + plen,
-		    RSTRING(str)->len - BEG(0) - plen);
+	if (RSTRING_LEN(repl) != plen) {
+	    memmove(RSTRING_PTR(str) + BEG(0) + RSTRING_LEN(repl),
+		    RSTRING_PTR(str) + BEG(0) + plen,
+		    RSTRING_LEN(str) - BEG(0) - plen);
 	}
-	memcpy(RSTRING(str)->ptr + BEG(0),
-	       RSTRING(repl)->ptr, RSTRING(repl)->len);
-	RSTRING(str)->len += RSTRING(repl)->len - plen;
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	memcpy(RSTRING_PTR(str) + BEG(0),
+	       RSTRING_PTR(repl), RSTRING_LEN(repl));
+	STR_SET_LEN(str, RSTRING_LEN(str) + RSTRING_LEN(repl) - plen);
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	if (tainted) OBJ_TAINT(str);
 
 	return str;
@@ -2000,12 +2084,12 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
 	return rb_str_dup(str);
     }
 
-    blen = RSTRING(str)->len + 30; /* len + margin */
+    blen = RSTRING_LEN(str) + 30; /* len + margin */
     dest = str_new(0, 0, blen);
-    buf = RSTRING(dest)->ptr;
+    buf = RSTRING_PTR(dest);
     bp = buf;
-    sp = cp = RSTRING(str)->ptr;
-    slen = RSTRING(str)->len;
+    sp = cp = RSTRING_PTR(str);
+    slen = RSTRING_LEN(str);
 
     rb_str_locktmp(dest);
     while (beg >= 0) {
@@ -2026,66 +2110,67 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang)
 	    val = rb_reg_regsub(repl, str, regs, pat);
 	}
 	if (OBJ_TAINTED(val)) tainted = 1;
-	len = (bp - buf) + (beg - offset) + RSTRING(val)->len + 3;
+	len = (bp - buf) + (beg - offset) + RSTRING_LEN(val) + 3;
 	if (blen < len) {
 	    while (blen < len) blen *= 2;
 	    len = bp - buf;
 	    RESIZE_CAPA(dest, blen);
-	    RSTRING(dest)->len = blen;
-	    buf = RSTRING(dest)->ptr;
+	    STR_SET_LEN(dest, blen);
+	    buf = RSTRING_PTR(dest);
 	    bp = buf + len;
 	}
 	len = beg - offset;	/* copy pre-match substr */
 	memcpy(bp, cp, len);
 	bp += len;
-	memcpy(bp, RSTRING(val)->ptr, RSTRING(val)->len);
-	bp += RSTRING(val)->len;
+	memcpy(bp, RSTRING_PTR(val), RSTRING_LEN(val));
+	bp += RSTRING_LEN(val);
 	offset = END(0);
 	if (BEG(0) == END(0)) {
 	    /*
 	     * Always consume at least one character of the input string
 	     * in order to prevent infinite loops.
 	     */
-	    if (RSTRING(str)->len <= END(0)) break;
-	    len = mbclen2(RSTRING(str)->ptr[END(0)], pat);
-	    memcpy(bp, RSTRING(str)->ptr+END(0), len);
+	    if (RSTRING_LEN(str) <= END(0)) break;
+	    len = mbclen2(RSTRING_PTR(str)[END(0)], pat);
+	    memcpy(bp, RSTRING_PTR(str)+END(0), len);
 	    bp += len;
 	    offset = END(0) + len;
 	}
-	cp = RSTRING(str)->ptr + offset;
-	if (offset > RSTRING(str)->len) break;
+	cp = RSTRING_PTR(str) + offset;
+	if (offset > RSTRING_LEN(str)) break;
 	beg = rb_reg_search(pat, str, offset, 0);
     }
-    if (RSTRING(str)->len > offset) {
+    if (RSTRING_LEN(str) > offset) {
 	len = bp - buf;
-	if (blen - len < RSTRING(str)->len - offset) {
-	    blen = len + RSTRING(str)->len - offset;
+	if (blen - len < RSTRING_LEN(str) - offset) {
+	    blen = len + RSTRING_LEN(str) - offset;
 	    RESIZE_CAPA(dest, blen);
-	    buf = RSTRING(dest)->ptr;
+	    buf = RSTRING_PTR(dest);
 	    bp = buf + len;
 	}
-	memcpy(bp, cp, RSTRING(str)->len - offset);
-	bp += RSTRING(str)->len - offset;
+	memcpy(bp, cp, RSTRING_LEN(str) - offset);
+	bp += RSTRING_LEN(str) - offset;
     }
     rb_backref_set(match);
     *bp = '\0';
     rb_str_unlocktmp(dest);
     if (bang) {
-	if (str_independent(str)) {
-	    free(RSTRING(str)->ptr);
+	if (str_independent(str) && !STR_EMBED_P(str)) {
+	    free(RSTRING_PTR(str));
 	}
-	FL_UNSET(str, STR_NOCAPA);
-	RSTRING(str)->ptr = buf;
-	RSTRING(str)->aux.capa = blen;
-	RSTRING(dest)->ptr = 0;
-	RSTRING(dest)->len = 0;
+	STR_SET_NOEMBED(str);
+	STR_UNSET_NOCAPA(str);
+	RSTRING(str)->as.heap.ptr = buf;
+	RSTRING(str)->as.heap.aux.capa = blen;
+	RSTRING(dest)->as.heap.ptr = 0;
+	RSTRING(dest)->as.heap.len = 0;
     }
     else {
 	RBASIC(dest)->klass = rb_obj_class(str);
 	OBJ_INFECT(dest, str);
 	str = dest;
     }
-    RSTRING(str)->len = bp - buf;
+    STR_SET_LEN(str, bp - buf);
 
     if (tainted) OBJ_TAINT(str);
     return str;
@@ -2162,27 +2247,34 @@ rb_str_gsub(int argc, VALUE *argv, VALUE str)
 static VALUE
 rb_str_replace(VALUE str, VALUE str2)
 {
+    long len;
     if (str == str2) return str;
 
     StringValue(str2);
-    if (FL_TEST(str2, ELTS_SHARED)) {
-	if (str_independent(str)) {
-	    free(RSTRING(str)->ptr);
+    len = RSTRING_LEN(str2);
+    if (STR_SHARED_P(str2)) {
+	if (str_independent(str) && !STR_EMBED_P(str)) {
+	    free(RSTRING_PTR(str));
 	}
-	RSTRING(str)->len = RSTRING(str2)->len;
-	RSTRING(str)->ptr = RSTRING(str2)->ptr;
+	STR_SET_NOEMBED(str);
+	RSTRING(str)->as.heap.len = len;
+	RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
 	FL_SET(str, ELTS_SHARED);
 	FL_UNSET(str, STR_ASSOC);
-	RSTRING(str)->aux.shared = RSTRING(str2)->aux.shared;
+	RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared;
+    }
+    else if (STR_ASSOC_P(str2)) {
+	rb_str_modify(str);
+	STR_SET_NOEMBED(str);
+	RSTRING(str)->as.heap.ptr = ALLOC_N(char,len+1);
+	memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), len+1);
+	FL_SET(str, STR_ASSOC);
+	RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared;
     }
     else {
 	rb_str_modify(str);
-	rb_str_resize(str, RSTRING(str2)->len);
-	memcpy(RSTRING(str)->ptr, RSTRING(str2)->ptr, RSTRING(str2)->len);
-	if (FL_TEST(str2, STR_ASSOC)) {
-	    FL_SET(str, STR_ASSOC);
-	    RSTRING(str)->aux.shared = RSTRING(str2)->aux.shared;
-	}
+	rb_str_resize(str, len);
+	memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), len+1);
     }
 
     OBJ_INFECT(str, str2);
@@ -2204,13 +2296,11 @@ rb_str_clear(VALUE str)
 {
     /* rb_str_modify() */	/* no need for str_make_independent */
     if (str_independent(str)) {
-	free(RSTRING(str)->ptr);
+	free(RSTRING_PTR(str));
     }
-    RSTRING(str)->aux.shared = 0;
-    FL_UNSET(str, STR_NOCAPA);
-    FL_SET(str, ELTS_SHARED);
-    RSTRING(str)->ptr = null_str;
-    RSTRING(str)->len = 0;
+    FL_UNSET(str, STR_NOEMBED);
+    STR_SET_EMBED_LEN(str, 0);
+    RSTRING_PTR(str)[0] = 0;
     return str;
 }
 
@@ -2243,10 +2333,10 @@ rb_str_reverse_bang(VALUE str)
     char *s, *e;
     char c;
 
-    if (RSTRING(str)->len > 1) {
+    if (RSTRING_LEN(str) > 1) {
 	rb_str_modify(str);
-	s = RSTRING(str)->ptr;
-	e = s + RSTRING(str)->len - 1;
+	s = RSTRING_PTR(str);
+	e = s + RSTRING_LEN(str) - 1;
 	while (s < e) {
 	    c = *s;
 	    *s++ = *e;
@@ -2272,11 +2362,11 @@ rb_str_reverse(VALUE str)
     VALUE obj;
     char *s, *e, *p;
 
-    if (RSTRING(str)->len <= 1) return rb_str_dup(str);
+    if (RSTRING_LEN(str) <= 1) return rb_str_dup(str);
 
-    obj = rb_str_new5(str, 0, RSTRING(str)->len);
-    s = RSTRING(str)->ptr; e = s + RSTRING(str)->len - 1;
-    p = RSTRING(obj)->ptr;
+    obj = rb_str_new5(str, 0, RSTRING_LEN(str));
+    s = RSTRING_PTR(str); e = s + RSTRING_LEN(str) - 1;
+    p = RSTRING_PTR(obj);
 
     while (e >= s) {
 	*p++ = *e--;
@@ -2306,7 +2396,7 @@ rb_str_include(VALUE str, VALUE arg)
     long i;
 
     if (FIXNUM_P(arg)) {
-	if (memchr(RSTRING(str)->ptr, FIX2INT(arg), RSTRING(str)->len))
+	if (memchr(RSTRING_PTR(str), FIX2INT(arg), RSTRING_LEN(str)))
 	    return Qtrue;
 	return Qfalse;
     }
@@ -2418,7 +2508,7 @@ rb_str_inspect(VALUE str)
     VALUE result = rb_str_buf_new2("\"");
     char s[5];
 
-    p = RSTRING(str)->ptr; pend = p + RSTRING(str)->len;
+    p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
     while (p < pend) {
 	char c = *p++;
 	if (ismbchar(c) && p < pend) {
@@ -2495,7 +2585,7 @@ rb_str_dump(VALUE str)
     VALUE result;
 
     len = 2;			/* "" */
-    p = RSTRING(str)->ptr; pend = p + RSTRING(str)->len;
+    p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
     while (p < pend) {
 	char c = *p++;
 	switch (c) {
@@ -2522,8 +2612,8 @@ rb_str_dump(VALUE str)
     }
 
     result = rb_str_new5(str, 0, len);
-    p = RSTRING(str)->ptr; pend = p + RSTRING(str)->len;
-    q = RSTRING(result)->ptr; qend = q + len;
+    p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
+    q = RSTRING_PTR(result); qend = q + len;
 
     *q++ = '"';
     while (p < pend) {
@@ -2600,7 +2690,7 @@ rb_str_upcase_bang(VALUE str)
     int modify = 0;
 
     rb_str_modify(str);
-    s = RSTRING(str)->ptr; send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str); send = s + RSTRING_LEN(str);
     while (s < send) {
 	if (ismbchar(*s)) {
 	    s+=mbclen(*s) - 1;
@@ -2652,7 +2742,7 @@ rb_str_downcase_bang(VALUE str)
     int modify = 0;
 
     rb_str_modify(str);
-    s = RSTRING(str)->ptr; send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str); send = s + RSTRING_LEN(str);
     while (s < send) {
 	if (ismbchar(*s)) {
 	    s+=mbclen(*s) - 1;
@@ -2709,8 +2799,8 @@ rb_str_capitalize_bang(VALUE str)
     int modify = 0;
 
     rb_str_modify(str);
-    if (RSTRING(str)->len == 0 || !RSTRING(str)->ptr) return Qnil;
-    s = RSTRING(str)->ptr; send = s + RSTRING(str)->len;
+    if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
+    s = RSTRING_PTR(str); send = s + RSTRING_LEN(str);
     if (ISLOWER(*s)) {
 	*s = toupper(*s);
 	modify = 1;
@@ -2765,7 +2855,7 @@ rb_str_swapcase_bang(VALUE str)
     int modify = 0;
 
     rb_str_modify(str);
-    s = RSTRING(str)->ptr; send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str); send = s + RSTRING_LEN(str);
     while (s < send) {
 	if (ismbchar(*s)) {
 	    s+=mbclen(*s) - 1;
@@ -2858,17 +2948,17 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
 
     StringValue(src);
     StringValue(repl);
-    if (RSTRING(str)->len == 0 || !RSTRING(str)->ptr) return Qnil;
-    trsrc.p = RSTRING(src)->ptr; trsrc.pend = trsrc.p + RSTRING(src)->len;
-    if (RSTRING(src)->len >= 2 && RSTRING(src)->ptr[0] == '^') {
+    if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil;
+    trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src);
+    if (RSTRING_LEN(src) >= 2 && RSTRING_PTR(src)[0] == '^') {
 	cflag++;
 	trsrc.p++;
     }
-    if (RSTRING(repl)->len == 0) {
+    if (RSTRING_LEN(repl) == 0) {
 	return rb_str_delete_bang(1, &src, str);
     }
-    trrepl.p = RSTRING(repl)->ptr;
-    trrepl.pend = trrepl.p + RSTRING(repl)->len;
+    trrepl.p = RSTRING_PTR(repl);
+    trrepl.pend = trrepl.p + RSTRING_LEN(repl);
     trsrc.gen = trrepl.gen = 0;
     trsrc.now = trrepl.now = 0;
     trsrc.max = trrepl.max = 0;
@@ -2902,7 +2992,7 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
     }
 
     rb_str_modify(str);
-    s = RSTRING(str)->ptr; send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str); send = s + RSTRING_LEN(str);
     if (sflag) {
 	char *t = s;
 	int c0, last = -1;
@@ -2920,8 +3010,8 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
 		*t++ = c0;
 	    }
 	}
-	if (RSTRING(str)->len > (t - RSTRING(str)->ptr)) {
-	    RSTRING(str)->len = (t - RSTRING(str)->ptr);
+	if (RSTRING_LEN(str) > (t - RSTRING_PTR(str))) {
+	    STR_SET_LEN(str, (t - RSTRING_PTR(str)));
 	    modify = 1;
 	    *t = '\0';
 	}
@@ -2990,9 +3080,9 @@ tr_setup_table(VALUE str, char table[256], int init)
     int i, c;
     int cflag = 0;
 
-    tr.p = RSTRING(str)->ptr; tr.pend = tr.p + RSTRING(str)->len;
+    tr.p = RSTRING_PTR(str); tr.pend = tr.p + RSTRING_LEN(str);
     tr.gen = tr.now = tr.max = 0;
-    if (RSTRING(str)->len > 1 && RSTRING(str)->ptr[0] == '^') {
+    if (RSTRING_LEN(str) > 1 && RSTRING_PTR(str)[0] == '^') {
 	cflag = 1;
 	tr.p++;
     }
@@ -3043,9 +3133,9 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
     }
 
     rb_str_modify(str);
-    s = t = RSTRING(str)->ptr;
-    if (!s || RSTRING(str)->len == 0) return Qnil;
-    send = s + RSTRING(str)->len;
+    s = t = RSTRING_PTR(str);
+    if (!s || RSTRING_LEN(str) == 0) return Qnil;
+    send = s + RSTRING_LEN(str);
     while (s < send) {
 	if (squeez[*s & 0xff])
 	    modify = 1;
@@ -3054,7 +3144,7 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str)
 	s++;
     }
     *t = '\0';
-    RSTRING(str)->len = t - RSTRING(str)->ptr;
+    STR_SET_LEN(str, t - RSTRING_PTR(str));
 
     if (modify) return str;
     return Qnil;
@@ -3117,9 +3207,9 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
     }
 
     rb_str_modify(str);
-    s = t = RSTRING(str)->ptr;
-    if (!s || RSTRING(str)->len == 0) return Qnil;
-    send = s + RSTRING(str)->len;
+    s = t = RSTRING_PTR(str);
+    if (!s || RSTRING_LEN(str) == 0) return Qnil;
+    send = s + RSTRING_LEN(str);
     save = -1;
     while (s < send) {
 	c = *s++ & 0xff;
@@ -3128,8 +3218,8 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
 	}
     }
     *t = '\0';
-    if (t - RSTRING(str)->ptr != RSTRING(str)->len) {
-	RSTRING(str)->len = t - RSTRING(str)->ptr;
+    if (t - RSTRING_PTR(str) != RSTRING_LEN(str)) {
+	STR_SET_LEN(str, t - RSTRING_PTR(str));
 	modify = 1;
     }
 
@@ -3234,9 +3324,9 @@ rb_str_count(int argc, VALUE *argv, VALUE str)
 	init = 0;
     }
 
-    s = RSTRING(str)->ptr;
-    if (!s || RSTRING(str)->len == 0) return INT2FIX(0);
-    send = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str);
+    if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0);
+    send = s + RSTRING_LEN(str);
     i = 0;
     while (s < send) {
 	if (table[*s++ & 0xff]) {
@@ -3303,7 +3393,7 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
 	lim = NUM2INT(limit);
 	if (lim <= 0) limit = Qnil;
 	else if (lim == 1) {
-	    if (RSTRING(str)->len == 0)
+	    if (RSTRING_LEN(str) == 0)
 		return rb_ary_new2(0);
 	    return rb_ary_new3(1, str);
 	}
@@ -3319,8 +3409,8 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
     }
     else {
       fs_set:
-	if (TYPE(spat) == T_STRING && RSTRING(spat)->len == 1) {
-	    if (RSTRING(spat)->ptr[0] == ' ') {
+	if (TYPE(spat) == T_STRING && RSTRING_LEN(spat) == 1) {
+	    if (RSTRING_PTR(spat)[0] == ' ') {
 		awk_split = Qtrue;
 	    }
 	    else {
@@ -3335,8 +3425,8 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
     result = rb_ary_new();
     beg = 0;
     if (awk_split) {
-	char *ptr = RSTRING(str)->ptr;
-	long len = RSTRING(str)->len;
+	char *ptr = RSTRING_PTR(str);
+	long len = RSTRING_LEN(str);
 	char *eptr = ptr + len;
 	int skip = 1;
 
@@ -3373,16 +3463,16 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
 	while ((end = rb_reg_search(spat, str, start, 0)) >= 0) {
 	    regs = RMATCH(rb_backref_get())->regs;
 	    if (start == end && BEG(0) == END(0)) {
-		if (!RSTRING(str)->ptr) {
+		if (!RSTRING_PTR(str)) {
 		    rb_ary_push(result, rb_str_new("", 0));
 		    break;
 		}
 		else if (last_null == 1) {
-		    rb_ary_push(result, rb_str_substr(str, beg, mbclen2(RSTRING(str)->ptr[beg],spat)));
+		    rb_ary_push(result, rb_str_substr(str, beg, mbclen2(RSTRING_PTR(str)[beg],spat)));
 		    beg = start;
 		}
 		else {
-		    start += mbclen2(RSTRING(str)->ptr[start],spat);
+		    start += mbclen2(RSTRING_PTR(str)[start],spat);
 		    last_null = 1;
 		    continue;
 		}
@@ -3404,16 +3494,16 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str)
 	    if (!NIL_P(limit) && lim <= ++i) break;
 	}
     }
-    if (RSTRING(str)->len > 0 && (!NIL_P(limit) || RSTRING(str)->len > beg || lim < 0)) {
-	if (RSTRING(str)->len == beg)
+    if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
+	if (RSTRING_LEN(str) == beg)
 	    tmp = rb_str_new5(str, 0, 0);
 	else
-	    tmp = rb_str_substr(str, beg, RSTRING(str)->len-beg);
+	    tmp = rb_str_substr(str, beg, RSTRING_LEN(str)-beg);
 	rb_ary_push(result, tmp);
     }
     if (NIL_P(limit) && lim == 0) {
 	while (RARRAY(result)->len > 0 &&
-	       RSTRING(RARRAY(result)->ptr[RARRAY(result)->len-1])->len == 0)
+	       RSTRING_LEN(RARRAY(result)->ptr[RARRAY(result)->len-1]) == 0)
 	    rb_ary_pop(result);
     }
 
@@ -3468,9 +3558,9 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
 {
     VALUE rs;
     int newline;
-    char *p = RSTRING(str)->ptr, *pend = p + RSTRING(str)->len, *s;
+    char *p = RSTRING_PTR(str), *pend = p + RSTRING_LEN(str), *s;
     char *ptr = p;
-    long len = RSTRING(str)->len, rslen;
+    long len = RSTRING_LEN(str), rslen;
     VALUE line;
 
     if (rb_scan_args(argc, argv, "01", &rs) == 0) {
@@ -3484,12 +3574,12 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
 	return str;
     }
     StringValue(rs);
-    rslen = RSTRING(rs)->len;
+    rslen = RSTRING_LEN(rs);
     if (rslen == 0) {
 	newline = '\n';
     }
     else {
-	newline = RSTRING(rs)->ptr[rslen-1];
+	newline = RSTRING_PTR(rs)[rslen-1];
     }
 
     for (s = p, p += rslen; p < pend; p++) {
@@ -3497,9 +3587,9 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str)
 	    if (*++p != '\n') continue;
 	    while (*p == '\n') p++;
 	}
-	if (RSTRING(str)->ptr < p && p[-1] == newline &&
+	if (RSTRING_PTR(str) < p && p[-1] == newline &&
 	    (rslen <= 1 ||
-	     rb_memcmp(RSTRING(rs)->ptr, p-rslen, rslen) == 0)) {
+	     rb_memcmp(RSTRING_PTR(rs), p-rslen, rslen) == 0)) {
 	    line = rb_str_new5(str, s, p - s);
 	    OBJ_INFECT(line, str);
 	    rb_yield(line);
@@ -3538,8 +3628,8 @@ rb_str_each_byte(VALUE str)
     long i;
 
     RETURN_ENUMERATOR(str, 0, 0);
-    for (i=0; i<RSTRING(str)->len; i++) {
-	rb_yield(INT2FIX(RSTRING(str)->ptr[i] & 0xff));
+    for (i=0; i<RSTRING_LEN(str); i++) {
+	rb_yield(INT2FIX(RSTRING_PTR(str)[i] & 0xff));
     }
     return str;
 }
@@ -3557,16 +3647,16 @@ rb_str_each_byte(VALUE str)
 static VALUE
 rb_str_chop_bang(VALUE str)
 {
-    if (RSTRING(str)->len > 0) {
+    if (RSTRING_LEN(str) > 0) {
 	rb_str_modify(str);
-	RSTRING(str)->len--;
-	if (RSTRING(str)->ptr[RSTRING(str)->len] == '\n') {
-	    if (RSTRING(str)->len > 0 &&
-		RSTRING(str)->ptr[RSTRING(str)->len-1] == '\r') {
-		RSTRING(str)->len--;
+	STR_DEC_LEN(str);
+	if (RSTRING_PTR(str)[RSTRING_LEN(str)] == '\n') {
+	    if (RSTRING_LEN(str) > 0 &&
+		RSTRING_PTR(str)[RSTRING_LEN(str)-1] == '\r') {
+		STR_DEC_LEN(str);
 	    }
 	}
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	return str;
     }
     return Qnil;
@@ -3616,61 +3706,61 @@ rb_str_chomp_bang(int argc, VALUE *argv, VALUE str)
     long len, rslen;
 
     if (rb_scan_args(argc, argv, "01", &rs) == 0) {
-	len = RSTRING(str)->len;
+	len = RSTRING_LEN(str);
 	if (len == 0) return Qnil;
-	p = RSTRING(str)->ptr;
+	p = RSTRING_PTR(str);
 	rs = rb_rs;
 	if (rs == rb_default_rs) {
 	  smart_chomp:
 	    rb_str_modify(str);
-	    if (RSTRING(str)->ptr[len-1] == '\n') {
-		RSTRING(str)->len--;
-		if (RSTRING(str)->len > 0 &&
-		    RSTRING(str)->ptr[RSTRING(str)->len-1] == '\r') {
-		    RSTRING(str)->len--;
+	    if (RSTRING_PTR(str)[len-1] == '\n') {
+		STR_DEC_LEN(str);
+		if (RSTRING_LEN(str) > 0 &&
+		    RSTRING_PTR(str)[RSTRING_LEN(str)-1] == '\r') {
+		    STR_DEC_LEN(str);
 		}
 	    }
-	    else if (RSTRING(str)->ptr[len-1] == '\r') {
-		RSTRING(str)->len--;
+	    else if (RSTRING_PTR(str)[len-1] == '\r') {
+		STR_DEC_LEN(str);
 	    }
 	    else {
 		return Qnil;
 	    }
-	    RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	    RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	    return str;
 	}
     }
     if (NIL_P(rs)) return Qnil;
     StringValue(rs);
-    len = RSTRING(str)->len;
+    len = RSTRING_LEN(str);
     if (len == 0) return Qnil;
-    p = RSTRING(str)->ptr;
-    rslen = RSTRING(rs)->len;
+    p = RSTRING_PTR(str);
+    rslen = RSTRING_LEN(rs);
     if (rslen == 0) {
 	while (len>0 && p[len-1] == '\n') {
 	    len--;
 	    if (len>0 && p[len-1] == '\r')
 		len--;
 	}
-	if (len < RSTRING(str)->len) {
+	if (len < RSTRING_LEN(str)) {
 	    rb_str_modify(str);
-	    RSTRING(str)->len = len;
-	    RSTRING(str)->ptr[len] = '\0';
+	    STR_SET_LEN(str, len);
+	    RSTRING_PTR(str)[len] = '\0';
 	    return str;
 	}
 	return Qnil;
     }
     if (rslen > len) return Qnil;
-    newline = RSTRING(rs)->ptr[rslen-1];
+    newline = RSTRING_PTR(rs)[rslen-1];
     if (rslen == 1 && newline == '\n')
 	goto smart_chomp;
 
     if (p[len-1] == newline &&
 	(rslen <= 1 ||
-	 rb_memcmp(RSTRING(rs)->ptr, p+len-rslen, rslen) == 0)) {
+	 rb_memcmp(RSTRING_PTR(rs), p+len-rslen, rslen) == 0)) {
 	rb_str_modify(str);
-	RSTRING(str)->len -= rslen;
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	STR_SET_LEN(str, RSTRING_LEN(str) - rslen);
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	return str;
     }
     return Qnil;
@@ -3721,17 +3811,17 @@ rb_str_lstrip_bang(VALUE str)
 {
     char *s, *t, *e;
 
-    s = RSTRING(str)->ptr;
-    if (!s || RSTRING(str)->len == 0) return Qnil;
-    e = t = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str);
+    if (!s || RSTRING_LEN(str) == 0) return Qnil;
+    e = t = s + RSTRING_LEN(str);
     /* remove spaces at head */
     while (s < t && ISSPACE(*s)) s++;
 
-    if (s > RSTRING(str)->ptr) {
+    if (s > RSTRING_PTR(str)) {
 	rb_str_modify(str);
-	RSTRING(str)->len = t-s;
-	memmove(RSTRING(str)->ptr, s, RSTRING(str)->len);
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	STR_SET_LEN(str, t-s);
+	memmove(RSTRING_PTR(str), s, RSTRING_LEN(str));
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	return str;
     }
     return Qnil;
@@ -3775,9 +3865,9 @@ rb_str_rstrip_bang(VALUE str)
 {
     char *s, *t, *e;
 
-    s = RSTRING(str)->ptr;
-    if (!s || RSTRING(str)->len == 0) return Qnil;
-    e = t = s + RSTRING(str)->len;
+    s = RSTRING_PTR(str);
+    if (!s || RSTRING_LEN(str) == 0) return Qnil;
+    e = t = s + RSTRING_LEN(str);
 
     /* remove trailing '\0's */
     while (s < t && t[-1] == '\0') t--;
@@ -3787,8 +3877,8 @@ rb_str_rstrip_bang(VALUE str)
 
     if (t < e) {
 	rb_str_modify(str);
-	RSTRING(str)->len = t-s;
-	RSTRING(str)->ptr[RSTRING(str)->len] = '\0';
+	STR_SET_LEN(str, t-s);
+	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	return str;
     }
     return Qnil;
@@ -3866,8 +3956,8 @@ scan_once(VALUE str, VALUE pat, long *start)
 	    /*
 	     * Always consume at least one character of the input string
 	     */
-	    if (RSTRING(str)->len > END(0))
-		*start = END(0)+mbclen2(RSTRING(str)->ptr[END(0)],pat);
+	    if (RSTRING_LEN(str) > END(0))
+		*start = END(0)+mbclen2(RSTRING_PTR(str)[END(0)],pat);
 	    else
 		*start = END(0)+1;
 	}
@@ -3925,7 +4015,7 @@ rb_str_scan(VALUE str, VALUE pat)
     VALUE result;
     long start = 0;
     VALUE match = Qnil;
-    char *p = RSTRING(str)->ptr; long len = RSTRING(str)->len;
+    char *p = RSTRING_PTR(str); long len = RSTRING_LEN(str);
 
     pat = get_pat(pat, 1);
     if (!rb_block_given_p()) {
@@ -4011,12 +4101,12 @@ rb_str_crypt(VALUE str, VALUE salt)
     const char *s;
 
     StringValue(salt);
-    if (RSTRING(salt)->len < 2)
+    if (RSTRING_LEN(salt) < 2)
 	rb_raise(rb_eArgError, "salt too short (need >=2 bytes)");
 
-    if (RSTRING(str)->ptr) s = RSTRING(str)->ptr;
+    if (RSTRING_PTR(str)) s = RSTRING_PTR(str);
     else s = "";
-    result = rb_str_new2(crypt(s, RSTRING(salt)->ptr));
+    result = rb_str_new2(crypt(s, RSTRING_PTR(salt)));
     OBJ_INFECT(result, str);
     OBJ_INFECT(result, salt);
     return result;
@@ -4049,12 +4139,12 @@ rb_str_intern(VALUE s)
     volatile VALUE str = s;
     ID id;
 
-    if (!RSTRING(str)->ptr || RSTRING(str)->len == 0) {
+    if (!RSTRING_PTR(str) || RSTRING_LEN(str) == 0) {
 	rb_raise(rb_eArgError, "interning empty string");
     }
-    if (strlen(RSTRING(str)->ptr) != RSTRING(str)->len)
+    if (strlen(RSTRING_PTR(str)) != RSTRING_LEN(str))
 	rb_raise(rb_eArgError, "symbol string may not contain `\\0'");
-    id = rb_intern(RSTRING(str)->ptr);
+    id = rb_intern(RSTRING_PTR(str));
     return ID2SYM(id);
 }
 
@@ -4073,12 +4163,12 @@ rb_str_ord(VALUE s)
 {
     int c;
 
-    if (RSTRING(s)->len != 1) {
+    if (RSTRING_LEN(s) != 1) {
 	rb_raise(rb_eTypeError,
 		 "expacted a characer, but string of size %d given",
-		 RSTRING(s)->len);
+		 RSTRING_LEN(s));
     }
-    c = RSTRING(s)->ptr[0] & 0xff;
+    c = RSTRING_PTR(s)[0] & 0xff;
     return INT2NUM(c);
 }
 /*
@@ -4105,8 +4195,8 @@ rb_str_sum(int argc, VALUE *argv, VALUE str)
     }
     else bits = NUM2INT(vbits);
 
-    ptr = p = RSTRING(str)->ptr;
-    len = RSTRING(str)->len;
+    ptr = p = RSTRING_PTR(str);
+    len = RSTRING_LEN(str);
     pend = p + len;
     if (bits >= sizeof(long)*CHAR_BIT) {
 	VALUE sum = INT2FIX(0);
@@ -4154,17 +4244,17 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
     width = NUM2LONG(w);
     if (argc == 2) {
 	StringValue(pad);
-	f = RSTRING(pad)->ptr;
-	flen = RSTRING(pad)->len;
+	f = RSTRING_PTR(pad);
+	flen = RSTRING_LEN(pad);
 	if (flen == 0) {
 	    rb_raise(rb_eArgError, "zero width padding");
 	}
     }
-    if (width < 0 || RSTRING(str)->len >= width) return rb_str_dup(str);
+    if (width < 0 || RSTRING_LEN(str) >= width) return rb_str_dup(str);
     res = rb_str_new5(str, 0, width);
-    p = RSTRING(res)->ptr;
+    p = RSTRING_PTR(res);
     if (jflag != 'l') {
-	n = width - RSTRING(str)->len;
+	n = width - RSTRING_LEN(str);
 	pend = p + ((jflag == 'r') ? n : n/2);
 	if (flen <= 1) {
 	    while (p < pend) {
@@ -4182,9 +4272,9 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
 	    }
 	}
     }
-    memcpy(p, RSTRING(str)->ptr, RSTRING(str)->len);
+    memcpy(p, RSTRING_PTR(str), RSTRING_LEN(str)+1);
     if (jflag != 'r') {
-	p += RSTRING(str)->len; pend = RSTRING(res)->ptr + width;
+	p += RSTRING_LEN(str); pend = RSTRING_PTR(res) + width;
 	if (flen <= 1) {
 	    while (p < pend) {
 		*p++ = *f;
diff --git a/time.c b/time.c
index d8d01b1cf2..0f178a78eb 100644
--- a/time.c
+++ b/time.c
@@ -326,14 +326,14 @@ time_arg(int argc, VALUE *argv, struct tm *tm, time_t *usec)
 	if (!NIL_P(s)) {
 	    tm->tm_mon = -1;
 	    for (i=0; i<12; i++) {
-		if (RSTRING(s)->len == 3 &&
-		    strcasecmp(months[i], RSTRING(v[1])->ptr) == 0) {
+		if (RSTRING_LEN(s) == 3 &&
+		    strcasecmp(months[i], RSTRING_PTR(v[1])) == 0) {
 		    tm->tm_mon = i;
 		    break;
 		}
 	    }
 	    if (tm->tm_mon == -1) {
-		char c = RSTRING(s)->ptr[0];
+		char c = RSTRING_PTR(s)[0];
 
 		if ('0' <= c && c <= '9') {
 		    tm->tm_mon = obj2long(s)-1;
@@ -1873,8 +1873,8 @@ time_strftime(VALUE time, VALUE format)
     }
     StringValue(format);
     format = rb_str_new4(format);
-    fmt = RSTRING(format)->ptr;
-    len = RSTRING(format)->len;
+    fmt = RSTRING_PTR(format);
+    len = RSTRING_LEN(format);
     if (len == 0) {
 	rb_warning("strftime called with empty format string");
     }
@@ -1897,7 +1897,7 @@ time_strftime(VALUE time, VALUE format)
 	return str;
     }
     else {
-	len = rb_strftime(&buf, RSTRING(format)->ptr, &tobj->tm);
+	len = rb_strftime(&buf, RSTRING_PTR(format), &tobj->tm);
     }
     str = rb_str_new(buf, len);
     if (buf != buffer) free(buf);
@@ -1997,8 +1997,8 @@ time_mload(VALUE time, VALUE str)
 
     time_modify(time);
     StringValue(str);
-    buf = (unsigned char *)RSTRING(str)->ptr;
-    if (RSTRING(str)->len != 8) {
+    buf = (unsigned char *)RSTRING_PTR(str);
+    if (RSTRING_LEN(str) != 8) {
 	rb_raise(rb_eTypeError, "marshaled time format differ");
     }
 
diff --git a/variable.c b/variable.c
index 2374e3fe70..47ef4dd54a 100644
--- a/variable.c
+++ b/variable.c
@@ -235,7 +235,7 @@ rb_path2class(const char *path)
 
 	while (*p && *p != ':') p++;
 	str = rb_str_new(pbeg, p-pbeg);
-	id = rb_intern(RSTRING(str)->ptr);
+	id = rb_intern(RSTRING_PTR(str));
 	if (p[0] == ':') {
 	    if (p[1] != ':') goto undefined_class;
 	    p += 2;
@@ -273,7 +273,7 @@ rb_class_name(VALUE klass)
 char *
 rb_class2name(VALUE klass)
 {
-    return RSTRING(rb_class_name(klass))->ptr;
+    return RSTRING_PTR(rb_class_name(klass));
 }
 
 char *
@@ -1155,7 +1155,7 @@ check_autoload_table(VALUE av)
     Check_Type(av, T_DATA);
     if (RDATA(av)->dmark != (RUBY_DATA_FUNC)rb_mark_tbl ||
 	RDATA(av)->dfree != (RUBY_DATA_FUNC)st_free_table) {
-	rb_raise(rb_eTypeError, "wrong autoload table: %s", RSTRING(rb_inspect(av))->ptr);
+	rb_raise(rb_eTypeError, "wrong autoload table: %s", RSTRING_PTR(rb_inspect(av)));
     }
     return (struct st_table *)DATA_PTR(av);
 }
@@ -1223,7 +1223,7 @@ rb_autoload_load(VALUE klass, ID id)
     VALUE file;
     NODE *load = autoload_delete(klass, id);
 
-    if (!load || !(file = load->nd_lit) || rb_provided(RSTRING(file)->ptr)) {
+    if (!load || !(file = load->nd_lit) || rb_provided(RSTRING_PTR(file))) {
 	return Qfalse;
     }
     return rb_require_safe(file, load->nd_nth);
@@ -1242,10 +1242,10 @@ autoload_file(VALUE mod, ID id)
     }
     file = ((NODE *)load)->nd_lit;
     Check_Type(file, T_STRING);
-    if (!RSTRING(file)->ptr) {
+    if (!RSTRING_PTR(file)) {
 	rb_raise(rb_eArgError, "empty file name");
     }
-    if (!rb_provided(RSTRING(file)->ptr)) {
+    if (!rb_provided(RSTRING_PTR(file))) {
 	return file;
     }