summaryrefslogtreecommitdiffhomepage
path: root/src/string.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/string.c')
-rw-r--r--src/string.c304
1 files changed, 162 insertions, 142 deletions
diff --git a/src/string.c b/src/string.c
index ad3ef2c70..2daac1f54 100644
--- a/src/string.c
+++ b/src/string.c
@@ -16,6 +16,12 @@
#include "mruby/string.h"
#include "re.h"
+#define STR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
+#define STR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
+#define STR_UNSET_EMBED_FLAG(s) ((s)->flags &= ~MRB_STR_EMBED)
+#define STR_EMBED_LEN(s)\
+ (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+
const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
typedef struct mrb_shared_string {
@@ -33,8 +39,20 @@ static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString
static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
#define RESIZE_CAPA(s,capacity) do {\
- s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\
- s->aux.capa = capacity;\
+ if (STR_EMBED_P(s)) {\
+ if (RSTRING_EMBED_LEN_MAX < (capacity)) {\
+ char *const tmp = (char *)mrb_malloc(mrb, (capacity)+1);\
+ const mrb_int len = STR_EMBED_LEN(s);\
+ memcpy(tmp, s->as.ary, len);\
+ STR_UNSET_EMBED_FLAG(s);\
+ s->as.heap.ptr = tmp;\
+ s->as.heap.len = len;\
+ s->as.heap.aux.capa = (capacity);\
+ }\
+ } else {\
+ s->as.heap.ptr = (char *)mrb_realloc(mrb, s->as.heap.ptr, (capacity)+1);\
+ s->as.heap.aux.capa = capacity;\
+ }\
} while(0)
static void
@@ -53,41 +71,41 @@ void
mrb_str_modify(mrb_state *mrb, struct RString *s)
{
if (STR_SHARED_P(s)) {
- mrb_shared_string *shared = s->aux.shared;
+ mrb_shared_string *shared = s->as.heap.aux.shared;
- if (shared->refcnt == 1 && s->ptr == shared->ptr) {
- s->ptr = shared->ptr;
- s->aux.capa = shared->len;
- s->ptr[s->len] = '\0';
+ if (shared->refcnt == 1 && s->as.heap.ptr == shared->ptr) {
+ s->as.heap.ptr = shared->ptr;
+ s->as.heap.aux.capa = shared->len;
+ s->as.heap.ptr[s->as.heap.len] = '\0';
mrb_free(mrb, shared);
}
else {
char *ptr, *p;
mrb_int len;
- p = s->ptr;
- len = s->len;
+ p = s->as.heap.ptr;
+ len = s->as.heap.len;
ptr = (char *)mrb_malloc(mrb, (size_t)len + 1);
if (p) {
memcpy(ptr, p, len);
}
ptr[len] = '\0';
- s->ptr = ptr;
- s->aux.capa = len;
+ s->as.heap.ptr = ptr;
+ s->as.heap.aux.capa = len;
str_decref(mrb, shared);
}
STR_UNSET_SHARED_FLAG(s);
return;
}
if (s->flags & MRB_STR_NOFREE) {
- char *p = s->ptr;
+ char *p = s->as.heap.ptr;
- s->ptr = (char *)mrb_malloc(mrb, (size_t)s->len+1);
+ s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)s->as.heap.len+1);
if (p) {
- memcpy(s->ptr, p, s->len);
+ memcpy(s->as.heap.ptr, p, s->as.heap.len);
}
- s->ptr[s->len] = '\0';
- s->aux.capa = s->len;
+ s->as.heap.ptr[s->as.heap.len] = '\0';
+ s->as.heap.aux.capa = s->as.heap.len;
s->flags &= ~MRB_STR_NOFREE;
return;
}
@@ -100,13 +118,13 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len)
struct RString *s = mrb_str_ptr(str);
mrb_str_modify(mrb, s);
- slen = s->len;
+ slen = s->as.heap.len;
if (len != slen) {
if (slen < len || slen - len > 256) {
RESIZE_CAPA(s, len);
}
- s->len = len;
- s->ptr[len] = '\0'; /* sentinel */
+ s->as.heap.len = len;
+ s->as.heap.ptr[len] = '\0'; /* sentinel */
}
return str;
}
@@ -126,13 +144,13 @@ str_new(mrb_state *mrb, const char *p, mrb_int len)
struct RString *s;
s = mrb_obj_alloc_string(mrb);
- s->len = len;
- s->aux.capa = len;
- s->ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
+ s->as.heap.len = len;
+ s->as.heap.aux.capa = len;
+ s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
if (p) {
- memcpy(s->ptr, p, len);
+ memcpy(s->as.heap.ptr, p, len);
}
- s->ptr[len] = '\0';
+ s->as.heap.ptr[len] = '\0';
return s;
}
@@ -165,10 +183,10 @@ mrb_str_buf_new(mrb_state *mrb, mrb_int capa)
if (capa < MRB_STR_BUF_MIN_SIZE) {
capa = MRB_STR_BUF_MIN_SIZE;
}
- s->len = 0;
- s->aux.capa = capa;
- s->ptr = (char *)mrb_malloc(mrb, capa+1);
- s->ptr[0] = '\0';
+ s->as.heap.len = 0;
+ s->as.heap.aux.capa = capa;
+ s->as.heap.ptr = (char *)mrb_malloc(mrb, capa+1);
+ s->as.heap.ptr[0] = '\0';
return mrb_obj_value(s);
}
@@ -181,15 +199,15 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
ptrdiff_t off = -1;
mrb_str_modify(mrb, s);
- if (ptr >= s->ptr && ptr <= s->ptr + s->len) {
- off = ptr - s->ptr;
+ if (ptr >= s->as.heap.ptr && ptr <= s->as.heap.ptr + s->as.heap.len) {
+ off = ptr - s->as.heap.ptr;
}
if (len == 0) return;
- capa = s->aux.capa;
- if (s->len >= MRB_INT_MAX - (mrb_int)len) {
+ capa = s->as.heap.aux.capa;
+ if (s->as.heap.len >= MRB_INT_MAX - (mrb_int)len) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big");
}
- total = s->len+len;
+ total = s->as.heap.len+len;
if (capa <= total) {
while (total > capa) {
if (capa + 1 >= MRB_INT_MAX / 2) {
@@ -201,11 +219,11 @@ str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, size_t len)
RESIZE_CAPA(s, capa);
}
if (off != -1) {
- ptr = s->ptr + off;
+ ptr = s->as.heap.ptr + off;
}
- memcpy(s->ptr + s->len, ptr, len);
- s->len = total;
- s->ptr[total] = '\0'; /* sentinel */
+ memcpy(s->as.heap.ptr + s->as.heap.len, ptr, len);
+ s->as.heap.len = total;
+ s->as.heap.ptr[total] = '\0'; /* sentinel */
}
mrb_value
@@ -265,9 +283,9 @@ mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
}
s = mrb_obj_alloc_string(mrb);
- s->len = len;
- s->aux.capa = 0; /* nofree */
- s->ptr = (char *)p;
+ s->as.heap.len = len;
+ s->as.heap.aux.capa = 0; /* nofree */
+ s->as.heap.ptr = (char *)p;
s->flags = MRB_STR_NOFREE;
return mrb_obj_value(s);
}
@@ -275,10 +293,12 @@ mrb_str_new_static(mrb_state *mrb, const char *p, size_t len)
void
mrb_gc_free_str(mrb_state *mrb, struct RString *str)
{
- if (STR_SHARED_P(str))
- str_decref(mrb, str->aux.shared);
+ if (STR_EMBED_P(str))
+ /* no code */;
+ else if (STR_SHARED_P(str))
+ str_decref(mrb, str->as.heap.aux.shared);
else if ((str->flags & MRB_STR_NOFREE) == 0)
- mrb_free(mrb, str->ptr);
+ mrb_free(mrb, str->as.heap.ptr);
}
char *
@@ -291,10 +311,10 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
}
s = str_new(mrb, RSTRING_PTR(str0), RSTRING_LEN(str0));
- if ((strlen(s->ptr) ^ s->len) != 0) {
+ if ((strlen(s->as.heap.ptr) ^ s->as.heap.len) != 0) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
}
- return s->ptr;
+ return s->as.heap.ptr;
}
static void
@@ -306,20 +326,20 @@ str_make_shared(mrb_state *mrb, struct RString *s)
shared->refcnt = 1;
if (s->flags & MRB_STR_NOFREE) {
shared->nofree = TRUE;
- shared->ptr = s->ptr;
+ shared->ptr = s->as.heap.ptr;
s->flags &= ~MRB_STR_NOFREE;
}
else {
shared->nofree = FALSE;
- if (s->aux.capa > s->len) {
- s->ptr = shared->ptr = (char *)mrb_realloc(mrb, s->ptr, s->len+1);
+ if (s->as.heap.aux.capa > s->as.heap.len) {
+ s->as.heap.ptr = shared->ptr = (char *)mrb_realloc(mrb, s->as.heap.ptr, s->as.heap.len+1);
}
else {
- shared->ptr = s->ptr;
+ shared->ptr = s->as.heap.ptr;
}
}
- shared->len = s->len;
- s->aux.shared = shared;
+ shared->len = s->as.heap.len;
+ s->as.heap.aux.shared = shared;
STR_SET_SHARED_FLAG(s);
}
}
@@ -335,8 +355,8 @@ mrb_str_body(mrb_value str, int *len_p)
{
struct RString *s = mrb_str_ptr(str);
- *len_p = s->len;
- return s->ptr;
+ *len_p = s->as.heap.len;
+ return s->as.heap.ptr;
}
/*
@@ -356,15 +376,15 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
other = mrb_str_to_str(mrb, other);
}
s2 = mrb_str_ptr(other);
- len = s1->len + s2->len;
+ len = s1->as.heap.len + s2->as.heap.len;
- if (s1->aux.capa < len) {
- s1->aux.capa = len;
- s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, len+1);
+ if (s1->as.heap.aux.capa < len) {
+ s1->as.heap.aux.capa = len;
+ s1->as.heap.ptr = (char *)mrb_realloc(mrb, s1->as.heap.ptr, len+1);
}
- memcpy(s1->ptr+s1->len, s2->ptr, s2->len);
- s1->len = len;
- s1->ptr[len] = '\0';
+ memcpy(s1->as.heap.ptr+s1->as.heap.len, s2->as.heap.ptr, s2->as.heap.len);
+ s1->as.heap.len = len;
+ s1->as.heap.ptr[len] = '\0';
}
/*
@@ -380,9 +400,9 @@ mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b)
struct RString *s2 = mrb_str_ptr(b);
struct RString *t;
- t = str_new(mrb, 0, s->len + s2->len);
- memcpy(t->ptr, s->ptr, s->len);
- memcpy(t->ptr + s->len, s2->ptr, s2->len);
+ t = str_new(mrb, 0, s->as.heap.len + s2->as.heap.len);
+ memcpy(t->as.heap.ptr, s->as.heap.ptr, s->as.heap.len);
+ memcpy(t->as.heap.ptr + s->as.heap.len, s2->as.heap.ptr, s2->as.heap.len);
return mrb_obj_value(t);
}
@@ -414,7 +434,7 @@ static mrb_value
mrb_str_bytesize(mrb_state *mrb, mrb_value self)
{
struct RString *s = mrb_str_ptr(self);
- return mrb_fixnum_value(s->len);
+ return mrb_fixnum_value(s->as.heap.len);
}
/* 15.2.10.5.26 */
@@ -429,7 +449,7 @@ mrb_value
mrb_str_size(mrb_state *mrb, mrb_value self)
{
struct RString *s = mrb_str_ptr(self);
- return mrb_fixnum_value(s->len);
+ return mrb_fixnum_value(s->as.heap.len);
}
/* 15.2.10.5.1 */
@@ -460,7 +480,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
len = RSTRING_LEN(self)*times;
str2 = str_new(mrb, 0, len);
str_with_class(mrb, str2, self);
- p = str2->ptr;
+ p = str2->as.heap.ptr;
if (len > 0) {
n = RSTRING_LEN(self);
memcpy(p, RSTRING_PTR(self), n);
@@ -470,7 +490,7 @@ mrb_str_times(mrb_state *mrb, mrb_value self)
}
memcpy(p + n, p, len-n);
}
- p[str2->len] = '\0';
+ p[str2->as.heap.len] = '\0';
return mrb_obj_value(str2);
}
@@ -494,11 +514,11 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)
struct RString *s1 = mrb_str_ptr(str1);
struct RString *s2 = mrb_str_ptr(str2);
- len = lesser(s1->len, s2->len);
- retval = memcmp(s1->ptr, s2->ptr, len);
+ len = lesser(s1->as.heap.len, s2->as.heap.len);
+ retval = memcmp(s1->as.heap.ptr, s2->as.heap.ptr, len);
if (retval == 0) {
- if (s1->len == s2->len) return 0;
- if (s1->len > s2->len) return 1;
+ if (s1->as.heap.len == s2->as.heap.len) return 0;
+ if (s1->as.heap.len > s2->as.heap.len) return 1;
return -1;
}
if (retval > 0) return 1;
@@ -724,7 +744,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str)
/* should return shared string */
struct RString *s = mrb_str_ptr(str);
- return mrb_str_new(mrb, s->ptr, s->len);
+ return mrb_str_new(mrb, s->as.heap.ptr, s->as.heap.len);
}
static mrb_value
@@ -853,8 +873,8 @@ mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str)
struct RString *s = mrb_str_ptr(str);
mrb_str_modify(mrb, s);
- if (s->len == 0 || !s->ptr) return mrb_nil_value();
- p = s->ptr; pend = s->ptr + s->len;
+ if (s->as.heap.len == 0 || !s->as.heap.ptr) return mrb_nil_value();
+ p = s->as.heap.ptr; pend = s->as.heap.ptr + s->as.heap.len;
if (ISLOWER(*p)) {
*p = TOUPPER(*p);
modify = 1;
@@ -910,29 +930,29 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
struct RString *s = mrb_str_ptr(str);
mrb_str_modify(mrb, s);
- len = s->len;
+ len = s->as.heap.len;
if (mrb_get_args(mrb, "|S", &rs) == 0) {
if (len == 0) return mrb_nil_value();
smart_chomp:
- if (s->ptr[len-1] == '\n') {
- s->len--;
- if (s->len > 0 &&
- s->ptr[s->len-1] == '\r') {
- s->len--;
+ if (s->as.heap.ptr[len-1] == '\n') {
+ s->as.heap.len--;
+ if (s->as.heap.len > 0 &&
+ s->as.heap.ptr[s->as.heap.len-1] == '\r') {
+ s->as.heap.len--;
}
}
- else if (s->ptr[len-1] == '\r') {
- s->len--;
+ else if (s->as.heap.ptr[len-1] == '\r') {
+ s->as.heap.len--;
}
else {
return mrb_nil_value();
}
- s->ptr[s->len] = '\0';
+ s->as.heap.ptr[s->as.heap.len] = '\0';
return str;
}
if (len == 0 || mrb_nil_p(rs)) return mrb_nil_value();
- p = s->ptr;
+ p = s->as.heap.ptr;
rslen = RSTRING_LEN(rs);
if (rslen == 0) {
while (len>0 && p[len-1] == '\n') {
@@ -940,8 +960,8 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
if (len>0 && p[len-1] == '\r')
len--;
}
- if (len < s->len) {
- s->len = len;
+ if (len < s->as.heap.len) {
+ s->as.heap.len = len;
p[len] = '\0';
return str;
}
@@ -958,8 +978,8 @@ mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)
if (p[len-1] == newline &&
(rslen <= 1 ||
memcmp(RSTRING_PTR(rs), pp, rslen) == 0)) {
- s->len = len - rslen;
- p[s->len] = '\0';
+ s->as.heap.len = len - rslen;
+ p[s->as.heap.len] = '\0';
return str;
}
return mrb_nil_value();
@@ -1009,17 +1029,17 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str)
struct RString *s = mrb_str_ptr(str);
mrb_str_modify(mrb, s);
- if (s->len > 0) {
+ if (s->as.heap.len > 0) {
int len;
- len = s->len - 1;
- if (s->ptr[len] == '\n') {
+ len = s->as.heap.len - 1;
+ if (s->as.heap.ptr[len] == '\n') {
if (len > 0 &&
- s->ptr[len-1] == '\r') {
+ s->as.heap.ptr[len-1] == '\r') {
len--;
}
}
- s->len = len;
- s->ptr[len] = '\0';
+ s->as.heap.len = len;
+ s->as.heap.ptr[len] = '\0';
return str;
}
return mrb_nil_value();
@@ -1067,8 +1087,8 @@ mrb_str_downcase_bang(mrb_state *mrb, mrb_value str)
struct RString *s = mrb_str_ptr(str);
mrb_str_modify(mrb, s);
- p = s->ptr;
- pend = s->ptr + s->len;
+ p = s->as.heap.ptr;
+ pend = s->as.heap.ptr + s->as.heap.len;
while (p < pend) {
if (ISUPPER(*p)) {
*p = TOLOWER(*p);
@@ -1117,7 +1137,7 @@ mrb_str_empty_p(mrb_state *mrb, mrb_value self)
{
struct RString *s = mrb_str_ptr(self);
- return mrb_bool_value(s->len == 0);
+ return mrb_bool_value(s->as.heap.len == 0);
}
/* 15.2.10.5.17 */
@@ -1147,11 +1167,12 @@ mrb_str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
orig = mrb_str_ptr(str);
str_make_shared(mrb, orig);
- shared = orig->aux.shared;
+ shared = orig->as.heap.aux.shared;
s = mrb_obj_alloc_string(mrb);
- s->ptr = orig->ptr + beg;
- s->len = len;
- s->aux.shared = shared;
+ s->as.heap.ptr = orig->as.heap.ptr + beg;
+ s->as.heap.len = len;
+ s->as.heap.aux.shared = shared;
+ s->flags |= MRB_STR_SHARED;
STR_SET_SHARED_FLAG(s);
shared->refcnt++;
@@ -1194,8 +1215,8 @@ mrb_str_hash(mrb_state *mrb, mrb_value str)
{
/* 1-8-7 */
struct RString *s = mrb_str_ptr(str);
- mrb_int len = s->len;
- char *p = s->ptr;
+ mrb_int len = s->as.heap.len;
+ char *p = s->as.heap.ptr;
mrb_int key = 0;
while (len--) {
@@ -1344,34 +1365,34 @@ str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
if (STR_SHARED_P(s2)) {
L_SHARE:
if (STR_SHARED_P(s1)) {
- str_decref(mrb, s1->aux.shared);
+ str_decref(mrb, s1->as.heap.aux.shared);
}
else {
- mrb_free(mrb, s1->ptr);
+ mrb_free(mrb, s1->as.heap.ptr);
}
- s1->ptr = s2->ptr;
- s1->len = s2->len;
- s1->aux.shared = s2->aux.shared;
+ s1->as.heap.ptr = s2->as.heap.ptr;
+ s1->as.heap.len = s2->as.heap.len;
+ s1->as.heap.aux.shared = s2->as.heap.aux.shared;
STR_SET_SHARED_FLAG(s1);
- s1->aux.shared->refcnt++;
+ s1->as.heap.aux.shared->refcnt++;
}
- else if (s2->len > STR_REPLACE_SHARED_MIN) {
+ else if (s2->as.heap.len > STR_REPLACE_SHARED_MIN) {
str_make_shared(mrb, s2);
goto L_SHARE;
}
else {
if (STR_SHARED_P(s1)) {
- str_decref(mrb, s1->aux.shared);
- STR_UNSET_SHARED_FLAG(s1);
- s1->ptr = (char *)mrb_malloc(mrb, s2->len+1);
+ str_decref(mrb, s1->as.heap.aux.shared);
+ s1->flags &= ~MRB_STR_SHARED;
+ s1->as.heap.ptr = (char *)mrb_malloc(mrb, s2->as.heap.len+1);
}
else {
- s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, s2->len+1);
+ s1->as.heap.ptr = (char *)mrb_realloc(mrb, s1->as.heap.ptr, s2->as.heap.len+1);
}
- memcpy(s1->ptr, s2->ptr, s2->len);
- s1->ptr[s2->len] = 0;
- s1->len = s2->len;
- s1->aux.capa = s2->len;
+ memcpy(s1->as.heap.ptr, s2->as.heap.ptr, s2->as.heap.len);
+ s1->as.heap.ptr[s2->as.heap.len] = 0;
+ s1->as.heap.len = s2->as.heap.len;
+ s1->as.heap.aux.capa = s2->as.heap.len;
}
return mrb_obj_value(s1);
}
@@ -1466,7 +1487,7 @@ mrb_ptr_to_str(mrb_state *mrb, void *p)
uintptr_t n = (uintptr_t)p;
p_str = str_new(mrb, NULL, 2 + sizeof(uintptr_t) * CHAR_BIT / 4);
- p1 = p_str->ptr;
+ p1 = p_str->as.heap.ptr;
*p1++ = '0';
*p1++ = 'x';
p2 = p1;
@@ -1476,7 +1497,7 @@ mrb_ptr_to_str(mrb_state *mrb, void *p)
n /= 16;
} while (n > 0);
*p2 = '\0';
- p_str->len = (mrb_int)(p2 - p_str->ptr);
+ p_str->as.heap.len = (mrb_int)(p2 - p_str->as.heap.ptr);
while (p1 < p2) {
const char c = *p1;
@@ -1515,12 +1536,12 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str)
struct RString *s2;
char *s, *e, *p;
- if (RSTRING(str)->len <= 1) return mrb_str_dup(mrb, str);
+ if (RSTRING_LEN(str) <= 1) return mrb_str_dup(mrb, str);
- s2 = str_new(mrb, 0, RSTRING(str)->len);
+ s2 = str_new(mrb, 0, RSTRING_LEN(str));
str_with_class(mrb, s2, str);
s = RSTRING_PTR(str); e = RSTRING_END(str) - 1;
- p = s2->ptr;
+ p = s2->as.heap.ptr;
while (e >= s) {
*p++ = *e--;
@@ -1543,9 +1564,9 @@ mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
char c;
mrb_str_modify(mrb, s);
- if (s->len > 1) {
- p = s->ptr;
- e = p + s->len - 1;
+ if (s->as.heap.len > 1) {
+ p = s->as.heap.ptr;
+ e = p + s->as.heap.len - 1;
while (p < e) {
c = *p;
*p++ = *e;
@@ -1578,21 +1599,20 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)
{
char *s, *sbeg, *t;
struct RString *ps = mrb_str_ptr(str);
- struct RString *psub = mrb_str_ptr(sub);
- mrb_int len = psub->len;
+ mrb_int len = RSTRING_LEN(sub);
/* substring longer than string */
- if (ps->len < len) return -1;
- if (ps->len - pos < len) {
- pos = ps->len - len;
+ if (ps->as.heap.len < len) return -1;
+ if (ps->as.heap.len - pos < len) {
+ pos = ps->as.heap.len - len;
}
- sbeg = ps->ptr;
- s = ps->ptr + pos;
- t = psub->ptr;
+ sbeg = ps->as.heap.ptr;
+ s = ps->as.heap.ptr + pos;
+ t = RSTRING_PTR(sub);
if (len) {
while (sbeg <= s) {
if (memcmp(s, t, len) == 0) {
- return s - ps->ptr;
+ return s - ps->as.heap.ptr;
}
s--;
}
@@ -2006,9 +2026,9 @@ char *
mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
{
struct RString *ps = mrb_str_ptr(*ptr);
- char *s = ps->ptr;
+ char *s = ps->as.heap.ptr;
- if (!s || ps->len != strlen(s)) {
+ if (!s || ps->as.heap.len != strlen(s)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
}
return s;
@@ -2031,7 +2051,7 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
len = RSTRING_LEN(str);
if (s[len]) { /* no sentinel somehow */
struct RString *temp_str = str_new(mrb, s, len);
- s = temp_str->ptr;
+ s = temp_str->as.heap.ptr;
}
}
return mrb_cstr_to_inum(mrb, s, base, badcheck);
@@ -2161,7 +2181,7 @@ mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck)
}
if (s[len]) { /* no sentinel somehow */
struct RString *temp_str = str_new(mrb, s, len);
- s = temp_str->ptr;
+ s = temp_str->as.heap.ptr;
}
}
return mrb_cstr_to_dbl(mrb, s, badcheck);
@@ -2300,7 +2320,7 @@ mrb_str_dump(mrb_state *mrb, mrb_value str)
result = str_new(mrb, 0, len);
str_with_class(mrb, result, str);
p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
- q = result->ptr;
+ q = result->as.heap.ptr;
*q++ = '"';
while (p < pend) {
@@ -2477,8 +2497,8 @@ static mrb_value
mrb_str_bytes(mrb_state *mrb, mrb_value str)
{
struct RString *s = mrb_str_ptr(str);
- mrb_value a = mrb_ary_new_capa(mrb, s->len);
- unsigned char *p = (unsigned char *)(s->ptr), *pend = p + s->len;
+ mrb_value a = mrb_ary_new_capa(mrb, s->as.heap.len);
+ unsigned char *p = (unsigned char *)(s->as.heap.ptr), *pend = p + s->as.heap.len;
while (p < pend) {
mrb_ary_push(mrb, a, mrb_fixnum_value(p[0]));
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-14 23:53:17 +0000