14#include "ruby/internal/config.h"
24#include "debug_counter.h"
28#include "internal/array.h"
29#include "internal/bits.h"
30#include "internal/compar.h"
31#include "internal/compilers.h"
32#include "internal/concurrent_set.h"
33#include "internal/encoding.h"
34#include "internal/error.h"
35#include "internal/gc.h"
36#include "internal/hash.h"
37#include "internal/numeric.h"
38#include "internal/object.h"
39#include "internal/proc.h"
40#include "internal/re.h"
41#include "internal/sanitizers.h"
42#include "internal/simd.h"
43#include "internal/string.h"
44#include "internal/transcode.h"
51#include "ruby_assert.h"
58#if defined HAVE_CRYPT_R
59# if defined HAVE_CRYPT_H
62#elif !defined HAVE_CRYPT
63# include "missing/crypt.h"
64# define HAVE_CRYPT_R 1
68#undef rb_usascii_str_new
72#undef rb_usascii_str_new_cstr
73#undef rb_utf8_str_new_cstr
74#undef rb_enc_str_new_cstr
75#undef rb_external_str_new_cstr
76#undef rb_locale_str_new_cstr
77#undef rb_str_dup_frozen
78#undef rb_str_buf_new_cstr
129#define RUBY_MAX_CHAR_LEN 16
130#define STR_PRECOMPUTED_HASH FL_USER4
131#define STR_SHARED_ROOT FL_USER5
132#define STR_BORROWED FL_USER6
133#define STR_TMPLOCK FL_USER7
134#define STR_NOFREE FL_USER18
136#define STR_SET_NOEMBED(str) do {\
137 FL_SET((str), STR_NOEMBED);\
138 FL_UNSET((str), STR_SHARED | STR_SHARED_ROOT | STR_BORROWED);\
140#define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED | STR_SHARED | STR_NOFREE)
142#define STR_SET_LEN(str, n) do { \
143 RSTRING(str)->len = (n); \
146#define TERM_LEN(str) (rb_str_enc_fastpath(str) ? 1 : rb_enc_mbminlen(rb_enc_from_index(ENCODING_GET(str))))
147#define TERM_FILL(ptr, termlen) do {\
148 char *const term_fill_ptr = (ptr);\
149 const int term_fill_len = (termlen);\
150 *term_fill_ptr = '\0';\
151 if (UNLIKELY(term_fill_len > 1))\
152 memset(term_fill_ptr, 0, term_fill_len);\
155#define RESIZE_CAPA(str,capacity) do {\
156 const int termlen = TERM_LEN(str);\
157 RESIZE_CAPA_TERM(str,capacity,termlen);\
159#define RESIZE_CAPA_TERM(str,capacity,termlen) do {\
160 if (STR_EMBED_P(str)) {\
161 if (str_embed_capa(str) < capacity + termlen) {\
162 char *const tmp = ALLOC_N(char, (size_t)(capacity) + (termlen));\
163 const rb_len_t tlen = RSTRING_LEN(str);\
164 memcpy(tmp, RSTRING_PTR(str), str_embed_capa(str));\
165 RSTRING(str)->as.heap.ptr = tmp;\
166 RSTRING(str)->len = tlen;\
167 STR_SET_NOEMBED(str);\
168 RSTRING(str)->as.heap.aux.capa = (capacity);\
172 RUBY_ASSERT(!FL_TEST((str), STR_SHARED)); \
173 SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \
174 (size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \
175 RSTRING(str)->as.heap.aux.capa = (capacity);\
179#define STR_SET_SHARED(str, shared_str) do { \
180 if (!FL_TEST(str, STR_FAKESTR)) { \
181 RUBY_ASSERT(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \
182 RUBY_ASSERT(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \
183 RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \
184 FL_SET((str), STR_SHARED); \
185 rb_gc_register_pinning_obj(str); \
186 FL_SET((shared_str), STR_SHARED_ROOT); \
187 if (RBASIC_CLASS((shared_str)) == 0) \
188 FL_SET_RAW((shared_str), STR_BORROWED); \
192#define STR_HEAP_PTR(str) (RSTRING(str)->as.heap.ptr)
193#define STR_HEAP_SIZE(str) ((size_t)RSTRING(str)->as.heap.aux.capa + TERM_LEN(str))
196#define STR_ENC_GET(str) get_encoding(str)
199zero_filled(
const char *s,
int n)
202 if (*s++)
return false;
207#if !defined SHARABLE_MIDDLE_SUBSTRING
208# define SHARABLE_MIDDLE_SUBSTRING 0
214#if SHARABLE_MIDDLE_SUBSTRING
218 rb_len_t source_len = RSTRING_LEN(str);
219 return end == source_len || zero_filled(RSTRING_PTR(str) + end, TERM_LEN(str));
224str_embed_capa(
VALUE str)
226 return rb_obj_shape_slot_size(str) - offsetof(
struct RString, as.
embed.ary);
230rb_str_reembeddable_p(
VALUE str)
232 return !
FL_TEST(str, STR_NOFREE|STR_SHARED_ROOT|STR_SHARED);
238rb_str_embedded_shared_root_p(
VALUE str)
240 return STR_EMBED_P(str) &&
FL_TEST(str, STR_SHARED_ROOT);
252rb_str_size_as_embedded(
VALUE str)
255 if (STR_EMBED_P(str)) {
257 if (
FL_TEST_RAW(str, STR_PRECOMPUTED_HASH))
capa +=
sizeof(st_index_t);
259 real_size = rb_str_embed_size(
capa, TERM_LEN(str));
263 else if (rb_str_reembeddable_p(str)) {
265 if (
FL_TEST_RAW(str, STR_PRECOMPUTED_HASH))
capa +=
sizeof(st_index_t);
267 real_size = rb_str_embed_size(
capa, TERM_LEN(str));
270 real_size =
sizeof(
struct RString);
280 RUBY_ASSERT(termlen > 0,
"non-positive termlen: %" PRIdLEN, termlen);
281 return rb_gc_size_allocatable_p(rb_str_embed_size(
len, termlen));
288#define STR_COPY_MAX_EMBED_SIZE 256
292static VALUE str_new_frozen_buffer(
VALUE klass,
VALUE orig,
int copy_encoding);
296static inline void str_modifiable(
VALUE str);
301str_make_independent(
VALUE str)
304 int termlen = TERM_LEN(str);
305 str_make_independent_expand((str),
len, 0L, termlen);
308static inline int str_dependent_p(
VALUE str);
311rb_str_make_independent(
VALUE str)
313 if (str_dependent_p(str)) {
314 str_make_independent(str);
319rb_str_make_embedded(
VALUE str)
324 int termlen = TERM_LEN(str);
325 char *buf =
RSTRING(str)->as.heap.ptr;
330 STR_SET_LEN(str,
len);
334 SIZED_FREE_N(buf, old_capa);
345rb_str_make_heap(
VALUE str)
347 if (STR_EMBED_P(str)) {
348 const int termlen = TERM_LEN(str);
355rb_debug_rstring_null_ptr(
const char *func)
357 fprintf(stderr,
"%s is returning NULL!! "
358 "SIGSEGV is highly expected to follow immediately.\n"
359 "If you could reproduce, attach your debugger here, "
360 "and look at the passed string.\n",
365static VALUE sym_ascii, sym_turkic, sym_lithuanian, sym_fold;
368get_encoding(
VALUE str)
374rb_str_invalid_byte_sequence(
VALUE str)
376 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str)));
380rb_str_unexpect_wchar(
VALUE str)
382 rb_raise(rb_eArgError,
"wide char encoding: %s", rb_enc_name(STR_ENC_GET(str)));
385static VALUE register_fstring(
VALUE str,
bool copy,
bool force_precompute_hash);
387#if SIZEOF_RB_LEN_T == SIZEOF_VOIDP
388#define PRECOMPUTED_FAKESTR_HASH 1
393BARE_STRING_P(
VALUE str)
398static inline st_index_t
399str_do_hash(
VALUE str)
403 if (e && !is_ascii_string(str)) {
410str_store_precomputed_hash(
VALUE str, st_index_t hash)
416 size_t used_bytes = (
RSTRING_LEN(str) + TERM_LEN(str));
417 size_t free_bytes = str_embed_capa(str) - used_bytes;
421 memcpy(
RSTRING_END(str) + TERM_LEN(str), &hash,
sizeof(hash));
423 FL_SET(str, STR_PRECOMPUTED_HASH);
436 if (
FL_TEST(str, RSTRING_FSTR))
439 bare = BARE_STRING_P(str);
441 if (STR_EMBED_P(str)) {
446 if (
FL_TEST_RAW(str, STR_SHARED_ROOT | STR_SHARED) == STR_SHARED_ROOT) {
455 fstr = register_fstring(str,
false,
false);
458 str_replace_shared_without_enc(str, fstr);
465static VALUE fstring_table_obj;
468fstring_concurrent_set_hash(
VALUE str)
470#ifdef PRECOMPUTED_FAKESTR_HASH
474 h = (st_index_t)
RSTRING(str)->as.heap.aux.capa;
491 const char *aptr, *bptr;
498 return (alen == blen &&
500 memcmp(aptr, bptr, alen) == 0);
505 bool force_precompute_hash;
509fstring_concurrent_set_create(
VALUE str,
void *data)
521 int term_len = TERM_LEN(str);
523 if (arg->force_precompute_hash && STR_EMBEDDABLE_P(
capa, term_len)) {
525 memcpy(RSTRING_PTR(new_str), RSTRING_PTR(str),
len);
526 STR_SET_LEN(new_str, RSTRING_LEN(str));
528 rb_enc_copy(new_str, str);
529 str_store_precomputed_hash(new_str, str_do_hash(str));
533 rb_enc_copy(new_str, str);
534#ifdef PRECOMPUTED_FAKESTR_HASH
535 if (
rb_str_capacity(new_str) >= RSTRING_LEN(str) + term_len +
sizeof(st_index_t)) {
536 str_store_precomputed_hash(new_str, (st_index_t)
RSTRING(str)->as.heap.aux.capa);
550 if (!
OBJ_FROZEN(str) || CHILLED_STRING_P(str)) {
553 if (STR_SHARED_P(str)) {
555 str_make_independent(str);
558 if (!BARE_STRING_P(str)) {
564 RBASIC(str)->flags |= RSTRING_FSTR;
580 .hash = fstring_concurrent_set_hash,
581 .cmp = fstring_concurrent_set_cmp,
582 .create = fstring_concurrent_set_create,
587Init_fstring_table(
void)
589 fstring_table_obj = rb_concurrent_set_new(&fstring_concurrent_set_funcs, 8192);
590 rb_gc_register_address(&fstring_table_obj);
594register_fstring(
VALUE str,
bool copy,
bool force_precompute_hash)
598 .force_precompute_hash = force_precompute_hash
601#ifdef PRECOMPUTED_FAKESTR_HASH
609 VALUE result = rb_concurrent_set_find_or_insert(&fstring_table_obj, str, &args);
611 RUBY_ASSERT(!rb_objspace_garbage_object_p(result));
623rb_obj_is_fstring_table(
VALUE obj)
627 return obj == fstring_table_obj;
631rb_gc_free_fstring(
VALUE obj)
633 ASSERT_vm_locking_with_barrier();
639 rb_concurrent_set_delete_by_identity(fstring_table_obj, obj);
641 RB_DEBUG_COUNTER_INC(obj_str_fstr);
647rb_fstring_foreach_with_replace(
int (*callback)(
VALUE *str,
void *data),
void *data)
649 if (fstring_table_obj) {
650 rb_concurrent_set_foreach_with_replace(fstring_table_obj, callback, data);
658 RBASIC_SET_FULL_SHAPE_ID((
VALUE)fake_str, ROOT_SHAPE_ID | SHAPE_ID_LAYOUT_OTHER);
671 return (
VALUE)fake_str;
678rb_setup_fake_str(
struct RString *fake_str,
const char *name,
rb_len_t len, rb_encoding *enc)
680 return setup_fake_str(fake_str, name,
len, rb_enc_to_index(enc));
691 struct RString fake_str = {RBASIC_INIT};
692 return register_fstring(setup_fake_str(&fake_str, ptr,
len, ENCINDEX_US_ASCII),
false,
false);
696rb_fstring_enc_new(
const char *ptr,
rb_len_t len, rb_encoding *enc)
698 struct RString fake_str = {RBASIC_INIT};
699 return register_fstring(rb_setup_fake_str(&fake_str, ptr,
len, enc),
false,
false);
703rb_fstring_cstr(
const char *ptr)
705 return rb_fstring_new(ptr, strlen(ptr));
709single_byte_optimizable(
VALUE str)
713 case ENCINDEX_ASCII_8BIT:
714 case ENCINDEX_US_ASCII:
736static inline const char *
737search_nonascii(
const char *p,
const char *e)
741 if (p < e && !ISASCII(*p)) {
745#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
746# if SIZEOF_UINTPTR_T == 8
747# define NONASCII_MASK UINT64_C(0x8080808080808080)
748# elif SIZEOF_UINTPTR_T == 4
749# define NONASCII_MASK UINT32_C(0x80808080)
751# error "don't know what to do."
754# if SIZEOF_UINTPTR_T == 8
755# define NONASCII_MASK ((uintptr_t)0x80808080UL << 32 | (uintptr_t)0x80808080UL)
756# elif SIZEOF_UINTPTR_T == 4
757# define NONASCII_MASK 0x80808080UL
759# error "don't know what to do."
763 if (UNALIGNED_WORD_ACCESS || e - p >= SIZEOF_VOIDP) {
764#if !UNALIGNED_WORD_ACCESS
765 if ((uintptr_t)p % SIZEOF_VOIDP) {
766 int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP;
771 case 7:
if (p[-7]&0x80)
return p-7;
772 case 6:
if (p[-6]&0x80)
return p-6;
773 case 5:
if (p[-5]&0x80)
return p-5;
774 case 4:
if (p[-4]&0x80)
return p-4;
776 case 3:
if (p[-3]&0x80)
return p-3;
777 case 2:
if (p[-2]&0x80)
return p-2;
778 case 1:
if (p[-1]&0x80)
return p-1;
783#if defined(HAVE_BUILTIN___BUILTIN_ASSUME_ALIGNED) &&! UNALIGNED_WORD_ACCESS
784#define aligned_ptr(value) \
785 __builtin_assume_aligned((value), sizeof(uintptr_t))
787#define aligned_ptr(value) (value)
790 t = (e - (SIZEOF_VOIDP-1));
792 for (;s < t; s +=
sizeof(uintptr_t)) {
794 memcpy(&word, s,
sizeof(word));
795 if (word & NONASCII_MASK) {
796#ifdef WORDS_BIGENDIAN
797 return (
const char *)s + (nlz_intptr(word&NONASCII_MASK)>>3);
799 return (
const char *)s + (ntz_intptr(word&NONASCII_MASK)>>3);
809 case 7:
if (e[-7]&0x80)
return e-7;
810 case 6:
if (e[-6]&0x80)
return e-6;
811 case 5:
if (e[-5]&0x80)
return e-5;
812 case 4:
if (e[-4]&0x80)
return e-4;
814 case 3:
if (e[-3]&0x80)
return e-3;
815 case 2:
if (e[-2]&0x80)
return e-2;
816 case 1:
if (e[-1]&0x80)
return e-1;
822coderange_scan(
const char *p,
rb_len_t len, rb_encoding *enc)
824 const char *e = p +
len;
828 p = search_nonascii(p, e);
832 if (rb_enc_asciicompat(enc)) {
833 p = search_nonascii(p, e);
836 int ret = rb_enc_precise_mbclen(p, e, enc);
840 p = search_nonascii(p, e);
846 int ret = rb_enc_precise_mbclen(p, e, enc);
855rb_str_coderange_scan_restartable(
const char *s,
const char *e, rb_encoding *enc,
int *cr)
865 p = search_nonascii(p, e);
869 else if (rb_enc_asciicompat(enc)) {
870 p = search_nonascii(p, e);
876 int ret = rb_enc_precise_mbclen(p, e, enc);
883 p = search_nonascii(p, e);
889 int ret = rb_enc_precise_mbclen(p, e, enc);
912 RUBY_ASSERT(TERM_LEN(str2) <= TERM_LEN(str1) || str_dependent_p(str1) ||
913 (STR_EMBED_P(str1) &&
914 str_embed_capa(str1) >=
RSTRING_LEN(str1) + TERM_LEN(str2)));
917 rb_enc_set_index(str1, rb_enc_get_index(str2));
925rb_enc_cr_str_copy_for_substr(
VALUE dest,
VALUE src)
930 str_enc_copy(dest, src);
932 if (!rb_enc_asciicompat(STR_ENC_GET(src)))
943 if (!rb_enc_asciicompat(STR_ENC_GET(src)) ||
955rb_enc_cr_str_exact_copy(
VALUE dest,
VALUE src)
957 str_enc_copy(dest, src);
962enc_coderange_scan(
VALUE str, rb_encoding *enc)
968rb_enc_str_coderange_scan(
VALUE str, rb_encoding *enc)
970 return enc_coderange_scan(str, enc);
974rbimpl_enc_str_coderange_scan(
VALUE str)
976 int cr = enc_coderange_scan(str, get_encoding(str));
981#undef rb_enc_str_coderange
988 cr = rbimpl_enc_str_coderange_scan(str);
992#define rb_enc_str_coderange rb_enc_str_coderange_inline
995rb_enc_str_asciicompat(
VALUE str)
998 return rb_str_encindex_fastpath(encindex) || rb_enc_asciicompat(rb_enc_get_from_index(encindex));
1006 return rb_enc_str_asciicompat(str) && is_ascii_string(str);
1023str_capacity(
VALUE str,
const int termlen)
1025 if (STR_EMBED_P(str)) {
1026 return str_embed_capa(str) - termlen;
1028 else if (
FL_ANY_RAW(str, STR_SHARED|STR_NOFREE)) {
1032 return RSTRING(str)->as.heap.aux.capa;
1039 return str_capacity(str, TERM_LEN(str));
1043must_not_null(
const char *ptr)
1046 rb_raise(rb_eArgError,
"NULL pointer given");
1051str_alloc_embed(
VALUE klass,
size_t capa)
1053 size_t size = rb_str_embed_size(
capa, 0);
1060 str->as.embed.ary[0] = 0;
1066str_alloc_heap(
VALUE klass)
1071 str->as.heap.aux.capa = 0;
1072 str->as.heap.ptr = NULL;
1078empty_str_alloc(
VALUE klass)
1080 RUBY_DTRACE_CREATE_HOOK(STRING, 0);
1081 VALUE str = str_alloc_embed(klass, 0);
1082 memset(
RSTRING(str)->
as.embed.ary, 0, str_embed_capa(str));
1093 rb_raise(rb_eArgError,
"negative string size (or size too big)");
1100 RUBY_DTRACE_CREATE_HOOK(STRING,
len);
1102 int termlen = rb_enc_mbminlen(enc);
1104 if (STR_EMBEDDABLE_P(
len, termlen)) {
1105 str = str_alloc_embed(klass,
len + termlen);
1111 str = str_alloc_heap(klass);
1117 rb_xmalloc_mul_add_mul(
sizeof(
char),
len,
sizeof(
char), termlen);
1120 rb_enc_raw_set(str, enc);
1129 STR_SET_LEN(str,
len);
1172 __msan_unpoison_string(ptr);
1192 if (rb_enc_mbminlen(enc) != 1) {
1193 rb_raise(rb_eArgError,
"wchar encoding given");
1195 return rb_enc_str_new(ptr, strlen(ptr), enc);
1204 rb_raise(rb_eArgError,
"negative string size (or size too big)");
1208 str = str_enc_new(klass, ptr,
len, rb_enc_from_index(encindex));
1211 RUBY_DTRACE_CREATE_HOOK(STRING,
len);
1212 str = str_alloc_heap(klass);
1214 RSTRING(str)->as.heap.ptr = (
char *)ptr;
1216 RBASIC(str)->flags |= STR_NOFREE;
1217 rb_enc_associate_index(str, encindex);
1234 RUBY_DTRACE_CREATE_HOOK(STRING,
len);
1237 RSTRING(str)->as.heap.ptr = ptr;
1241 rb_enc_associate_index(str, encindex);
1248 return str_new_static(
rb_cString, ptr,
len, ENCINDEX_US_ASCII);
1254 return str_new_static(
rb_cString, ptr,
len, ENCINDEX_UTF_8);
1260 return str_new_static(
rb_cString, ptr,
len, rb_enc_to_index(enc));
1264 rb_encoding *from, rb_encoding *to,
1265 int ecflags,
VALUE ecopts);
1268is_enc_ascii_string(
VALUE str, rb_encoding *enc)
1270 int encidx = rb_enc_to_index(enc);
1271 if (rb_enc_get_index(str) == encidx)
1272 return is_ascii_string(str);
1283 if (!to)
return str;
1284 if (!from) from = rb_enc_get(str);
1285 if (from == to)
return str;
1286 if ((rb_enc_asciicompat(to) && is_enc_ascii_string(str, from)) ||
1287 rb_is_ascii8bit_enc(to)) {
1288 if (STR_ENC_GET(str) != to) {
1290 rb_enc_associate(str, to);
1297 from, to, ecflags, ecopts);
1298 if (
NIL_P(newstr)) {
1307 rb_encoding *from,
int ecflags,
VALUE ecopts)
1312 if (ofs < -olen || olen < ofs)
1314 if (ofs < 0) ofs += olen;
1316 STR_SET_LEN(newstr, ofs);
1320 rb_str_modify(newstr);
1321 return str_cat_conv_enc_opts(newstr, ofs, ptr,
len, from,
1327rb_str_initialize(
VALUE str,
const char *ptr,
rb_len_t len, rb_encoding *enc)
1329 STR_SET_LEN(str, 0);
1330 rb_enc_associate(str, enc);
1337 rb_encoding *from, rb_encoding *to,
1338 int ecflags,
VALUE ecopts)
1343 VALUE econv_wrapper;
1344 const unsigned char *start, *sp;
1345 unsigned char *dest, *dp;
1346 size_t converted_output = (size_t)ofs;
1351 RBASIC_CLEAR_CLASS(econv_wrapper);
1353 if (!ec)
return Qnil;
1356 sp = (
unsigned char*)ptr;
1358 while ((dest = (
unsigned char*)
RSTRING_PTR(newstr)),
1359 (dp = dest + converted_output),
1363 size_t converted_input = sp - start;
1364 size_t rest =
len - converted_input;
1365 converted_output = dp - dest;
1367 if (converted_input && converted_output &&
1369 rest = (rest * converted_output) / converted_input;
1374 olen += rest < 2 ? 2 : rest;
1375 rb_str_resize(newstr, olen);
1384 rb_enc_associate(newstr, to);
1403 const int eidx = rb_enc_to_index(eenc);
1406 return rb_enc_str_new(ptr,
len, eenc);
1416 if (!ienc || eenc == ienc) {
1417 return rb_enc_str_new(ptr,
len, eenc);
1423 (rb_enc_asciicompat(eenc) && !search_nonascii(ptr, ptr +
len))) {
1424 return rb_enc_str_new(ptr,
len, ienc);
1427 str = rb_enc_str_new(NULL, 0, ienc);
1430 if (
NIL_P(rb_str_cat_conv_enc_opts(str, 0, ptr,
len, eenc, 0,
Qnil))) {
1431 rb_str_initialize(str, ptr,
len, eenc);
1437rb_external_str_with_enc(
VALUE str, rb_encoding *eenc)
1439 int eidx = rb_enc_to_index(eenc);
1441 !is_ascii_string(str)) {
1445 rb_enc_associate_index(str, eidx);
1504str_replace_shared_without_enc(
VALUE str2,
VALUE str)
1506 const int termlen = TERM_LEN(str);
1511 if (str_embed_capa(str2) >=
len + termlen) {
1512 char *ptr2 =
RSTRING(str2)->as.embed.ary;
1513 STR_SET_EMBED(str2);
1515 TERM_FILL(ptr2+
len, termlen);
1519 if (STR_SHARED_P(str)) {
1520 root =
RSTRING(str)->as.heap.aux.shared;
1529 if (!STR_EMBED_P(str2) && !
FL_TEST_RAW(str2, STR_SHARED|STR_NOFREE)) {
1531 rb_fatal(
"about to free a possible shared root");
1533 char *ptr2 = STR_HEAP_PTR(str2);
1535 SIZED_FREE_N(ptr2, STR_HEAP_SIZE(str2));
1538 FL_SET(str2, STR_NOEMBED);
1539 RSTRING(str2)->as.heap.ptr = ptr;
1540 STR_SET_SHARED(str2, root);
1543 STR_SET_LEN(str2,
len);
1551 str_replace_shared_without_enc(str2, str);
1552 rb_enc_cr_str_exact_copy(str2, str);
1559 return str_replace_shared(str_alloc_heap(klass), str);
1576rb_str_new_frozen_String(
VALUE orig)
1584rb_str_frozen_bare_string(
VALUE orig)
1586 if (RB_LIKELY(BARE_STRING_P(orig) &&
OBJ_FROZEN_RAW(orig)))
return orig;
1591rb_str_tmp_frozen_acquire(
VALUE orig)
1594 return str_new_frozen_buffer(0, orig, FALSE);
1601 if (STR_SHARED_P(orig) && !STR_EMBED_P(
RSTRING(orig)->
as.heap.aux.shared))
return rb_str_tmp_frozen_acquire(orig);
1603 VALUE str = str_alloc_heap(0);
1606 FL_SET(str, STR_SHARED_ROOT);
1608 size_t capa = str_capacity(orig, TERM_LEN(orig));
1614 if (STR_EMBED_P(orig) ||
FL_TEST_RAW(orig, STR_SHARED | STR_SHARED_ROOT | RSTRING_FSTR)) {
1615 RSTRING(str)->as.heap.ptr = rb_xmalloc_mul_add_mul(
sizeof(
char),
capa,
sizeof(
char), TERM_LEN(orig));
1622 RBASIC(str)->flags |=
RBASIC(orig)->flags & STR_NOFREE;
1623 RBASIC(orig)->flags &= ~STR_NOFREE;
1624 STR_SET_SHARED(orig, str);
1635 RSTRING(str)->as.heap.aux.capa =
capa + (TERM_LEN(orig) - TERM_LEN(str));
1643 rb_str_tmp_frozen_release(orig, tmp);
1647rb_str_tmp_frozen_release(
VALUE orig,
VALUE tmp)
1652 if (STR_EMBED_P(tmp)) {
1655 else if (
FL_TEST_RAW(orig, STR_SHARED | STR_TMPLOCK) == STR_SHARED &&
1665 RSTRING(orig)->as.heap.aux.capa =
RSTRING(tmp)->as.heap.aux.capa + TERM_LEN(tmp) - TERM_LEN(orig);
1666 RBASIC(orig)->flags |=
RBASIC(tmp)->flags & STR_NOFREE;
1671 STR_SET_LEN(tmp, 0);
1679 return str_new_frozen_buffer(klass, orig, TRUE);
1688heap_str_make_shared(
VALUE klass,
VALUE orig,
int termlen)
1694 VALUE str = str_alloc_heap(klass);
1697 RSTRING(str)->as.heap.aux.capa =
RSTRING(orig)->as.heap.aux.capa + TERM_LEN(orig) - termlen;
1698 RBASIC(str)->flags |=
RBASIC(orig)->flags & STR_NOFREE;
1699 RBASIC(orig)->flags &= ~STR_NOFREE;
1700 STR_SET_SHARED(orig, str);
1707str_new_frozen_buffer(
VALUE klass,
VALUE orig,
int copy_encoding)
1712 rb_encoding *enc = copy_encoding ? STR_ENC_GET(orig) : rb_ascii8bit_encoding();
1713 int termlen = copy_encoding ? TERM_LEN(orig) : 1;
1715 if (STR_EMBED_P(orig) || STR_EMBEDDABLE_P(
len, termlen)) {
1729 if ((ofs > 0) || (rest > 0) ||
1732 str = str_new_shared(klass,
shared);
1734 RSTRING(str)->as.heap.ptr += ofs;
1735 STR_SET_LEN(str,
RSTRING_LEN(str) - (ofs + rest));
1743 else if (STR_EMBEDDABLE_P(
RSTRING_LEN(orig), TERM_LEN(orig))) {
1744 str = str_alloc_embed(klass,
RSTRING_LEN(orig) + TERM_LEN(orig));
1756 str = heap_str_make_shared(klass, orig, termlen);
1761 if (copy_encoding) rb_enc_cr_str_exact_copy(str, orig);
1773str_new_empty_String(
VALUE str)
1776 rb_enc_copy(v, str);
1780#define STR_BUF_MIN_SIZE 63
1785 if (STR_EMBEDDABLE_P(
capa, 1)) {
1793 RSTRING(str)->as.heap.ptr[0] =
'\0';
1813 return str_new(0, 0,
len);
1819 if (STR_EMBED_P(str)) {
1820 RB_DEBUG_COUNTER_INC(obj_str_embed);
1822 else if (
FL_TEST(str, STR_SHARED | STR_NOFREE)) {
1823 (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared,
FL_TEST(str, STR_SHARED));
1824 (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared,
FL_TEST(str, STR_NOFREE));
1827 RB_DEBUG_COUNTER_INC(obj_str_ptr);
1828 SIZED_FREE_N(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
1833rb_str_memsize(
VALUE str)
1835 if (
FL_TEST(str, STR_NOEMBED|STR_SHARED|STR_NOFREE) == STR_NOEMBED) {
1836 return STR_HEAP_SIZE(str);
1846 return rb_convert_type_with_id(str,
T_STRING,
"String", idTo_str);
1849static inline void str_discard(
VALUE str);
1850static void str_shared_replace(
VALUE str,
VALUE str2);
1855 if (str != str2) str_shared_replace(str, str2);
1866 enc = STR_ENC_GET(str2);
1869 termlen = rb_enc_mbminlen(enc);
1873 if (str_embed_capa(str) >=
RSTRING_LEN(str2) + termlen) {
1878 if (STR_EMBED_P(str2)) {
1883 char *new_ptr =
ALLOC_N(
char,
len + termlen);
1884 memcpy(new_ptr,
RSTRING(str2)->
as.embed.ary,
len + termlen);
1885 RSTRING(str2)->as.heap.ptr = new_ptr;
1886 STR_SET_LEN(str2,
len);
1888 STR_SET_NOEMBED(str2);
1891 STR_SET_NOEMBED(str);
1895 if (
FL_TEST(str2, STR_SHARED)) {
1897 STR_SET_SHARED(str,
shared);
1900 RSTRING(str)->as.heap.aux.capa =
RSTRING(str2)->as.heap.aux.capa;
1904 STR_SET_EMBED(str2);
1906 STR_SET_LEN(str2, 0);
1911 rb_enc_raw_set(str, enc);
1924 return rb_obj_as_string_result(str, obj);
1941 if (STR_SHARED_P(str2)) {
1944 STR_SET_NOEMBED(str);
1945 STR_SET_LEN(str,
len);
1947 STR_SET_SHARED(str,
shared);
1948 rb_enc_cr_str_exact_copy(str, str2);
1951 str_replace_shared(str, str2);
1960 size_t size = rb_str_embed_size(
capa, 0);
1976 str->as.heap.aux.capa = 0;
1977 str->as.heap.ptr = NULL;
1987 encidx = rb_enc_get_index(str);
1991 if (encidx) rb_enc_associate_index(dup, encidx);
2006 str_duplicate_setup_encoding(str, dup, flags);
2015 root =
RSTRING(str)->as.heap.aux.shared;
2018 root = str = str_new_frozen(klass, str);
2026 STR_SET_SHARED(dup, root);
2027 flags |= RSTRING_NOEMBED | STR_SHARED;
2030 str_duplicate_setup_encoding(str, dup, flags);
2037 if (STR_EMBED_P(str) && rb_str_embed_size(
RSTRING_LEN(str), 1) <= STR_COPY_MAX_EMBED_SIZE) {
2038 dup = str_alloc_embed(klass,
RSTRING_LEN(str) + TERM_LEN(str));
2040 str_duplicate_setup_embed(klass, str, dup);
2043 dup = str_alloc_heap(klass);
2045 str_duplicate_setup_heap(klass, str, dup);
2059rb_str_dup_m(
VALUE str)
2061 if (LIKELY(BARE_STRING_P(str))) {
2072 RUBY_DTRACE_CREATE_HOOK(STRING,
RSTRING_LEN(str));
2079 RUBY_DTRACE_CREATE_HOOK(STRING,
RSTRING_LEN(str));
2083 new_str = ec_str_alloc_embed(ec, klass,
RSTRING_LEN(str) + TERM_LEN(str));
2084 str_duplicate_setup_embed(klass, str, new_str);
2087 new_str = ec_str_alloc_heap(ec, klass);
2088 str_duplicate_setup_heap(klass, str, new_str);
2098rb_zjit_str_resurrect_fastpath(
VALUE str,
bool chilled,
size_t *size_out,
2100 rb_len_t *len_out,
size_t *byte_size_out)
2104 if (!STR_EMBED_P(str))
return false;
2108 size_t size = rb_str_embed_size(
len + termlen, 0);
2109 if (!rb_gc_size_allocatable_p(size))
return false;
2119 if (chilled) flags |= STR_CHILLED;
2124 *byte_size_out = (size_t)(
len + termlen);
2130rb_str_with_debug_created_info(
VALUE str,
VALUE path,
int line)
2132 VALUE debug_info = rb_ary_new_from_args(2, path,
INT2FIX(line));
2149 rb_encoding *enc = UNDEF_P(venc) ? 0 : rb_to_encoding(venc);
2156 if (
capa < STR_BUF_MIN_SIZE) {
2157 capa = STR_BUF_MIN_SIZE;
2164 if (orig == str) orig = 0;
2166 termlen = enc ? rb_enc_mbminlen(enc) : TERM_LEN(orig ? orig : str);
2167 str_modifiable(str);
2169 const size_t size = (size_t)
capa + termlen;
2171 if (STR_EMBED_P(str) && (
size_t)str_embed_capa(str) >= size) {
2174 else if (STR_EMBED_P(str) ||
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2176 const size_t osize =
RSTRING_LEN(str) + TERM_LEN(str);
2177 char *new_ptr =
ALLOC_N(
char, size);
2179 memcpy(new_ptr, old_ptr, osize < size ? osize : size);
2181 RSTRING(str)->as.heap.ptr = new_ptr;
2183 FL_SET(str, STR_NOEMBED);
2185 else if (STR_HEAP_SIZE(str) != (
size_t)
capa + termlen) {
2186 SIZED_REALLOC_N(
RSTRING(str)->
as.heap.ptr,
char,
2187 (
size_t)
capa + termlen, STR_HEAP_SIZE(str));
2190 STR_SET_LEN(str,
len);
2192 TERM_FILL(buf +
len, termlen);
2195 if (!enc || rb_enc_get(orig) == enc) {
2196 rb_enc_cr_str_exact_copy(str, orig);
2205 str_modifiable(str);
2208 rb_enc_raw_set(str, enc);
2211 rb_enc_associate(str, enc);
2225 if (!
NIL_P(venc_unset)) {
2229 return str_init(str, orig, venc, vcapa);
2233rb_str_new_enc_capa(rb_execution_context_t *ec,
VALUE str,
VALUE venc,
VALUE venc_unset,
VALUE vcapa)
2235 if (!
NIL_P(venc_unset)) {
2239 return str_init(str,
Qundef, venc, vcapa);
2253 if (!UNDEF_P(encoding) && !
NIL_P(encoding)) {
2254 enc = rb_to_encoding(encoding);
2258 RUBY_DTRACE_CREATE_HOOK(STRING,
capa);
2260 if (STR_EMBEDDABLE_P(
capa, termlen)) {
2261 return str_alloc_embed(klass,
capa + termlen);
2264 return str_alloc_heap(klass);
2269rb_str_s_new(
int argc,
VALUE *argv,
VALUE klass)
2280 if (n == 0) orig =
Qundef;
2283 ID keyword_ids[2] = {idEncoding, idCapacity};
2287 if (!UNDEF_P(kwargs[1])) {
2292 VALUE str = rb_str_alloc_enc_capa(klass, venc, vcapa);
2293 str_init(str, orig, venc, vcapa);
2298#define is_utf8_lead_byte(c) (((c)&0xC0) != 0x80)
2313static inline uintptr_t
2314count_utf8_lead_bytes_with_word(
const uintptr_t *s)
2319 d = (d>>6) | (~d>>7);
2320 d &= NONASCII_MASK >> 7;
2323#if defined(HAVE_BUILTIN___BUILTIN_POPCOUNT) && defined(__POPCNT__)
2325 return rb_popcount_intptr(d);
2329# if SIZEOF_VOIDP == 8
2338enc_strlen(
const char *p,
const char *e, rb_encoding *enc,
int cr)
2345 return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
2350 if ((
int)
sizeof(uintptr_t) * 2 < e - p) {
2351 const uintptr_t *s, *t;
2352 const uintptr_t lowbits =
sizeof(uintptr_t) - 1;
2353 s = (
const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
2354 t = (
const uintptr_t*)(~lowbits & (uintptr_t)e);
2355 while (p < (
const char *)s) {
2356 if (is_utf8_lead_byte(*p))
len++;
2360 len += count_utf8_lead_bytes_with_word(s);
2363 p = (
const char *)s;
2366 if (is_utf8_lead_byte(*p))
len++;
2372 else if (rb_enc_asciicompat(enc)) {
2376 q = search_nonascii(p, e);
2381 p += rb_enc_fast_mbclen(p, e, enc);
2387 q = search_nonascii(p, e);
2392 p += rb_enc_mbclen(p, e, enc);
2399 for (c=0; p<e; c++) {
2400 p += rb_enc_mbclen(p, e, enc);
2415rb_enc_strlen_cr(
const char *p,
const char *e, rb_encoding *enc,
int *cr)
2424 return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
2426 else if (rb_enc_asciicompat(enc)) {
2429 q = search_nonascii(p, e);
2436 ret = rb_enc_precise_mbclen(p, e, enc);
2451 for (c=0; p<e; c++) {
2452 ret = rb_enc_precise_mbclen(p, e, enc);
2459 if (p + rb_enc_mbminlen(enc) <= e)
2460 p += rb_enc_mbminlen(enc);
2471str_strlen(
VALUE str, rb_encoding *enc)
2476 if (single_byte_optimizable(str))
return RSTRING_LEN(str);
2477 if (!enc) enc = STR_ENC_GET(str);
2483 rb_len_t n = rb_enc_strlen_cr(p, e, enc, &cr);
2488 return enc_strlen(p, e, enc, cr);
2495 return str_strlen(str, NULL);
2519 return LEN2NUM(str_strlen(str, NULL));
2542rb_str_bytesize(
VALUE str)
2561rb_str_empty(
VALUE str)
2582 const char *ptr1, *ptr2;
2588 enc = rb_enc_check_str(str1, str2);
2591 termlen = rb_enc_mbminlen(enc);
2593 rb_raise(rb_eArgError,
"string size too big");
2595 str3 = str_enc_new(
rb_cString, 0, len1+len2, enc);
2597 memcpy(ptr3, ptr1, len1);
2598 memcpy(ptr3+len1, ptr2, len2);
2599 TERM_FILL(&ptr3[len1+len2], termlen);
2615 MAYBE_UNUSED(
char) *ptr1, *ptr2;
2618 int enc1 = rb_enc_get_index(str1);
2619 int enc2 = rb_enc_get_index(str2);
2624 else if (enc2 < 0) {
2627 else if (enc1 != enc2) {
2664 rb_enc_copy(str2, str);
2669 rb_raise(rb_eArgError,
"negative argument");
2672 if (STR_EMBEDDABLE_P(
len, 1)) {
2681 STR_SET_LEN(str2,
len);
2682 rb_enc_copy(str2, str);
2686 rb_raise(rb_eArgError,
"argument too big");
2690 termlen = TERM_LEN(str);
2696 while (n <=
len/2) {
2697 memcpy(ptr2 + n, ptr2, n);
2700 memcpy(ptr2 + n, ptr2,
len-n);
2702 STR_SET_LEN(str2,
len);
2703 TERM_FILL(&ptr2[
len], termlen);
2704 rb_enc_cr_str_copy_for_substr(str2, str);
2743rb_check_lockedtmp(
VALUE str)
2745 if (
FL_TEST(str, STR_TMPLOCK)) {
2752#define STR_UNMODIFIABLE_MASK (FL_FREEZE | STR_TMPLOCK | STR_CHILLED)
2754str_modifiable(
VALUE str)
2758 if (RB_UNLIKELY(
FL_ANY_RAW(str, STR_UNMODIFIABLE_MASK))) {
2759 if (CHILLED_STRING_P(str)) {
2760 CHILLED_STRING_MUTATED(str);
2762 rb_check_lockedtmp(str);
2763 rb_check_frozen(str);
2768str_dependent_p(
VALUE str)
2770 if (STR_EMBED_P(str) || !
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2780#define STR_DEPENDANT_MASK (STR_UNMODIFIABLE_MASK | STR_SHARED | STR_NOFREE)
2782str_independent(
VALUE str)
2786 if (RB_UNLIKELY(
FL_ANY_RAW(str, STR_DEPENDANT_MASK))) {
2787 str_modifiable(str);
2788 return !str_dependent_p(str);
2804 if (!STR_EMBED_P(str) && str_embed_capa(str) >=
capa + termlen) {
2805 ptr =
RSTRING(str)->as.heap.ptr;
2809 STR_SET_LEN(str,
len);
2816 memcpy(ptr, oldptr,
len);
2818 if (
FL_TEST_RAW(str, STR_NOEMBED|STR_NOFREE|STR_SHARED) == STR_NOEMBED) {
2819 SIZED_FREE_N(oldptr, STR_HEAP_SIZE(str));
2821 STR_SET_NOEMBED(str);
2822 FL_UNSET(str, STR_SHARED|STR_NOFREE);
2823 TERM_FILL(ptr +
len, termlen);
2824 RSTRING(str)->as.heap.ptr = ptr;
2825 STR_SET_LEN(str,
len);
2832 if (!str_independent(str))
2833 str_make_independent(str);
2842 int termlen = TERM_LEN(str);
2846 rb_raise(rb_eArgError,
"negative expanding string size");
2849 rb_raise(rb_eArgError,
"string size too big");
2852 if (!str_independent(str)) {
2853 str_make_independent_expand(str,
len, expand, termlen);
2855 else if (expand > 0) {
2856 RESIZE_CAPA_TERM(str,
len + expand, termlen);
2863str_modify_keep_cr(
VALUE str)
2865 if (!str_independent(str))
2866 str_make_independent(str);
2873str_discard(
VALUE str)
2875 str_modifiable(str);
2876 if (!STR_EMBED_P(str) && !
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2877 SIZED_FREE_N(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
2878 RSTRING(str)->as.heap.ptr = 0;
2879 STR_SET_LEN(str, 0);
2886 int encindex = rb_enc_get_index(str);
2888 if (RB_UNLIKELY(encindex == -1)) {
2892 if (RB_LIKELY(rb_str_encindex_fastpath(encindex))) {
2896 rb_encoding *enc = rb_enc_from_index(encindex);
2897 if (!rb_enc_asciicompat(enc)) {
2923str_null_char(
const char *s,
rb_len_t len,
const int minlen, rb_encoding *enc)
2925 const char *e = s +
len;
2927 for (; s + minlen <= e; s += rb_enc_mbclen(s, e, enc)) {
2928 if (zero_filled(s, minlen))
return s;
2939 if (str_dependent_p(str)) {
2940 if (!zero_filled(s +
len, termlen))
2941 str_make_independent_expand(str,
len, 0L, termlen);
2944 TERM_FILL(s +
len, termlen);
2951rb_str_change_terminator_length(
VALUE str,
const int oldtermlen,
const int termlen)
2953 rb_len_t capa = str_capacity(str, oldtermlen) + oldtermlen;
2958 rb_check_lockedtmp(str);
2959 str_make_independent_expand(str,
len, 0L, termlen);
2961 else if (str_dependent_p(str)) {
2962 if (termlen > oldtermlen)
2963 str_make_independent_expand(str,
len, 0L, termlen);
2966 if (!STR_EMBED_P(str)) {
2971 if (termlen > oldtermlen) {
2980str_null_check(
VALUE str,
int *w)
2986 if (RB_UNLIKELY(!rb_str_enc_fastpath(str))) {
2987 rb_encoding *enc = rb_str_enc_get(str);
2988 minlen = rb_enc_mbminlen(enc);
2992 if (str_null_char(s,
len, minlen, enc)) {
2995 return str_fill_term(str, s,
len, minlen);
3000 if (!s || memchr(s, 0,
len)) {
3004 s = str_fill_term(str, s,
len, minlen);
3009static char *str_to_cstr(
VALUE str);
3012rb_str_null_check(
VALUE str)
3020 if (RB_LIKELY(rb_str_enc_fastpath(str))) {
3021 if (!s || memchr(s, 0,
len)) {
3022 rb_raise(rb_eArgError,
"string contains null byte");
3033rb_str_to_cstr(
VALUE str)
3036 return str_null_check(str, &w);
3043 return str_to_cstr(str);
3047str_to_cstr(
VALUE str)
3050 char *s = str_null_check(str, &w);
3053 rb_raise(rb_eArgError,
"string contains null char");
3055 rb_raise(rb_eArgError,
"string contains null byte");
3061rb_str_fill_terminator(
VALUE str,
const int newminlen)
3065 return str_fill_term(str, s,
len, newminlen);
3071 str = rb_check_convert_type_with_id(str,
T_STRING,
"String", idTo_str);
3097str_nth_len(
const char *p,
const char *e,
rb_len_t *nthp, rb_encoding *enc)
3106 else if (rb_enc_asciicompat(enc)) {
3107 const char *p2, *e2;
3110 while (p < e && 0 < nth) {
3116 p2 = search_nonascii(p, e2);
3124 n = rb_enc_mbclen(p, e, enc);
3135 while (p < e && nth--) {
3136 p += rb_enc_mbclen(p, e, enc);
3147 return str_nth_len(p, e, &nth, enc);
3151str_nth(
const char *p,
const char *e,
rb_len_t nth, rb_encoding *enc,
int singlebyte)
3156 p = str_nth_len(p, e, &nth, enc);
3165str_offset(
const char *p,
const char *e,
rb_len_t nth, rb_encoding *enc,
int singlebyte)
3167 const char *pp = str_nth(p, e, nth, enc, singlebyte);
3168 if (!pp)
return e - p;
3176 STR_ENC_GET(str), single_byte_optimizable(str));
3181str_utf8_nth(
const char *p,
const char *e,
rb_len_t *nthp)
3184 if ((
int)SIZEOF_VOIDP * 2 < e - p && (
int)SIZEOF_VOIDP * 2 < nth) {
3185 const uintptr_t *s, *t;
3186 const uintptr_t lowbits = SIZEOF_VOIDP - 1;
3187 s = (
const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
3188 t = (
const uintptr_t*)(~lowbits & (uintptr_t)e);
3189 while (p < (
const char *)s) {
3190 if (is_utf8_lead_byte(*p)) nth--;
3194 nth -= count_utf8_lead_bytes_with_word(s);
3196 }
while (s < t && (
int)SIZEOF_VOIDP <= nth);
3200 if (is_utf8_lead_byte(*p)) {
3201 if (nth == 0)
break;
3211str_utf8_offset(
const char *p,
const char *e,
rb_len_t nth)
3213 const char *pp = str_utf8_nth(p, e, &nth);
3222 if (single_byte_optimizable(str) || pos < 0)
3226 return enc_strlen(p, p + pos, STR_ENC_GET(str),
ENC_CODERANGE(str));
3239 const int termlen = TERM_LEN(str);
3240 if (!SHARABLE_SUBSTRING_P(str, beg,
len)) {
3241 str2 = rb_enc_str_new(
RSTRING_PTR(str) + beg,
len, rb_str_enc_get(str));
3251 const bool root_available = STR_SHARED_P(str) ||
3253 const size_t max_embed_size = root_available ?
3254 rb_gc_size_slot_size(
sizeof(
struct RString)) : STR_COPY_MAX_EMBED_SIZE;
3255 const size_t embed_size = rb_str_embed_size(
len, termlen);
3257 if (embed_size <= max_embed_size && rb_gc_size_allocatable_p(embed_size)) {
3259 char *ptr2 =
RSTRING(str2)->as.embed.ary;
3261 TERM_FILL(ptr2 +
len, termlen);
3263 STR_SET_LEN(str2,
len);
3272 str_replace_shared(str2, str);
3278 RSTRING(str2)->as.heap.ptr += beg;
3280 STR_SET_LEN(str2,
len);
3290 VALUE str2 = str_subseq(str, beg,
len);
3291 rb_enc_cr_str_copy_for_substr(str2, str);
3301 rb_encoding *enc = STR_ENC_GET(str);
3302 const char *p, *s =
RSTRING_PTR(str), *e = s + blen;
3304 if (
len < 0)
return 0;
3309 if (single_byte_optimizable(str)) {
3310 if (beg > blen)
return 0;
3313 if (beg < 0)
return 0;
3315 if (
len > blen - beg)
3317 if (
len < 0)
return 0;
3322 if (
len > -beg)
len = -beg;
3326 while (beg-- >
len && (e = rb_enc_prev_char(s, e, e, enc)) != 0);
3329 while (
len-- > 0 && (p = rb_enc_prev_char(s, p, e, enc)) != 0);
3335 slen = str_strlen(str, enc);
3337 if (beg < 0)
return 0;
3339 if (
len == 0)
goto end;
3342 else if (beg > 0 && beg > blen) {
3346 if (beg > str_strlen(str, enc))
return 0;
3352 p = str_utf8_nth(s, e, &beg);
3353 if (beg > 0)
return 0;
3354 len = str_utf8_offset(p, e,
len);
3360 p = s + beg * char_sz;
3364 else if (
len * char_sz > e - p)
3369 else if ((p = str_nth_len(s, e, &beg, enc)) == e) {
3370 if (beg > 0)
return 0;
3374 len = str_offset(p, e,
len, enc, 0);
3387 return str_substr(str, beg,
len, TRUE);
3401 if (!p)
return Qnil;
3402 if (!
len && !empty)
return Qnil;
3406 VALUE str2 = str_subseq(str, beg,
len);
3407 rb_enc_cr_str_copy_for_substr(str2, str);
3415 if (CHILLED_STRING_P(str)) {
3438 if (
OBJ_FROZEN(str) || CHILLED_STRING_P(str)) {
3481str_uminus(
VALUE str)
3486 return rb_fstring(str);
3490#define rb_str_dup_frozen rb_str_new_frozen
3495 rb_check_frozen(str);
3496 if (
FL_TEST(str, STR_TMPLOCK)) {
3499 FL_SET(str, STR_TMPLOCK);
3506 rb_check_frozen(str);
3507 if (!
FL_TEST(str, STR_TMPLOCK)) {
3527 const int termlen = TERM_LEN(str);
3529 str_modifiable(str);
3530 if (STR_SHARED_P(str)) {
3534 rb_bug(
"probable buffer overflow: %"PRIdLEN
" for %"PRIdLEN,
len,
capa);
3550 rb_encoding *enc = rb_enc_get(str);
3551 rb_str_coderange_scan_restartable(prev_end, new_end, enc, &cr);
3567 STR_SET_LEN(str,
len);
3575 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3578 int independent = str_independent(str);
3580 const int termlen = TERM_LEN(str);
3582 rb_raise(rb_eArgError,
"string size too big");
3585 if (slen >
len || (termlen != 1 && slen <
len)) {
3591 if (STR_EMBED_P(str)) {
3592 if (
len == slen)
return str;
3593 if (str_embed_capa(str) >=
len + termlen) {
3594 STR_SET_LEN(str,
len);
3598 str_make_independent_expand(str, slen,
len - slen, termlen);
3600 else if (str_embed_capa(str) >=
len + termlen) {
3602 char *ptr = STR_HEAP_PTR(str);
3604 if (slen >
len) slen =
len;
3607 STR_SET_LEN(str,
len);
3609 SIZED_FREE_N(ptr,
capa + termlen);
3613 else if (!independent) {
3614 if (
len == slen)
return str;
3615 str_make_independent_expand(str, slen,
len - slen, termlen);
3619 SIZED_REALLOC_N(
RSTRING(str)->
as.heap.ptr,
char,
3620 (
size_t)
len + termlen, STR_HEAP_SIZE(str));
3623 else if (
len == slen)
return str;
3624 STR_SET_LEN(str,
len);
3633 str_modify_keep_cr(str);
3635 const int termlen = TERM_LEN(str);
3639 rb_raise(rb_eArgError,
"string sizes too big");
3649 while (total >
capa) {
3652 RESIZE_CAPA_TERM(str,
capa, termlen);
3660 str_modify_keep_cr(str);
3665 if (
len == 0)
return 0;
3669 const int termlen = TERM_LEN(str);
3672 if (ptr >= sptr && ptr <= sptr + olen) {
3679 rb_raise(rb_eArgError,
"string sizes too big");
3686 while (total >
capa) {
3689 RESIZE_CAPA_TERM(str,
capa, termlen);
3695 memcpy(sptr + olen, ptr,
len);
3696 STR_SET_LEN(str, total);
3697 TERM_FILL(sptr + total, termlen);
3702#define str_buf_cat(str, ptr, len) str_buf_cat4((str), (ptr), len, false)
3703#define str_buf_cat2(str, ptr) str_buf_cat4((str), (ptr), rb_strlen_lit(ptr), false)
3708 if (
len == 0)
return str;
3710 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3712 return str_buf_cat(str, ptr,
len);
3723rb_str_buf_cat_byte(
VALUE str,
unsigned char byte)
3728 if (UNLIKELY(!str_independent(str))) {
3729 str_make_independent(str);
3733 const int null_terminator_length = 1;
3738 if (UNLIKELY(string_length >
RB_LEN_MAX - 1)) {
3739 rb_raise(rb_eArgError,
"string sizes too big");
3742 rb_len_t string_capacity = str_capacity(str, null_terminator_length);
3748 if (LIKELY(string_capacity >= string_length + 1)) {
3750 sptr[string_length] = byte;
3751 STR_SET_LEN(str, string_length + 1);
3752 TERM_FILL(sptr + string_length + 1, null_terminator_length);
3756 str_buf_cat(str, (
char *)&
byte, 1);
3764 if (ISASCII(
byte)) {
3772 rb_enc_associate_index(str, ENCINDEX_ASCII_8BIT);
3784 int ptr_encindex,
int ptr_cr,
int *ptr_cr_ret)
3789 rb_encoding *str_enc, *ptr_enc;
3793 if (str_encindex == ptr_encindex) {
3795 ptr_cr = coderange_scan(ptr,
len, rb_enc_from_index(ptr_encindex));
3799 str_enc = rb_enc_from_index(str_encindex);
3800 ptr_enc = rb_enc_from_index(ptr_encindex);
3801 if (!rb_enc_asciicompat(str_enc) || !rb_enc_asciicompat(ptr_enc)) {
3806 rb_str_change_terminator_length(str, rb_enc_mbminlen(str_enc), rb_enc_mbminlen(ptr_enc));
3813 ptr_cr = coderange_scan(ptr,
len, ptr_enc);
3817 str_cr = rb_enc_str_coderange(str);
3822 *ptr_cr_ret = ptr_cr;
3824 if (str_encindex != ptr_encindex &&
3827 str_enc = rb_enc_from_index(str_encindex);
3828 ptr_enc = rb_enc_from_index(ptr_encindex);
3833 res_encindex = str_encindex;
3838 res_encindex = str_encindex;
3842 res_encindex = ptr_encindex;
3847 res_encindex = str_encindex;
3854 res_encindex = str_encindex;
3860 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3862 str_buf_cat(str, ptr,
len);
3868 rb_enc_inspect_name(str_enc), rb_enc_inspect_name(ptr_enc));
3875 return rb_enc_cr_str_buf_cat(str, ptr,
len,
3884 rb_encoding *enc = rb_enc_from_index(encindex);
3885 if (rb_enc_asciicompat(enc)) {
3886 return rb_enc_cr_str_buf_cat(str, ptr, strlen(ptr),
3892 unsigned int c = (
unsigned char)*ptr;
3893 int len = rb_enc_codelen(c, enc);
3894 rb_enc_mbcput(c, buf, enc);
3895 rb_enc_cr_str_buf_cat(str, buf,
len,
3906 str_modify_keep_cr(str);
3908 int str2_cr = rb_enc_str_coderange(str2);
3910 if (rb_str_enc_fastpath(str)) {
3947rb_str_concat_literals(
size_t num,
const VALUE *strary)
3960 for (i = s; i < num; ++i) {
3961 const VALUE v = strary[i];
3965 if (encidx != ENCINDEX_US_ASCII) {
3967 rb_enc_associate_index(str, encidx);
3990rb_str_concat_multi(
int argc,
VALUE *argv,
VALUE str)
3992 str_modifiable(str);
3997 else if (argc > 1) {
4000 rb_enc_copy(arg_str, str);
4001 for (i = 0; i < argc; i++) {
4036rb_str_append_as_bytes(
int argc,
VALUE *argv,
VALUE str)
4041 str_modify_keep_cr(str);
4045 for (
int index = 0; index < argc; index++) {
4046 VALUE obj = argv[index];
4059 "wrong argument type %"PRIsVALUE
" (expected String or Integer)",
4066 str_ensure_available_capa(str, needed_capacity);
4069 for (
int index = 0; index < argc; index++) {
4070 VALUE obj = argv[index];
4075 argv[index] = obj = rb_int_and(obj,
INT2FIX(0xff));
4076 char byte = (char)(
NUM2INT(obj) & 0xFF);
4085 memcpy(sptr, ptr,
len);
4090 rb_bug(
"append_as_bytes arguments should have been validated");
4094 STR_SET_LEN(str,
RSTRING_LEN(str) + needed_capacity);
4095 TERM_FILL(sptr, TERM_LEN(str));
4100 for (
int index = 0; index < argc; index++) {
4101 VALUE obj = argv[index];
4118 rb_bug(
"append_as_bytes arguments should have been validated");
4198 str_modify_keep_cr(str1);
4199 enc = STR_ENC_GET(str1);
4202 if (rb_num_to_uint(str2, &code) == 0) {
4215 encidx = rb_ascii8bit_appendable_encoding_index(enc, code);
4218 rb_str_buf_cat_byte(str1, (
unsigned char)code);
4226 switch (
len = rb_enc_codelen(code, enc)) {
4227 case ONIGERR_INVALID_CODE_POINT_VALUE:
4228 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
4230 case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
4236 rb_enc_mbcput(code, buf, enc);
4237 if (rb_enc_precise_mbclen(buf, buf +
len + 1, enc) !=
len) {
4238 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
4240 rb_str_resize(str1, pos+
len);
4254rb_ascii8bit_appendable_encoding_index(rb_encoding *enc,
unsigned int code)
4256 int encidx = rb_enc_to_index(enc);
4258 if (encidx == ENCINDEX_ASCII_8BIT || encidx == ENCINDEX_US_ASCII) {
4263 if (encidx == ENCINDEX_US_ASCII && code > 127) {
4264 return ENCINDEX_ASCII_8BIT;
4286rb_str_prepend_multi(
int argc,
VALUE *argv,
VALUE str)
4288 str_modifiable(str);
4293 else if (argc > 1) {
4296 rb_enc_copy(arg_str, str);
4297 for (i = 0; i < argc; i++) {
4310 st_index_t precomputed_hash;
4311 memcpy(&precomputed_hash,
RSTRING_END(str) + TERM_LEN(str),
sizeof(precomputed_hash));
4313 RUBY_ASSERT(precomputed_hash == str_do_hash(str));
4314 return precomputed_hash;
4317 return str_do_hash(str);
4324 const char *ptr1, *ptr2;
4327 return (len1 != len2 ||
4329 memcmp(ptr1, ptr2, len1) != 0);
4359rb_str_hash_m(
VALUE str)
4365#define lesser(a,b) (((a)>(b))?(b):(a))
4377 if (idx1 == idx2)
return TRUE;
4378 rc1 = rb_enc_str_coderange(str1);
4379 rc2 = rb_enc_str_coderange(str2);
4382 if (rb_enc_asciicompat(rb_enc_from_index(idx2)))
4386 if (rb_enc_asciicompat(rb_enc_from_index(idx1)))
4396 const char *ptr1, *ptr2;
4399 if (str1 == str2)
return 0;
4402 if (ptr1 == ptr2 || (retval = memcmp(ptr1, ptr2, lesser(len1, len2))) == 0) {
4411 if (len1 > len2)
return 1;
4414 if (retval > 0)
return 1;
4448 if (str1 == str2)
return Qtrue;
4453 return rb_equal(str2, str1);
4455 return rb_str_eql_internal(str1, str2);
4486 if (str1 == str2)
return Qtrue;
4488 return rb_str_eql_internal(str1, str2);
4526 return rb_invcmp(str1, str2);
4568 return str_casecmp(str1, s);
4576 const char *p1, *p1end, *p2, *p2end;
4578 enc = rb_enc_compatible(str1, str2);
4585 if (single_byte_optimizable(str1) && single_byte_optimizable(str2)) {
4586 while (p1 < p1end && p2 < p2end) {
4588 unsigned int c1 =
TOLOWER(*p1 & 0xff);
4589 unsigned int c2 =
TOLOWER(*p2 & 0xff);
4591 return INT2FIX(c1 < c2 ? -1 : 1);
4598 while (p1 < p1end && p2 < p2end) {
4599 int l1, c1 = rb_enc_ascget(p1, p1end, &l1, enc);
4600 int l2, c2 = rb_enc_ascget(p2, p2end, &l2, enc);
4602 if (0 <= c1 && 0 <= c2) {
4606 return INT2FIX(c1 < c2 ? -1 : 1);
4610 l1 = rb_enc_mbclen(p1, p1end, enc);
4611 l2 = rb_enc_mbclen(p2, p2end, enc);
4612 len = l1 < l2 ? l1 : l2;
4613 r = memcmp(p1, p2,
len);
4615 return INT2FIX(r < 0 ? -1 : 1);
4617 return INT2FIX(l1 < l2 ? -1 : 1);
4623 if (p1 == p1end && p2 == p2end)
return INT2FIX(0);
4624 if (p1 == p1end)
return INT2FIX(-1);
4657 return str_casecmp_p(str1, s);
4664 VALUE folded_str1, folded_str2;
4665 VALUE fold_opt = sym_fold;
4667 enc = rb_enc_compatible(str1, str2);
4672 if (is_ascii_string(str1) && is_ascii_string(str2)) {
4676 while (p1 < p1end) {
4677 if (*p1 != *p2 &&
TOLOWER((
unsigned char)*p1) !=
TOLOWER((
unsigned char)*p2)) {
4686 folded_str1 = rb_str_downcase(1, &fold_opt, str1);
4687 folded_str2 = rb_str_downcase(1, &fold_opt, str2);
4689 return rb_str_eql(folded_str1, folded_str2);
4693strseq_core(
const char *str_ptr,
const char *str_ptr_end,
rb_len_t str_len,
4696 const char *search_start = str_ptr;
4697 rb_len_t pos, search_len = str_len - offset;
4701 pos =
rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc);
4702 if (pos < 0)
return pos;
4704 if (t == search_start + pos)
break;
4705 search_len -= t - search_start;
4706 if (search_len <= 0)
return -1;
4707 offset += t - search_start;
4710 return pos + offset;
4714#define rb_str_index(str, sub, offset) rb_strseq_index(str, sub, offset, 0)
4715#define rb_str_byteindex(str, sub, offset) rb_strseq_index(str, sub, offset, 1)
4720 const char *str_ptr, *str_ptr_end, *sub_ptr;
4724 enc = rb_enc_check(str, sub);
4725 if (is_broken_string(sub))
return -1;
4733 if (str_len < sub_len)
return -1;
4736 rb_len_t str_len_char, sub_len_char;
4737 int single_byte = single_byte_optimizable(str);
4738 str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc);
4739 sub_len_char = in_byte ? sub_len : str_strlen(sub, enc);
4741 offset += str_len_char;
4742 if (offset < 0)
return -1;
4744 if (str_len_char - offset < sub_len_char)
return -1;
4745 if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte);
4748 if (sub_len == 0)
return offset;
4751 return strseq_core(str_ptr, str_ptr_end, str_len, sub_ptr, sub_len, offset, enc);
4801rb_str_index_m(
int argc,
VALUE *argv,
VALUE str)
4805 rb_encoding *enc = STR_ENC_GET(str);
4808 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
4809 rb_len_t slen = str_strlen(str, enc);
4811 if (pos < 0 ? (pos += slen) < 0 : pos > slen) {
4824 enc, single_byte_optimizable(str));
4834 pos = rb_str_index(str, sub, pos);
4850 if (!single_byte_optimizable(str)) {
4853 const char *p = s + pos;
4854 if (!at_char_boundary(s, p, e, rb_enc_get(str))) {
4856 "offset %"PRIdLEN
" does not land on character boundary", pos);
4929rb_str_byteindex_m(
int argc,
VALUE *argv,
VALUE str)
4935 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
4938 if (pos < 0 ? (pos += slen) < 0 : pos > slen) {
4949 str_ensure_byte_pos(str, pos);
4954 pos = RMATCH_BEG(match, 0);
4960 pos = rb_str_byteindex(str, sub, pos);
4961 if (pos >= 0)
return LEN2NUM(pos);
4967str_rindex(
VALUE str,
VALUE sub,
const char *s, rb_encoding *enc)
4969 const char *hit, *adjusted, *sbeg, *e, *t;
4975 if (slen == 0)
return s - sbeg;
4979 searchlen = s - sbeg + 1;
4981 if (s + slen <= e && memcmp(s, t, slen) == 0) {
4986 hit = memrchr(sbeg, c, searchlen);
4989 if (hit != adjusted) {
4990 searchlen = adjusted - sbeg;
4993 if (hit + slen <= e && memcmp(hit, t, slen) == 0)
4995 searchlen = adjusted - sbeg;
4996 }
while (searchlen > 0);
5006 const char *sbeg, *s;
5010 enc = rb_enc_check(str, sub);
5011 if (is_broken_string(sub))
return -1;
5012 singlebyte = single_byte_optimizable(str);
5014 slen = str_strlen(sub, enc);
5017 if (
len < slen)
return -1;
5019 if (
len - pos < slen) pos =
len - slen;
5020 if (
len == 0)
return pos;
5034 s = str_nth(sbeg,
RSTRING_END(str), pos, enc, singlebyte);
5035 return str_rindex(str, sub, s, enc);
5097rb_str_rindex_m(
int argc,
VALUE *argv,
VALUE str)
5101 rb_encoding *enc = STR_ENC_GET(str);
5104 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
5106 if (pos < 0 && (pos +=
len) < 0) {
5112 if (pos >
len) pos =
len;
5121 enc, single_byte_optimizable(str));
5131 pos = rb_str_rindex(str, sub, pos);
5144 const char *sbeg, *s;
5147 enc = rb_enc_check(str, sub);
5148 if (is_broken_string(sub))
return -1;
5153 if (
len < slen)
return -1;
5154 if (
len - pos < slen) pos =
len - slen;
5155 if (
len == 0)
return pos;
5167 return str_rindex(str, sub, s, enc);
5257rb_str_byterindex_m(
int argc,
VALUE *argv,
VALUE str)
5263 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
5266 if (pos < 0 && (pos +=
len) < 0) {
5272 if (pos >
len) pos =
len;
5278 str_ensure_byte_pos(str, pos);
5283 pos = RMATCH_BEG(match, 0);
5289 pos = rb_str_byterindex(str, sub, pos);
5290 if (pos >= 0)
return LEN2NUM(pos);
5332 switch (OBJ_BUILTIN_TYPE(y)) {
5384rb_str_match_m(
int argc,
VALUE *argv,
VALUE str)
5391 result =
rb_funcallv(get_pat(re), rb_intern(
"match"), argc, argv);
5422rb_str_match_m_p(
int argc,
VALUE *argv,
VALUE str)
5426 re = get_pat(argv[0]);
5427 return rb_reg_match_p(re, str, argc > 1 ?
NUM2LEN(argv[1]) : 0);
5436static enum neighbor_char
5437enc_succ_char(
char *p,
rb_len_t len, rb_encoding *enc)
5442 if (rb_enc_mbminlen(enc) > 1) {
5444 int r = rb_enc_precise_mbclen(p, p +
len, enc), c;
5446 return NEIGHBOR_NOT_CHAR;
5448 c = rb_enc_mbc_to_codepoint(p, p +
len, enc) + 1;
5450 if (!l)
return NEIGHBOR_NOT_CHAR;
5451 if (l !=
len)
return NEIGHBOR_WRAPPED;
5452 rb_enc_mbcput(c, p, enc);
5453 r = rb_enc_precise_mbclen(p, p +
len, enc);
5455 return NEIGHBOR_NOT_CHAR;
5457 return NEIGHBOR_FOUND;
5460 for (i =
len-1; 0 <= i && (
unsigned char)p[i] == 0xff; i--)
5463 return NEIGHBOR_WRAPPED;
5464 ++((
unsigned char*)p)[i];
5465 l = rb_enc_precise_mbclen(p, p+
len, enc);
5469 return NEIGHBOR_FOUND;
5472 memset(p+l, 0xff,
len-l);
5478 for (len2 =
len-1; 0 < len2; len2--) {
5479 l2 = rb_enc_precise_mbclen(p, p+len2, enc);
5483 memset(p+len2+1, 0xff,
len-(len2+1));
5488static enum neighbor_char
5489enc_pred_char(
char *p,
rb_len_t len, rb_encoding *enc)
5493 if (rb_enc_mbminlen(enc) > 1) {
5495 int r = rb_enc_precise_mbclen(p, p +
len, enc), c;
5497 return NEIGHBOR_NOT_CHAR;
5499 c = rb_enc_mbc_to_codepoint(p, p +
len, enc);
5500 if (!c)
return NEIGHBOR_NOT_CHAR;
5503 if (!l)
return NEIGHBOR_NOT_CHAR;
5504 if (l !=
len)
return NEIGHBOR_WRAPPED;
5505 rb_enc_mbcput(c, p, enc);
5506 r = rb_enc_precise_mbclen(p, p +
len, enc);
5508 return NEIGHBOR_NOT_CHAR;
5510 return NEIGHBOR_FOUND;
5513 for (i =
len-1; 0 <= i && (
unsigned char)p[i] == 0; i--)
5516 return NEIGHBOR_WRAPPED;
5517 --((
unsigned char*)p)[i];
5518 l = rb_enc_precise_mbclen(p, p+
len, enc);
5522 return NEIGHBOR_FOUND;
5525 memset(p+l, 0,
len-l);
5531 for (len2 =
len-1; 0 < len2; len2--) {
5532 l2 = rb_enc_precise_mbclen(p, p+len2, enc);
5536 memset(p+len2+1, 0,
len-(len2+1));
5550static enum neighbor_char
5551enc_succ_alnum_char(
char *p,
rb_len_t len, rb_encoding *enc,
char *carry)
5553 enum neighbor_char ret;
5557 char save[ONIGENC_CODE_TO_MBC_MAXLEN];
5561 const int max_gaps = 1;
5563 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5565 ctype = ONIGENC_CTYPE_DIGIT;
5567 ctype = ONIGENC_CTYPE_ALPHA;
5569 return NEIGHBOR_NOT_CHAR;
5572 for (
try = 0;
try <= max_gaps; ++
try) {
5573 ret = enc_succ_char(p,
len, enc);
5574 if (ret == NEIGHBOR_FOUND) {
5575 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5577 return NEIGHBOR_FOUND;
5584 ret = enc_pred_char(p,
len, enc);
5585 if (ret == NEIGHBOR_FOUND) {
5586 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5599 return NEIGHBOR_NOT_CHAR;
5602 if (ctype != ONIGENC_CTYPE_DIGIT) {
5604 return NEIGHBOR_WRAPPED;
5608 enc_succ_char(carry,
len, enc);
5609 return NEIGHBOR_WRAPPED;
5679 rb_enc_cr_str_copy_for_substr(str, orig);
5680 return str_succ(str);
5687 char *sbeg, *s, *e, *last_alnum = 0;
5688 int found_alnum = 0;
5690 char carry[ONIGENC_CODE_TO_MBC_MAXLEN] =
"\1";
5691 rb_len_t carry_pos = 0, carry_len = 1;
5692 enum neighbor_char neighbor = NEIGHBOR_FOUND;
5695 if (slen == 0)
return str;
5697 enc = STR_ENC_GET(str);
5699 s = e = sbeg + slen;
5701 while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
5702 if (neighbor == NEIGHBOR_NOT_CHAR && last_alnum) {
5708 l = rb_enc_precise_mbclen(s, e, enc);
5709 if (!ONIGENC_MBCLEN_CHARFOUND_P(l))
continue;
5710 l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
5711 neighbor = enc_succ_alnum_char(s, l, enc, carry);
5713 case NEIGHBOR_NOT_CHAR:
5715 case NEIGHBOR_FOUND:
5717 case NEIGHBOR_WRAPPED:
5722 carry_pos = s - sbeg;
5727 while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
5728 enum neighbor_char neighbor;
5729 char tmp[ONIGENC_CODE_TO_MBC_MAXLEN];
5730 l = rb_enc_precise_mbclen(s, e, enc);
5731 if (!ONIGENC_MBCLEN_CHARFOUND_P(l))
continue;
5732 l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
5734 neighbor = enc_succ_char(tmp, l, enc);
5736 case NEIGHBOR_FOUND:
5740 case NEIGHBOR_WRAPPED:
5743 case NEIGHBOR_NOT_CHAR:
5746 if (rb_enc_precise_mbclen(s, s+l, enc) != l) {
5748 enc_succ_char(s, l, enc);
5750 if (!rb_enc_asciicompat(enc)) {
5751 MEMCPY(carry, s,
char, l);
5754 carry_pos = s - sbeg;
5758 RESIZE_CAPA(str, slen + carry_len);
5760 s = sbeg + carry_pos;
5761 memmove(s + carry_len, s, slen - carry_pos);
5762 memmove(s, carry, carry_len);
5764 STR_SET_LEN(str, slen);
5765 TERM_FILL(&sbeg[slen], rb_enc_mbminlen(enc));
5766 rb_enc_str_coderange(str);
5781rb_str_succ_bang(
VALUE str)
5854 VALUE end, exclusive;
5858 return rb_str_upto_each(beg, end,
RTEST(exclusive), str_upto_i,
Qnil);
5864 VALUE current, after_end;
5871 enc = rb_enc_check(beg, end);
5872 ascii = (is_ascii_string(beg) && is_ascii_string(end));
5878 if (c > e || (excl && c == e))
return beg;
5880 VALUE str = rb_enc_str_new(&c, 1, enc);
5882 if ((*each)(str, arg))
break;
5883 if (!excl && c == e)
break;
5885 if (excl && c == e)
break;
5897 b = rb_str_to_inum(beg, 10, FALSE);
5898 e = rb_str_to_inum(end, 10, FALSE);
5905 if (excl && bi == ei)
break;
5906 if ((*each)(
rb_enc_sprintf(usascii,
"%.*ld", width, bi), arg))
break;
5911 ID op = excl ?
'<' : idLE;
5912 VALUE args[2], fmt = rb_fstring_lit(
"%.*d");
5917 if ((*each)(
rb_str_format(numberof(args), args, fmt), arg))
break;
5925 if (n > 0 || (excl && n == 0))
return beg;
5933 if ((*each)(current, arg))
break;
5934 if (
NIL_P(next))
break;
5955 VALUE b, args[2], fmt = rb_fstring_lit(
"%.*d");
5957 b = rb_str_to_inum(beg, 10, FALSE);
5963 if ((*each)(
rb_enc_sprintf(usascii,
"%.*ld", width, bi), arg))
break;
5971 if ((*each)(
rb_str_format(numberof(args), args, fmt), arg))
break;
5979 if ((*each)(current, arg))
break;
5993 if (!rb_equal(str, *argp))
return 0;
6007 if (rb_enc_asciicompat(STR_ENC_GET(beg)) &&
6008 rb_enc_asciicompat(STR_ENC_GET(end)) &&
6009 rb_enc_asciicompat(STR_ENC_GET(val))) {
6021 if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
6022 if (b <= v && v < e)
return Qtrue;
6023 return RBOOL(!
RTEST(exclusive) && b <= v && v == e);
6036 rb_str_upto_each(beg, end,
RTEST(exclusive), include_range_i, (
VALUE)&val);
6038 return RBOOL(
NIL_P(val));
6061 return rb_str_subpat(str, indx,
INT2FIX(0));
6064 if (rb_str_index(str, indx, 0) != -1)
6082 return str_substr(str, idx, 1, FALSE);
6194rb_str_aref_m(
int argc,
VALUE *argv,
VALUE str)
6198 return rb_str_subpat(str, argv[0], argv[1]);
6201 return rb_str_substr_two_fixnums(str, argv[0], argv[1], TRUE);
6205 return rb_str_aref(str, argv[0]);
6211 str_modifiable(str);
6216 if (
len > olen)
len = olen;
6218 if (str_embed_capa(str) >= nlen + TERM_LEN(str)) {
6220 size_t old_capa =
RSTRING(str)->as.heap.aux.capa + TERM_LEN(str);
6221 int fl = (int)(
RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE));
6223 ptr =
RSTRING(str)->as.embed.ary;
6224 memmove(ptr, oldptr +
len, nlen);
6225 if (fl == STR_NOEMBED) {
6226 SIZED_FREE_N(oldptr, old_capa);
6230 if (!STR_SHARED_P(str)) {
6232 rb_enc_cr_str_exact_copy(
shared, str);
6237 STR_SET_LEN(str, nlen);
6239 if (!SHARABLE_MIDDLE_SUBSTRING) {
6240 TERM_FILL(ptr + nlen, TERM_LEN(str));
6253 if (beg == 0 && vlen == 0) {
6258 str_modify_keep_cr(str);
6262 rb_raise(rb_eArgError,
"string sizes too big");
6264 if ((
rb_len_t)str_capacity(str, TERM_LEN(str)) < slen + vlen -
len) {
6266 RESIZE_CAPA(str, slen + vlen -
len);
6272 cr = rb_enc_str_coderange(val);
6277 memmove(sptr + beg + vlen,
6279 slen - (beg +
len));
6281 if (vlen < beg &&
len < 0) {
6285 memmove(sptr + beg,
RSTRING_PTR(val) + vbeg, vlen);
6288 STR_SET_LEN(str, slen);
6289 TERM_FILL(&sptr[slen], TERM_LEN(str));
6305 int singlebyte = single_byte_optimizable(str);
6311 enc = rb_enc_check(str, val);
6312 slen = str_strlen(str, enc);
6314 if ((slen < beg) || ((beg < 0) && (beg + slen < 0))) {
6323 if (
len > slen - beg) {
6333 rb_str_update_0(str, beg,
len, val);
6334 rb_enc_associate(str, enc);
6353 int num_regs = RMATCH_NREGS(match);
6354 if (nth >= num_regs || nth + num_regs <= 0) {
6361 start = RMATCH_BEG(match, nth);
6365 end = RMATCH_END(match, nth);
6373 enc = rb_enc_check_str(str, val);
6374 rb_str_update_0(str, start,
len, val);
6375 rb_enc_associate(str, enc);
6383 switch (
TYPE(indx)) {
6385 rb_str_subpat_set(str, indx,
INT2FIX(0), val);
6389 beg = rb_str_index(str, indx, 0);
6606rb_str_aset_m(
int argc,
VALUE *argv,
VALUE str)
6610 rb_str_subpat_set(str, argv[0], argv[1], argv[2]);
6618 return rb_str_aset(str, argv[0], argv[1]);
6684rb_str_slice_bang(
int argc,
VALUE *argv,
VALUE str)
6692 str_modify_keep_cr(str);
6697 int num_regs = RMATCH_NREGS(match);
6700 if ((nth += num_regs) <= 0)
return Qnil;
6702 else if (nth >= num_regs)
return Qnil;
6703 beg = RMATCH_BEG(match, nth);
6704 len = RMATCH_END(match, nth) - beg;
6710 else if (argc == 2) {
6723 beg = rb_str_index(str, indx, 0);
6724 if (beg == -1)
return Qnil;
6750 rb_enc_cr_str_copy_for_substr(result, str);
6760 if (beg +
len > slen)
6764 slen - (beg +
len));
6766 STR_SET_LEN(str, slen);
6767 TERM_FILL(&sptr[slen], TERM_LEN(str));
6778 switch (OBJ_BUILTIN_TYPE(pat)) {
6797get_pat_quoted(
VALUE pat,
int check)
6801 switch (OBJ_BUILTIN_TYPE(pat)) {
6815 if (check && is_broken_string(pat)) {
6825 pos = rb_str_byteindex(str, pat, pos);
6826 if (set_backref_str) {
6828 str = rb_str_new_frozen_String(str);
6831 *match = match_data;
6841 return rb_reg_search0(pat, str, pos, 0, set_backref_str, match);
6848 return rb_pat_search0(pat, str, pos, set_backref_str, NULL);
6866rb_str_sub_bang(
int argc,
VALUE *argv,
VALUE str)
6881 hash = rb_check_hash_type(repl);
6888 pat = get_pat_quoted(argv[0], 1);
6890 str_modifiable(str);
6891 beg = rb_pat_search(pat, str, 0, 1);
6907 beg0 = RMATCH_BEG(match, 0);
6908 end0 = RMATCH_END(match, 0);
6912 if (iter || !
NIL_P(hash)) {
6919 repl = rb_hash_aref(hash,
rb_str_subseq(str, beg0, end0 - beg0));
6922 str_mod_check(str, p,
len);
6923 rb_check_frozen(str);
6926 repl = rb_reg_regsub_match(repl, str, match);
6929 enc = rb_enc_compatible(str, repl);
6931 rb_encoding *str_enc = STR_ENC_GET(str);
6936 rb_enc_inspect_name(str_enc),
6937 rb_enc_inspect_name(STR_ENC_GET(repl)));
6939 enc = STR_ENC_GET(repl);
6942 rb_enc_associate(str, enc);
6955 RESIZE_CAPA(str,
len + rlen - plen);
6959 memmove(p + beg0 + rlen, p + beg0 + plen,
len - beg0 - plen);
6962 memmove(p + beg0, rp, rlen);
6964 STR_SET_LEN(str,
len);
7020 rb_str_sub_bang(argc, argv, str);
7025str_gsub(
int argc,
VALUE *argv,
VALUE str,
int bang)
7030 enum {STR, ITER, FAST_MAP, MAP} mode = STR;
7032 int need_backref_str = -1;
7033 rb_encoding *str_enc;
7043 hash = rb_check_hash_type(repl);
7047 else if (rb_hash_default_unredefined(hash) && !
FL_TEST_RAW(hash, RHASH_PROC_DEFAULT)) {
7056 rb_error_arity(argc, 1, 2);
7059 pat = get_pat_quoted(argv[0], 1);
7060 beg = rb_pat_search0(pat, str, 0, need_backref_str, &match);
7063 if (bang)
return Qnil;
7066 if (bang) str_modify_keep_cr(str);
7074 str_enc = STR_ENC_GET(str);
7075 rb_enc_associate(dest, str_enc);
7085 beg0 = RMATCH_BEG(match, 0);
7086 end0 = RMATCH_END(match, 0);
7095 struct RString fake_str = {RBASIC_INIT};
7097 if (mode == FAST_MAP) {
7106 val = rb_hash_aref(hash, key);
7109 str_mod_check(str, sp, slen);
7114 else if (need_backref_str) {
7115 val = rb_reg_regsub_match(repl, str, match);
7116 if (need_backref_str < 0) {
7117 need_backref_str = val != repl;
7124 len = beg0 - offset;
7141 offset = end0 +
len;
7147 if (mode != FAST_MAP && mode != STR) {
7150 beg = rb_pat_search0(pat, str, offset, need_backref_str, &match);
7158 rb_pat_search0(pat, str, last, 1, &match);
7160 str_shared_replace(str, dest);
7185rb_str_gsub_bang(
int argc,
VALUE *argv,
VALUE str)
7187 str_modifiable(str);
7188 return str_gsub(argc, argv, str, 1);
7238 return str_gsub(argc, argv, str, 0);
7258 str_modifiable(str);
7259 if (str == str2)
return str;
7263 return str_replace(str, str2);
7280rb_str_clear(
VALUE str)
7284 STR_SET_LEN(str, 0);
7286 if (rb_enc_asciicompat(STR_ENC_GET(str)))
7308rb_str_chr(
VALUE str)
7372 char *ptr, *head, *left = 0;
7378 char byte = (char)(
NUM2INT(w) & 0xFF);
7380 if (!str_independent(str))
7381 str_make_independent(str);
7384 if (pos < -
len ||
len <= pos)
7389 enc = STR_ENC_GET(str);
7392 if (!STR_EMBED_P(str)) {
7398 if (ISASCII(
byte))
goto end;
7399 nlen = rb_enc_precise_mbclen(left, head+
len, enc);
7407 width = rb_enc_precise_mbclen(left, head+
len, enc);
7409 nlen = rb_enc_precise_mbclen(left, head+
len, enc);
7425str_bit_offset_out_of_range(
rb_len_t byte_len, uint64_t bit_offset)
7428 return bit_offset / CHAR_BIT >= (uint64_t)byte_len;
7444str_bit_offset_from_index(
VALUE index)
7457 offset.index_value =
FIX2LONG(integer);
7458 if (offset.index_value < 0) {
7461 offset.value = (uint64_t)offset.index_value;
7462 offset.fits_index =
true;
7467 if (rb_int_negative_p(integer)) {
7470 if (rb_cmpint(rb_int_cmp(integer,
ULL2NUM(UINT64_MAX)), integer,
ULL2NUM(UINT64_MAX)) > 0) {
7471 rb_raise(
rb_eArgError,
"bit index out of representable range");
7474 offset.value = (uint64_t)
NUM2ULL(integer);
7476 offset.index_value = (
rb_len_t)offset.value;
7477 offset.fits_index =
true;
7480 offset.index_value = 0;
7481 offset.fits_index =
false;
7491str_bit_length_from_index(
VALUE index)
7498 rb_raise(rb_eArgError,
"negative bit length");
7500 return (uint64_t)value;
7504 if (rb_int_negative_p(integer)) {
7505 rb_raise(rb_eArgError,
"negative bit length");
7507 if (rb_cmpint(rb_int_cmp(integer,
ULL2NUM(UINT64_MAX)), integer,
ULL2NUM(UINT64_MAX)) > 0) {
7508 rb_raise(rb_eArgError,
"bit length out of representable range");
7510 return (uint64_t)
NUM2ULL(integer);
7513static inline uint64_t
7520 if ((uint64_t)byte_len > UINT64_MAX / CHAR_BIT)
return UINT64_MAX;
7521 return (uint64_t)byte_len * CHAR_BIT;
7526 uint64_t end_exclusive;
7549 out->beg =
NIL_P(beg_v) ? 0 : str_bit_offset_from_index(beg_v).value;
7551 out->end_open =
true;
7552 out->end_exclusive = 0;
7555 uint64_t end = str_bit_offset_from_index(end_v).value;
7556 out->end_open =
false;
7561 out->end_exclusive = (excl || end == UINT64_MAX) ? end : end + 1;
7571str_bit_range_resolve(
const struct str_bit_range *range, uint64_t total_bits, uint64_t *begp, uint64_t *lenp)
7573 uint64_t beg = range->beg;
7574 if (beg > total_bits)
return false;
7576 uint64_t end_exclusive = range->end_open ? total_bits : range->end_exclusive;
7577 if (end_exclusive < beg) end_exclusive = beg;
7580 *lenp = end_exclusive - beg;
7585str_lsb_first_from_opts(
VALUE opts)
7587 static ID keywords[1];
7595 if (vlsb_first ==
Qundef || vlsb_first ==
Qtrue) {
7598 if (vlsb_first ==
Qfalse) {
7601 rb_raise(rb_eArgError,
"lsb_first must be true or false");
7606str_lsb_first(
int argc,
VALUE *argv,
VALUE *index)
7611 return str_lsb_first_from_opts(opts);
7614static inline uint64_t
7615str_logical_to_physical_bit64(uint64_t logical,
bool lsb_first)
7617 return lsb_first ? logical : ((logical & ~(uint64_t)7) | (7 - (logical & 7)));
7621str_logical_to_physical_bit(
rb_len_t logical,
bool lsb_first)
7623 return lsb_first ? logical : ((logical & ~7L) | (7 - (logical & 7L)));
7628 unsigned int bit_offset;
7632str_bit_location_from_offset(uint64_t logical, bool lsb_first)
7638 uint64_t physical = str_logical_to_physical_bit64(logical, lsb_first);
7640 location.byte_index = (
rb_len_t)(physical / CHAR_BIT);
7641 location.bit_offset = (
unsigned int)(physical % CHAR_BIT);
7646str_get_bit(
const char *ptr,
rb_len_t bit_index)
7648 return (((
unsigned char)ptr[bit_index / CHAR_BIT]) >> (bit_index % CHAR_BIT)) & 1;
7654 return (((
unsigned char)ptr[location.byte_index]) >> location.bit_offset) & 1;
7661 bool lsb_first = str_lsb_first(argc, argv, &index);
7664 if (str_bit_offset_out_of_range(RSTRING_LEN(str), offset.value)) {
7668 if (offset.fits_index) {
7669 return str_get_bit(RSTRING_PTR(str), str_logical_to_physical_bit(offset.index_value, lsb_first));
7672 return str_get_bit_location(RSTRING_PTR(str), str_bit_location_from_offset(offset.value, lsb_first));
7703rb_str_bit_get(
int argc,
VALUE *argv,
VALUE str)
7705 int bit = str_bit_get(argc, argv, str);
7736rb_str_bit_set_p(
int argc,
VALUE *argv,
VALUE str)
7738 int bit = str_bit_get(argc, argv, str);
7739 return bit < 0 ?
Qnil : RBOOL(bit);
7742enum str_bit_mutation {
7753static inline unsigned char
7754str_bit_region_byte_mask(
unsigned int lo,
unsigned int hi,
bool lsb_first)
7757 return (
unsigned char)((0xFFu >> (7 - hi)) & (0xFFu << lo));
7760 return (
unsigned char)((0xFFu >> lo) & (0xFFu << (7 - hi)));
7765str_apply_bit_mask(
unsigned char *
byte,
unsigned char mask,
enum str_bit_mutation mutation)
7772 *
byte &= (
unsigned char)~mask;
7782str_mutate_bit_region(
unsigned char *ptr, uint64_t beg, uint64_t
len,
bool lsb_first,
enum str_bit_mutation mutation)
7784 uint64_t first_bit = beg;
7785 uint64_t last_bit = beg +
len - 1;
7788 unsigned int first_off = (
unsigned int)(first_bit % CHAR_BIT);
7789 unsigned int last_off = (
unsigned int)(last_bit % CHAR_BIT);
7791 if (first_byte == last_byte) {
7792 str_apply_bit_mask(ptr + first_byte, str_bit_region_byte_mask(first_off, last_off, lsb_first), mutation);
7796 str_apply_bit_mask(ptr + first_byte, str_bit_region_byte_mask(first_off, 7, lsb_first), mutation);
7797 rb_len_t middle_len = last_byte - first_byte - 1;
7798 if (middle_len > 0) {
7799 unsigned char *middle = ptr + first_byte + 1;
7802 memset(middle, 0xFF, middle_len);
7805 memset(middle, 0, middle_len);
7813 for (
rb_len_t i = 0; i < middle_len; i++) {
7819 str_apply_bit_mask(ptr + last_byte, str_bit_region_byte_mask(0, last_off, lsb_first), mutation);
7823str_mutate_single_bit(
VALUE str,
VALUE index,
bool lsb_first,
enum str_bit_mutation mutation)
7831 rb_check_frozen(str);
7833 if (str_bit_offset_out_of_range(RSTRING_LEN(str), offset.value)) {
7838 ptr = (
unsigned char *)RSTRING_PTR(str);
7839 if (offset.fits_index) {
7840 bit_index = str_logical_to_physical_bit(offset.index_value, lsb_first);
7841 mask = (
unsigned char)(1u << (bit_index % CHAR_BIT));
7842 location.byte_index = bit_index / CHAR_BIT;
7845 location = str_bit_location_from_offset(offset.value, lsb_first);
7846 mask = (
unsigned char)(1u << location.bit_offset);
7849 str_apply_bit_mask(ptr + location.byte_index, mask, mutation);
7854str_mutate_bit(
int argc,
VALUE *argv,
VALUE str,
enum str_bit_mutation mutation)
7856 VALUE target, length_v, opts;
7857 uint64_t beg = 0,
len = 0;
7860 int nargs =
rb_scan_args(argc, argv,
"11:", &target, &length_v, &opts);
7861 bool lsb_first = str_lsb_first_from_opts(opts);
7864 if (nargs == 1 && !is_range) {
7865 return str_mutate_single_bit(str, target, lsb_first, mutation);
7872 rb_raise(rb_eArgError,
"bit length not allowed with a Range");
7874 str_bit_range_to_offsets(target, &range);
7877 offset = str_bit_offset_from_index(target);
7878 len = str_bit_length_from_index(length_v);
7882 rb_check_frozen(str);
7890 uint64_t total_bits = str_bit_size(RSTRING_LEN(str));
7892 if (!str_bit_range_resolve(&range, total_bits, &beg, &
len) ||
len > total_bits - beg) {
7898 if (beg > total_bits ||
len > total_bits - beg) {
7903 if (
len == 0)
return str;
7906 str_mutate_bit_region((
unsigned char *)RSTRING_PTR(str), beg,
len, lsb_first, mutation);
7953rb_str_bit_set(
int argc,
VALUE *argv,
VALUE str)
7955 return str_mutate_bit(argc, argv, str, STR_BIT_SET);
8001rb_str_bit_clear(
int argc,
VALUE *argv,
VALUE str)
8003 return str_mutate_bit(argc, argv, str, STR_BIT_CLEAR);
8049rb_str_bit_flip(
int argc,
VALUE *argv,
VALUE str)
8051 return str_mutate_bit(argc, argv, str, STR_BIT_FLIP);
8055str_count_bits(
const unsigned char *ptr,
rb_len_t len)
8063 for (;
off < unrolled_end;
off += 32) {
8064 uint64_t w0, w1, w2, w3;
8065 memcpy(&w0, ptr +
off, 8);
8066 memcpy(&w1, ptr +
off + 8, 8);
8067 memcpy(&w2, ptr +
off + 16, 8);
8068 memcpy(&w3, ptr +
off + 24, 8);
8069 count += rb_popcount64(w0);
8070 count += rb_popcount64(w1);
8071 count += rb_popcount64(w2);
8072 count += rb_popcount64(w3);
8076 for (;
off < aligned_end;
off += 8) {
8078 memcpy(&word, ptr +
off, 8);
8079 count += rb_popcount64(word);
8086 for (;
off <
len;
off++, shift += CHAR_BIT) {
8087 word |= (uint64_t)ptr[
off] << shift;
8089 count += rb_popcount64(word);
8096str_count_bits_region(
const unsigned char *ptr, uint64_t beg, uint64_t
len,
bool lsb_first)
8098 uint64_t first_bit = beg;
8099 uint64_t last_bit = beg +
len - 1;
8102 unsigned int first_off = (
unsigned int)(first_bit % CHAR_BIT);
8103 unsigned int last_off = (
unsigned int)(last_bit % CHAR_BIT);
8105 if (first_byte == last_byte) {
8106 return rb_popcount32((uint32_t)(ptr[first_byte] & str_bit_region_byte_mask(first_off, last_off, lsb_first)));
8109 uint64_t count = rb_popcount32((uint32_t)(ptr[first_byte] & str_bit_region_byte_mask(first_off, 7, lsb_first)));
8110 count += str_count_bits(ptr + first_byte + 1, last_byte - first_byte - 1);
8111 count += rb_popcount32((uint32_t)(ptr[last_byte] & str_bit_region_byte_mask(0, last_off, lsb_first)));
8162rb_str_bit_count(
int argc,
VALUE *argv,
VALUE str)
8165 uint64_t beg = 0,
len = 0;
8168 int nargs =
rb_scan_args(argc, argv,
"02:", &v0, &v1, &opts);
8173 bool lsb_first = str_lsb_first_from_opts(opts);
8176 return ULL2NUM(str_count_bits((
const unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str)));
8183 rb_raise(rb_eArgError,
"bit length not allowed with a Range");
8185 str_bit_range_to_offsets(v0, &range);
8187 else if (nargs == 1) {
8188 rb_raise(rb_eArgError,
"no bit length given");
8191 beg = str_bit_offset_from_index(v0).value;
8192 len = str_bit_length_from_index(v1);
8195 const unsigned char *ptr = (
const unsigned char *)RSTRING_PTR(str);
8196 uint64_t total_bits = str_bit_size(RSTRING_LEN(str));
8198 if (!str_bit_range_resolve(&range, total_bits, &beg, &
len)) {
8202 else if (beg >= total_bits) {
8207 if (
len > total_bits - beg)
len = total_bits - beg;
8209 return ULL2NUM(str_count_bits_region(ptr, beg,
len, lsb_first));
8213str_check_bitwise_length(
VALUE str,
VALUE other)
8215 if (RSTRING_LEN(str) != RSTRING_LEN(other)) {
8216 rb_raise(rb_eArgError,
"operands must have the same length (%"PRIdLEN
" vs %"PRIdLEN
")",
8217 RSTRING_LEN(str), RSTRING_LEN(other));
8222str_bitwise_result(
VALUE str)
8226 rb_str_resize(result,
len);
8232#define STR_DEFINE_UNARY_BITWISE_KERNEL(name, expr_word, expr_byte) \
8234 name(unsigned char *dst, const unsigned char *src, rb_len_t len) \
8237 rb_len_t unrolled_end = len & ~31L; \
8238 rb_len_t aligned_end = len & ~7L; \
8239 for (; off < unrolled_end; off += 32) { \
8240 uint64_t s0, s1, s2, s3; \
8241 memcpy(&s0, src + off, 8); \
8242 memcpy(&s1, src + off + 8, 8); \
8243 memcpy(&s2, src + off + 16, 8); \
8244 memcpy(&s3, src + off + 24, 8); \
8245 s0 = (expr_word(s0)); \
8246 s1 = (expr_word(s1)); \
8247 s2 = (expr_word(s2)); \
8248 s3 = (expr_word(s3)); \
8249 memcpy(dst + off, &s0, 8); \
8250 memcpy(dst + off + 8, &s1, 8); \
8251 memcpy(dst + off + 16, &s2, 8); \
8252 memcpy(dst + off + 24, &s3, 8); \
8254 for (; off < aligned_end; off += 8) { \
8256 memcpy(&word, src + off, 8); \
8257 word = (expr_word(word)); \
8258 memcpy(dst + off, &word, 8); \
8260 for (; off < len; off++) dst[off] = (expr_byte(src[off])); \
8263#define STR_DEFINE_BINARY_BITWISE_KERNEL(name, expr_word, expr_byte) \
8265 name(unsigned char *dst, const unsigned char *lhs, \
8266 const unsigned char *rhs, rb_len_t len) \
8269 rb_len_t unrolled_end = len & ~31L; \
8270 rb_len_t aligned_end = len & ~7L; \
8271 for (; off < unrolled_end; off += 32) { \
8272 uint64_t l0, l1, l2, l3, r0, r1, r2, r3; \
8273 memcpy(&l0, lhs + off, 8); memcpy(&r0, rhs + off, 8); \
8274 memcpy(&l1, lhs + off + 8, 8); memcpy(&r1, rhs + off + 8, 8); \
8275 memcpy(&l2, lhs + off + 16, 8); memcpy(&r2, rhs + off + 16, 8); \
8276 memcpy(&l3, lhs + off + 24, 8); memcpy(&r3, rhs + off + 24, 8); \
8277 l0 = expr_word(l0, r0); \
8278 l1 = expr_word(l1, r1); \
8279 l2 = expr_word(l2, r2); \
8280 l3 = expr_word(l3, r3); \
8281 memcpy(dst + off, &l0, 8); \
8282 memcpy(dst + off + 8, &l1, 8); \
8283 memcpy(dst + off + 16, &l2, 8); \
8284 memcpy(dst + off + 24, &l3, 8); \
8286 for (; off < aligned_end; off += 8) { \
8287 uint64_t lhs_word, rhs_word; \
8288 memcpy(&lhs_word, lhs + off, 8); \
8289 memcpy(&rhs_word, rhs + off, 8); \
8290 lhs_word = expr_word(lhs_word, rhs_word); \
8291 memcpy(dst + off, &lhs_word, 8); \
8293 for (; off < len; off++) dst[off] = expr_byte(lhs[off], rhs[off]); \
8296#define STR_BITWISE_NOT_WORD(x) (~(x))
8297#define STR_BITWISE_NOT_BYTE(x) ((unsigned char)~(x))
8298#define STR_BITWISE_AND_WORD(x, y) ((x) & (y))
8299#define STR_BITWISE_AND_BYTE(x, y) ((unsigned char)((x) & (y)))
8300#define STR_BITWISE_OR_WORD(x, y) ((x) | (y))
8301#define STR_BITWISE_OR_BYTE(x, y) ((unsigned char)((x) | (y)))
8302#define STR_BITWISE_XOR_WORD(x, y) ((x) ^ (y))
8303#define STR_BITWISE_XOR_BYTE(x, y) ((unsigned char)((x) ^ (y)))
8305STR_DEFINE_UNARY_BITWISE_KERNEL(str_bitwise_not, STR_BITWISE_NOT_WORD, STR_BITWISE_NOT_BYTE)
8306STR_DEFINE_BINARY_BITWISE_KERNEL(str_bitwise_and, STR_BITWISE_AND_WORD, STR_BITWISE_AND_BYTE)
8307STR_DEFINE_BINARY_BITWISE_KERNEL(str_bitwise_or, STR_BITWISE_OR_WORD, STR_BITWISE_OR_BYTE)
8308STR_DEFINE_BINARY_BITWISE_KERNEL(str_bitwise_xor, STR_BITWISE_XOR_WORD, STR_BITWISE_XOR_BYTE)
8322rb_str_bitwise_not(
VALUE str)
8325 VALUE result = str_bitwise_result(str);
8326 str_bitwise_not((
unsigned char *)RSTRING_PTR(result),
8327 (
const unsigned char *)RSTRING_PTR(str),
len);
8345rb_str_bitwise_not_bang(
VALUE str)
8351 len = RSTRING_LEN(str);
8352 ptr = (
unsigned char *)RSTRING_PTR(str);
8353 str_bitwise_not(ptr, ptr,
len);
8462#define STR_DEFINE_BINARY_BITWISE_METHOD(name) \
8464 rb_str_bitwise_##name(VALUE str, VALUE other) \
8468 StringValue(other); \
8469 str_check_bitwise_length(str, other); \
8470 len = RSTRING_LEN(str); \
8471 result = str_bitwise_result(str); \
8472 str_bitwise_##name((unsigned char *)RSTRING_PTR(result), \
8473 (const unsigned char *)RSTRING_PTR(str), \
8474 (const unsigned char *)RSTRING_PTR(other), len); \
8478 rb_str_bitwise_##name##_bang(VALUE str, VALUE other) \
8481 unsigned char *ptr; \
8482 StringValue(other); \
8483 str_check_bitwise_length(str, other); \
8484 rb_str_modify(str); \
8485 len = RSTRING_LEN(str); \
8486 ptr = (unsigned char *)RSTRING_PTR(str); \
8487 str_bitwise_##name(ptr, ptr, \
8488 (const unsigned char *)RSTRING_PTR(other), len); \
8492STR_DEFINE_BINARY_BITWISE_METHOD(and)
8493STR_DEFINE_BINARY_BITWISE_METHOD(or)
8494STR_DEFINE_BINARY_BITWISE_METHOD(xor)
8501 if (beg > n ||
len < 0)
return Qnil;
8504 if (beg < 0)
return Qnil;
8509 if (!empty)
return Qnil;
8513 VALUE str2 = str_subseq(str, beg,
len);
8515 str_enc_copy_direct(str2, str);
8517 if (RSTRING_LEN(str2) == 0) {
8518 if (!rb_enc_asciicompat(STR_ENC_GET(str)))
8560 return str_byte_substr(str, beg,
len, TRUE);
8565 return str_byte_substr(str, idx, 1, FALSE);
8630rb_str_byteslice(
int argc,
VALUE *argv,
VALUE str)
8635 return str_byte_substr(str, beg,
len, TRUE);
8638 return str_byte_aref(str, argv[0]);
8644 rb_len_t end, slen = RSTRING_LEN(str);
8647 if ((slen < *beg) || ((*beg < 0) && (*beg + slen < 0))) {
8648 rb_raise(
rb_eIndexError,
"index %"PRIdLEN
" out of string", *beg);
8656 if (*
len > slen - *beg) {
8660 str_ensure_byte_pos(str, *beg);
8661 str_ensure_byte_pos(str, end);
8739rb_str_bytesplice(
int argc,
VALUE *argv,
VALUE str)
8746 if (!(argc == 2 || argc == 3 || argc == 5)) {
8747 rb_raise(rb_eArgError,
"wrong number of arguments (given %d, expected 2, 3, or 5)", argc);
8751 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Range)",
8752 rb_builtin_class_name(argv[0]));
8759 vlen = RSTRING_LEN(val);
8764 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Range)",
8765 rb_builtin_class_name(argv[2]));
8777 vlen = RSTRING_LEN(val);
8785 str_check_beg_len(str, &beg, &
len);
8786 str_check_beg_len(val, &vbeg, &vlen);
8787 str_modify_keep_cr(str);
8790 rb_enc_associate(str, rb_enc_check(str, val));
8793 rb_str_update_1(str, beg,
len, val, vbeg, vlen);
8815rb_str_reverse(
VALUE str)
8822 if (RSTRING_LEN(str) <= 1)
return str_duplicate(
rb_cString, str);
8823 enc = STR_ENC_GET(str);
8824 rev = str_enc_new(
rb_cString, 0, RSTRING_LEN(str), enc);
8829 if (RSTRING_LEN(str) > 1) {
8830 if (single_byte_optimizable(str)) {
8837 int clen = rb_enc_fast_mbclen(s, e, enc);
8845 cr = rb_enc_asciicompat(enc) ?
8848 int clen = rb_enc_mbclen(s, e, enc);
8857 STR_SET_LEN(rev, RSTRING_LEN(str));
8879rb_str_reverse_bang(
VALUE str)
8881 if (RSTRING_LEN(str) > 1) {
8882 if (single_byte_optimizable(str)) {
8885 str_modify_keep_cr(str);
8886 s = RSTRING_PTR(str);
8895 str_shared_replace(str, rb_str_reverse(str));
8899 str_modify_keep_cr(str);
8928 i = rb_str_index(str, arg, 0);
8930 return RBOOL(i != -1);
8974 rb_raise(rb_eArgError,
"invalid radix %d", base);
8976 return rb_str_to_inum(str, base, FALSE);
9001rb_str_to_f(
VALUE str)
9018rb_str_to_s(
VALUE str)
9028str_cat_char(
VALUE str,
unsigned int c, rb_encoding *enc)
9030 char s[RUBY_MAX_CHAR_LEN];
9031 int n = rb_enc_codelen(c, enc);
9033 rb_enc_mbcput(c, s, enc);
9038#define CHAR_ESC_LEN 13
9041rb_str_buf_cat_escaped_char(
VALUE result,
unsigned int c,
int unicode_p)
9043 char buf[CHAR_ESC_LEN + 1];
9051 snprintf(buf, CHAR_ESC_LEN,
"%c", c);
9053 else if (c < 0x10000) {
9054 snprintf(buf, CHAR_ESC_LEN,
"\\u%04X", c);
9057 snprintf(buf, CHAR_ESC_LEN,
"\\u{%X}", c);
9062 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", c);
9065 snprintf(buf, CHAR_ESC_LEN,
"\\x{%X}", c);
9068 l = (int)strlen(buf);
9074ruby_escaped_char(
int c)
9077 case '\0':
return "\\0";
9078 case '\n':
return "\\n";
9079 case '\r':
return "\\r";
9080 case '\t':
return "\\t";
9081 case '\f':
return "\\f";
9082 case '\013':
return "\\v";
9083 case '\010':
return "\\b";
9084 case '\007':
return "\\a";
9085 case '\033':
return "\\e";
9086 case '\x7f':
return "\\c?";
9092rb_str_escape(
VALUE str)
9095 rb_encoding *enc = rb_enc_from_index(encidx);
9096 const char *p = RSTRING_PTR(str);
9098 const char *prev = p;
9099 char buf[CHAR_ESC_LEN + 1];
9101 int unicode_p = rb_enc_unicode_p(enc);
9102 int asciicompat = rb_enc_asciicompat(enc);
9107 int n = rb_enc_precise_mbclen(p, pend, enc);
9109 if (p > prev) str_buf_cat(result, prev, p - prev);
9110 n = rb_enc_mbminlen(enc);
9112 n = (int)(pend - p);
9114 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", *p & 0377);
9115 str_buf_cat(result, buf, strlen(buf));
9121 c = rb_enc_mbc_to_codepoint(p, pend, enc);
9123 cc = ruby_escaped_char(c);
9125 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
9126 str_buf_cat(result, cc, strlen(cc));
9129 else if (asciicompat && rb_enc_isascii(c, enc) &&
ISPRINT(c)) {
9132 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
9133 rb_str_buf_cat_escaped_char(result, c, unicode_p);
9137 if (p > prev) str_buf_cat(result, prev, p - prev);
9147static const bool inspect_no_escape[256] = {
9148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9150 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
9151 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
9152 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
9153 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
9154 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
9155 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
9207 rb_encoding *enc = rb_enc_from_index(encidx);
9208 const char *p, *pend, *prev;
9209 char buf[CHAR_ESC_LEN + 1];
9212 int unicode_p = rb_enc_unicode_p(enc);
9213 int asciicompat = rb_enc_asciicompat(enc);
9214 int cr = rb_enc_str_coderange(str);
9218 rb_enc_associate(result, resenc);
9219 str_buf_cat2(result,
"\"");
9232 while (p < pend && inspect_no_escape[(
unsigned char)*p]) p++;
9233 if (p >= pend)
break;
9236 n = rb_enc_precise_mbclen(p, pend, enc);
9238 if (p > prev) str_buf_cat(result, prev, p - prev);
9239 n = rb_enc_mbminlen(enc);
9241 n = (int)(pend - p);
9243 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", *p & 0377);
9244 str_buf_cat(result, buf, strlen(buf));
9250 c = rb_enc_mbc_to_codepoint(p, pend, enc);
9252 if ((asciicompat || unicode_p) &&
9253 (c ==
'"'|| c ==
'\\' ||
9258 (cc ==
'$' || cc ==
'@' || cc ==
'{'))))) {
9259 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
9260 str_buf_cat2(result,
"\\");
9261 if (asciicompat || enc == resenc) {
9267 case '\n': cc =
'n';
break;
9268 case '\r': cc =
'r';
break;
9269 case '\t': cc =
't';
break;
9270 case '\f': cc =
'f';
break;
9271 case '\013': cc =
'v';
break;
9272 case '\010': cc =
'b';
break;
9273 case '\007': cc =
'a';
break;
9274 case 033: cc =
'e';
break;
9275 default: cc = 0;
break;
9278 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
9281 str_buf_cat(result, buf, 2);
9294 (asciicompat && rb_enc_isascii(c, enc) &&
ISPRINT(c))) {
9298 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
9299 rb_str_buf_cat_escaped_char(result, c, unicode_p);
9304 if (p > prev) str_buf_cat(result, prev, p - prev);
9305 str_buf_cat2(result,
"\"");
9310#define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
9411 int encidx = rb_enc_get_index(str);
9412 rb_encoding *enc = rb_enc_from_index(encidx);
9414 const char *p, *pend;
9418 static const char nonascii_suffix[] =
".dup.force_encoding(\"%s\")";
9421 if (!rb_enc_asciicompat(enc)) {
9423 len += strlen(enc->name);
9426 p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
9429 unsigned char c = *p++;
9432 case '"':
case '\\':
9433 case '\n':
case '\r':
9434 case '\t':
case '\f':
9435 case '\013':
case '\010':
case '\007':
case '\033':
9440 clen = IS_EVSTR(p, pend) ? 2 : 1;
9448 if (u8 && c > 0x7F) {
9449 int n = rb_enc_precise_mbclen(p-1, pend, enc);
9451 unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
9454 else if (cc <= 0xFFFFF)
9474 p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
9475 q = RSTRING_PTR(result); qend = q +
len + 1;
9479 unsigned char c = *p++;
9481 if (c ==
'"' || c ==
'\\') {
9485 else if (c ==
'#') {
9486 if (IS_EVSTR(p, pend)) *q++ =
'\\';
9489 else if (c ==
'\n') {
9493 else if (c ==
'\r') {
9497 else if (c ==
'\t') {
9501 else if (c ==
'\f') {
9505 else if (c ==
'\013') {
9509 else if (c ==
'\010') {
9513 else if (c ==
'\007') {
9517 else if (c ==
'\033') {
9527 int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1;
9529 int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
9532 snprintf(q, qend-q,
"u%04X", cc);
9534 snprintf(q, qend-q,
"u{%X}", cc);
9539 snprintf(q, qend-q,
"x%02X", c);
9545 if (!rb_enc_asciicompat(enc)) {
9546 snprintf(q, qend-q, nonascii_suffix, enc->name);
9550 rb_enc_associate_index(result, encidx);
9556unescape_ascii(
unsigned int c)
9580undump_after_backslash(
VALUE undumped,
const char **ss,
const char *s_end, rb_encoding **penc,
bool *utf8,
bool *binary)
9582 const char *s = *ss;
9586 unsigned char buf[6];
9587 static rb_encoding *enc_utf8 = NULL;
9604 *buf = unescape_ascii(*s);
9617 if (*penc != enc_utf8) {
9619 rb_enc_associate(undumped, enc_utf8);
9636 if (hexlen == 0 || hexlen > 6) {
9642 if (0xd800 <= c && c <= 0xdfff) {
9645 codelen = rb_enc_mbcput(c, (
char *)buf, *penc);
9655 if (0xd800 <= c && c <= 0xdfff) {
9658 codelen = rb_enc_mbcput(c, (
char *)buf, *penc);
9671 if (!ISASCII(*buf)) {
9688static VALUE rb_str_is_ascii_only_p(
VALUE str);
9700str_undump(
VALUE str)
9702 const char *s = RSTRING_PTR(str);
9704 rb_encoding *enc = rb_enc_get(str);
9705 VALUE undumped = rb_enc_str_new(s, 0L, enc);
9707 bool binary =
false;
9711 if (rb_str_is_ascii_only_p(str) ==
Qfalse) {
9714 if (!str_null_check(str, &w)) {
9717 if (RSTRING_LEN(str) < 2)
goto invalid_format;
9718 if (*s !=
'"')
goto invalid_format;
9736 static const char force_encoding_suffix[] =
".force_encoding(\"";
9737 static const char dup_suffix[] =
".dup";
9738 const char *encname;
9743 size =
sizeof(dup_suffix) - 1;
9744 if (s_end - s > size && memcmp(s, dup_suffix, size) == 0) s += size;
9746 size =
sizeof(force_encoding_suffix) - 1;
9747 if (s_end - s <= size)
goto invalid_format;
9748 if (memcmp(s, force_encoding_suffix, size) != 0)
goto invalid_format;
9752 rb_raise(
rb_eRuntimeError,
"dumped string contained Unicode escape but used force_encoding");
9756 s = memchr(s,
'"', s_end-s);
9758 if (!s)
goto invalid_format;
9759 if (s_end - s != 2)
goto invalid_format;
9760 if (s[0] !=
'"' || s[1] !=
')')
goto invalid_format;
9762 encidx = rb_enc_find_index2(encname, (
rb_len_t)size);
9766 rb_enc_associate_index(undumped, encidx);
9776 undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary);
9787 rb_raise(
rb_eRuntimeError,
"invalid dumped string; not wrapped with '\"' nor '\"...\".force_encoding(\"...\")' form");
9791rb_str_check_dummy_enc(rb_encoding *enc)
9793 if (rb_enc_dummy_p(enc)) {
9800str_true_enc(
VALUE str)
9802 rb_encoding *enc = STR_ENC_GET(str);
9803 rb_str_check_dummy_enc(enc);
9807static OnigCaseFoldType
9808check_case_options(
int argc,
VALUE *argv, OnigCaseFoldType flags)
9813 rb_raise(rb_eArgError,
"too many options");
9814 if (argv[0]==sym_turkic) {
9815 flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
9817 if (argv[1]==sym_lithuanian)
9818 flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
9820 rb_raise(rb_eArgError,
"invalid second option");
9823 else if (argv[0]==sym_lithuanian) {
9824 flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
9826 if (argv[1]==sym_turkic)
9827 flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
9829 rb_raise(rb_eArgError,
"invalid second option");
9833 rb_raise(rb_eArgError,
"too many options");
9834 else if (argv[0]==sym_ascii)
9835 flags |= ONIGENC_CASE_ASCII_ONLY;
9836 else if (argv[0]==sym_fold) {
9837 if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE)
9838 flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE;
9840 rb_raise(rb_eArgError,
"option :fold only allowed for downcasing");
9843 rb_raise(rb_eArgError,
"invalid option");
9848case_option_single_p(OnigCaseFoldType flags, rb_encoding *enc,
VALUE str)
9852 return !(flags & ONIGENC_CASE_FOLD_TURKISH_AZERI) &&
9857#define CASE_MAPPING_ADDITIONAL_LENGTH 20
9858#ifndef CASEMAP_DEBUG
9859# define CASEMAP_DEBUG 0
9867 OnigUChar space[FLEX_ARY_LEN];
9871mapping_buffer_free(
void *p)
9875 while (current_buffer) {
9876 previous_buffer = current_buffer;
9877 current_buffer = current_buffer->next;
9878 ruby_xfree_sized(previous_buffer, offsetof(
mapping_buffer, space) + previous_buffer->capa);
9884 {0, mapping_buffer_free,},
9885 0, 0, RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_WB_PROTECTED
9889rb_str_casemap(
VALUE source, OnigCaseFoldType *flags, rb_encoding *enc)
9893 const OnigUChar *source_current, *source_end;
9895 VALUE buffer_anchor;
9898 size_t buffer_count = 0;
9899 int buffer_length_or_invalid;
9901 if (RSTRING_LEN(source) == 0)
return str_duplicate(
rb_cString, source);
9902 if (RSTRING_LEN(source) > INT_MAX - CASE_MAPPING_ADDITIONAL_LENGTH)
9903 rb_raise(rb_eArgError,
"string size too big");
9905 source_current = (OnigUChar*)RSTRING_PTR(source);
9910 while (source_current < source_end) {
9912 size_t capa = (size_t)(source_end-source_current);
9913 if (
capa > (INT_MAX - CASE_MAPPING_ADDITIONAL_LENGTH) / ++buffer_count)
9916 capa =
capa * buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH;
9917 if (CASEMAP_DEBUG) {
9918 fprintf(stderr,
"Buffer allocation, capa is %"PRIuSIZE
"\n",
capa);
9921 *pre_buffer = current_buffer;
9922 pre_buffer = ¤t_buffer->next;
9923 current_buffer->next = NULL;
9924 current_buffer->capa =
capa;
9925 buffer_length_or_invalid = enc->case_map(flags,
9926 &source_current, source_end,
9927 current_buffer->space,
9928 current_buffer->space+current_buffer->capa,
9930 if (buffer_length_or_invalid < 0 || buffer_length_or_invalid >
RB_LEN_MAX - target_length) {
9931 current_buffer =
DATA_PTR(buffer_anchor);
9933 mapping_buffer_free(current_buffer);
9934 if (buffer_length_or_invalid < 0)
9935 rb_raise(rb_eArgError,
"input string invalid");
9936 rb_raise(rb_eArgError,
"string size too big");
9938 target_length += current_buffer->used = buffer_length_or_invalid;
9940 if (CASEMAP_DEBUG) {
9941 fprintf(stderr,
"Buffer count is %"PRIuSIZE
"\n", buffer_count);
9944 if (buffer_count==1) {
9945 target = str_enc_new(
rb_cString, (
const char*)current_buffer->space, target_length, enc);
9948 char *target_current;
9950 target = str_enc_new(
rb_cString, 0, target_length, enc);
9951 target_current = RSTRING_PTR(target);
9952 current_buffer =
DATA_PTR(buffer_anchor);
9953 while (current_buffer) {
9954 memcpy(target_current, current_buffer->space, current_buffer->used);
9955 target_current += current_buffer->used;
9956 current_buffer = current_buffer->next;
9959 current_buffer =
DATA_PTR(buffer_anchor);
9961 mapping_buffer_free(current_buffer);
9971rb_str_ascii_casemap(
VALUE source,
VALUE target, OnigCaseFoldType *flags, rb_encoding *enc)
9973 const OnigUChar *source_current, *source_end;
9974 OnigUChar *target_current, *target_end;
9975 rb_len_t old_length = RSTRING_LEN(source);
9976 int length_or_invalid;
9978 if (old_length == 0)
return Qnil;
9980 source_current = (OnigUChar*)RSTRING_PTR(source);
9982 if (source == target) {
9983 target_current = (OnigUChar*)source_current;
9984 target_end = (OnigUChar*)source_end;
9987 target_current = (OnigUChar*)RSTRING_PTR(target);
9991 length_or_invalid = onigenc_ascii_only_case_map(flags,
9992 &source_current, source_end,
9993 target_current, target_end, enc);
9994 if (length_or_invalid < 0)
9995 rb_raise(rb_eArgError,
"input string invalid");
9996 if (CASEMAP_DEBUG && length_or_invalid != old_length) {
9997 fprintf(stderr,
"problem with rb_str_ascii_casemap"
9998 "; old_length=%"PRIdLEN
", new_length=%d\n", old_length, length_or_invalid);
9999 rb_raise(rb_eArgError,
"internal problem with rb_str_ascii_casemap"
10000 "; old_length=%"PRIdLEN
", new_length=%d\n", old_length, length_or_invalid);
10009upcase_single(
VALUE str)
10011 char *s = RSTRING_PTR(str), *send =
RSTRING_END(str);
10012 bool modified =
false;
10015 unsigned int c = *(
unsigned char*)s;
10017 if (
'a' <= c && c <=
'z') {
10018 *s =
'A' + (c -
'a');
10039rb_str_upcase_bang(
int argc,
VALUE *argv,
VALUE str)
10042 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE;
10044 flags = check_case_options(argc, argv, flags);
10045 str_modify_keep_cr(str);
10046 enc = str_true_enc(str);
10047 if (case_option_single_p(flags, enc, str)) {
10048 if (upcase_single(str))
10049 flags |= ONIGENC_CASE_MODIFIED;
10051 else if (flags&ONIGENC_CASE_ASCII_ONLY)
10052 rb_str_ascii_casemap(str, str, &flags, enc);
10054 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
10056 if (ONIGENC_CASE_MODIFIED&flags)
return str;
10095rb_str_upcase(
int argc,
VALUE *argv,
VALUE str)
10098 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE;
10101 flags = check_case_options(argc, argv, flags);
10102 enc = str_true_enc(str);
10103 if (case_option_single_p(flags, enc, str)) {
10104 ret =
rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
10105 str_enc_copy_direct(ret, str);
10106 upcase_single(ret);
10108 else if (flags&ONIGENC_CASE_ASCII_ONLY) {
10110 rb_str_ascii_casemap(str, ret, &flags, enc);
10113 ret = rb_str_casemap(str, &flags, enc);
10120downcase_single(
VALUE str)
10122 char *s = RSTRING_PTR(str), *send =
RSTRING_END(str);
10123 bool modified =
false;
10126 unsigned int c = *(
unsigned char*)s;
10128 if (
'A' <= c && c <=
'Z') {
10129 *s =
'a' + (c -
'A');
10151rb_str_downcase_bang(
int argc,
VALUE *argv,
VALUE str)
10154 OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE;
10156 flags = check_case_options(argc, argv, flags);
10157 str_modify_keep_cr(str);
10158 enc = str_true_enc(str);
10159 if (case_option_single_p(flags, enc, str)) {
10160 if (downcase_single(str))
10161 flags |= ONIGENC_CASE_MODIFIED;
10163 else if (flags&ONIGENC_CASE_ASCII_ONLY)
10164 rb_str_ascii_casemap(str, str, &flags, enc);
10166 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
10168 if (ONIGENC_CASE_MODIFIED&flags)
return str;
10201rb_str_downcase(
int argc,
VALUE *argv,
VALUE str)
10204 OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE;
10207 flags = check_case_options(argc, argv, flags);
10208 enc = str_true_enc(str);
10209 if (case_option_single_p(flags, enc, str)) {
10210 ret =
rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
10211 str_enc_copy_direct(ret, str);
10212 downcase_single(ret);
10214 else if (flags&ONIGENC_CASE_ASCII_ONLY) {
10216 rb_str_ascii_casemap(str, ret, &flags, enc);
10219 ret = rb_str_casemap(str, &flags, enc);
10226capitalize_single(
VALUE str)
10228 char *s = RSTRING_PTR(str), *send =
RSTRING_END(str);
10229 bool modified =
false;
10232 unsigned int c = (
unsigned char)*s;
10234 if (
'a' <= c && c <=
'z') {
10235 *s =
'A' + (c -
'a');
10241 unsigned int c = (
unsigned char)*s;
10243 if (
'A' <= c && c <=
'Z') {
10244 *s =
'a' + (c -
'A');
10266rb_str_capitalize_bang(
int argc,
VALUE *argv,
VALUE str)
10269 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_TITLECASE;
10271 flags = check_case_options(argc, argv, flags);
10272 str_modify_keep_cr(str);
10273 enc = str_true_enc(str);
10274 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
10275 if (case_option_single_p(flags, enc, str)) {
10276 if (capitalize_single(str))
10277 flags |= ONIGENC_CASE_MODIFIED;
10279 else if (flags&ONIGENC_CASE_ASCII_ONLY)
10280 rb_str_ascii_casemap(str, str, &flags, enc);
10282 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
10284 if (ONIGENC_CASE_MODIFIED&flags)
return str;
10323rb_str_capitalize(
int argc,
VALUE *argv,
VALUE str)
10326 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_TITLECASE;
10329 flags = check_case_options(argc, argv, flags);
10330 enc = str_true_enc(str);
10331 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return str;
10332 if (case_option_single_p(flags, enc, str)) {
10333 ret =
rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
10334 str_enc_copy_direct(ret, str);
10335 capitalize_single(ret);
10337 else if (flags&ONIGENC_CASE_ASCII_ONLY) {
10339 rb_str_ascii_casemap(str, ret, &flags, enc);
10342 ret = rb_str_casemap(str, &flags, enc);
10361rb_str_swapcase_bang(
int argc,
VALUE *argv,
VALUE str)
10364 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE;
10366 flags = check_case_options(argc, argv, flags);
10367 str_modify_keep_cr(str);
10368 enc = str_true_enc(str);
10369 if (flags&ONIGENC_CASE_ASCII_ONLY)
10370 rb_str_ascii_casemap(str, str, &flags, enc);
10372 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
10374 if (ONIGENC_CASE_MODIFIED&flags)
return str;
10418rb_str_swapcase(
int argc,
VALUE *argv,
VALUE str)
10421 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE;
10424 flags = check_case_options(argc, argv, flags);
10425 enc = str_true_enc(str);
10426 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return str_duplicate(
rb_cString, str);
10427 if (flags&ONIGENC_CASE_ASCII_ONLY) {
10429 rb_str_ascii_casemap(str, ret, &flags, enc);
10432 ret = rb_str_casemap(str, &flags, enc);
10437typedef unsigned char *USTR;
10441 unsigned int now, max;
10442 const char *p, *pend;
10446trnext(
struct tr *t, rb_encoding *enc)
10453 if (t->p == t->pend)
return -1;
10454 if (rb_enc_ascget(t->p, t->pend, &n, enc) ==
'\\' && t->p + n < t->pend) {
10457 t->now = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
10459 if (rb_enc_ascget(t->p, t->pend, &n, enc) ==
'-' && t->p + n < t->pend) {
10461 if (t->p < t->pend) {
10462 unsigned int c = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
10465 if (t->now < 0x80 && c < 0x80) {
10466 rb_raise(rb_eArgError,
10467 "invalid range \"%c-%c\" in string transliteration",
10471 rb_raise(rb_eArgError,
"invalid range in string transliteration");
10475 else if (t->now < c) {
10484 while (ONIGENC_CODE_TO_MBCLEN(enc, ++t->now) <= 0) {
10485 if (t->now == t->max) {
10490 if (t->now < t->max) {
10506 const unsigned int errc = -1;
10507 unsigned int trans[256];
10508 rb_encoding *enc, *e1, *e2;
10509 struct tr trsrc, trrepl;
10511 unsigned int c, c0, last = 0;
10512 int modify = 0, i, l;
10513 unsigned char *s, *send;
10515 int singlebyte = single_byte_optimizable(str);
10519#define CHECK_IF_ASCII(c) \
10520 (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \
10521 (cr = ENC_CODERANGE_VALID) : 0)
10525 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
10526 if (RSTRING_LEN(repl) == 0) {
10527 return rb_str_delete_bang(1, &src, str);
10531 e1 = rb_enc_check(str, src);
10532 e2 = rb_enc_check(str, repl);
10537 enc = rb_enc_check(src, repl);
10539 trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src);
10540 if (RSTRING_LEN(src) > 1 &&
10541 rb_enc_ascget(trsrc.p, trsrc.pend, &l, enc) ==
'^' &&
10542 trsrc.p + l < trsrc.pend) {
10546 trrepl.p = RSTRING_PTR(repl);
10547 trrepl.pend = trrepl.p + RSTRING_LEN(repl);
10548 trsrc.gen = trrepl.gen = 0;
10549 trsrc.now = trrepl.now = 0;
10550 trsrc.max = trrepl.max = 0;
10553 for (i=0; i<256; i++) {
10556 while ((c = trnext(&trsrc, enc)) != errc) {
10565 while ((c = trnext(&trrepl, enc)) != errc)
10568 for (i=0; i<256; i++) {
10569 if (trans[i] != errc) {
10577 for (i=0; i<256; i++) {
10580 while ((c = trnext(&trsrc, enc)) != errc) {
10581 r = trnext(&trrepl, enc);
10582 if (r == errc) r = trrepl.now;
10585 if (rb_enc_codelen(r, enc) != 1) singlebyte = 0;
10596 str_modify_keep_cr(str);
10597 s = (
unsigned char *)RSTRING_PTR(str); send = (
unsigned char *)
RSTRING_END(str);
10598 termlen = rb_enc_mbminlen(enc);
10601 rb_len_t offset, max = RSTRING_LEN(str);
10602 unsigned int save = -1;
10603 unsigned char *buf =
ALLOC_N(
unsigned char, max + termlen), *t = buf;
10606 int may_modify = 0;
10608 int r = rb_enc_precise_mbclen((
char *)s, (
char *)send, e1);
10610 SIZED_FREE_N(buf, max + termlen);
10611 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(e1));
10614 c0 = c = rb_enc_mbc_to_codepoint((
char *)s, (
char *)send, e1);
10616 tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
10625 if (cflag) c = last;
10628 else if (cflag) c = errc;
10634 if (c != (
unsigned int)-1) {
10640 tlen = rb_enc_codelen(c, enc);
10646 if (enc != e1) may_modify = 1;
10648 if ((offset = t - buf) + tlen > max) {
10649 size_t MAYBE_UNUSED(old) = max + termlen;
10650 max = offset + tlen + (send - s);
10651 SIZED_REALLOC_N(buf,
unsigned char, max + termlen, old);
10654 rb_enc_mbcput(c, t, enc);
10655 if (may_modify && memcmp(s, t, tlen) != 0) {
10661 if (!STR_EMBED_P(str)) {
10662 SIZED_FREE_N(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
10664 TERM_FILL((
char *)t, termlen);
10665 RSTRING(str)->as.heap.ptr = (
char *)buf;
10666 STR_SET_LEN(str, t - buf);
10667 STR_SET_NOEMBED(str);
10668 RSTRING(str)->as.heap.aux.capa = max;
10672 c = (
unsigned char)*s;
10673 if (trans[c] != errc) {
10691 unsigned char *buf =
ALLOC_N(
unsigned char, max + termlen), *t = buf;
10694 int may_modify = 0;
10696 int r = rb_enc_precise_mbclen((
char *)s, (
char *)send, e1);
10698 SIZED_FREE_N(buf, max + termlen);
10699 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(e1));
10702 c0 = c = rb_enc_mbc_to_codepoint((
char *)s, (
char *)send, e1);
10704 tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
10712 if (cflag) c = last;
10715 else if (cflag) c = errc;
10719 c = cflag ? last : errc;
10722 tlen = rb_enc_codelen(c, enc);
10727 if (enc != e1) may_modify = 1;
10729 if ((offset = t - buf) + tlen > max) {
10730 size_t MAYBE_UNUSED(old) = max + termlen;
10731 max = offset + tlen + (
rb_len_t)((send - s) * 1.2);
10732 SIZED_REALLOC_N(buf,
unsigned char, max + termlen, old);
10736 rb_enc_mbcput(c, t, enc);
10737 if (may_modify && memcmp(s, t, tlen) != 0) {
10744 if (!STR_EMBED_P(str)) {
10745 SIZED_FREE_N(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
10747 TERM_FILL((
char *)t, termlen);
10748 RSTRING(str)->as.heap.ptr = (
char *)buf;
10749 STR_SET_LEN(str, t - buf);
10750 STR_SET_NOEMBED(str);
10751 RSTRING(str)->as.heap.aux.capa = max;
10757 rb_enc_associate(str, enc);
10764 unsigned char *buf;
10765 unsigned char *ptr;
10767 size_t initial_capa;
10771tr_buffer_init(
struct tr_buffer *buffer,
size_t initial_capa)
10773 if (initial_capa < 32) {
10776 *buffer = (
struct tr_buffer){ .initial_capa = initial_capa };
10780tr_buffer_ensure_capa(
struct tr_buffer *buffer,
size_t extra_capa)
10782 size_t offset = buffer->ptr - buffer->buf;
10783 size_t required_capa = offset + extra_capa;
10784 if (UNLIKELY(buffer->capa < required_capa)) {
10785 size_t new_capa = buffer->capa ? buffer->capa : buffer->initial_capa;
10787 while (new_capa < required_capa) {
10788 new_capa = (size_t)(new_capa * 1.2);
10790 SIZED_REALLOC_N(buffer->buf,
unsigned char, new_capa, buffer->capa);
10791 buffer->ptr = buffer->buf + offset;
10792 buffer->capa = new_capa;
10797tr_buffer_append(
struct tr_buffer *buffer,
const unsigned char *ptr,
size_t len)
10800 tr_buffer_ensure_capa(buffer,
len);
10801 memcpy(buffer->ptr, ptr,
len);
10802 buffer->ptr +=
len;
10809 tr_buffer_append(buffer, (
unsigned char *)RSTRING_PTR(str), RSTRING_LEN(str));
10813tr_buffer_mbcput(
struct tr_buffer *buffer,
int codepoint, rb_encoding *enc)
10816 buffer->ptr += rb_enc_mbcput(codepoint, buffer->ptr, enc);
10820tr_buffer_free(
struct tr_buffer *buffer)
10823 SIZED_FREE_N(buffer->buf, buffer->capa);
10840tr_trans_pairs_coerce_i(st_data_t key, st_data_t value, st_data_t _args)
10843 struct tr_pair *pair = &args->pairs[args->index];
10851 if (RSTRING_LEN(search) != 1 && str_strlen(search, NULL) != 1) {
10852 rb_raise(rb_eArgError,
"keys must be of size 1");
10855 args->enc = rb_enc_check_multi_str(args->enc, &args->cr, search);
10856 args->enc = rb_enc_check_multi_str(args->enc, &args->cr, replace);
10858 pair->search = search;
10859 pair->replace = replace;
10860 return ST_CONTINUE;
10863#define TR_TRANS_PAIRS_SIMD_MAX_NEEDLES 16
10866 const unsigned char *s;
10867 const unsigned char *send;
10870 unsigned int needles_count;
10871#ifdef HAVE_SIMD_NEON
10872 uint64_t matches_bitmap;
10873 uint8x16_t needle_masks[TR_TRANS_PAIRS_SIMD_MAX_NEEDLES];
10875#ifdef HAVE_SIMD_SSE2
10876 int matches_bitmap;
10877 __m128i needle_masks[TR_TRANS_PAIRS_SIMD_MAX_NEEDLES];
10881 VALUE trans_table[256];
10887 while (search->s < search->send) {
10888 VALUE repl = search->trans_table[*search->s];
10889 if (UNLIKELY(repl)) {
10899#ifdef HAVE_SIMD_SSE2
10904 size_t trailing_zeros = (size_t)ntz_int32(search->matches_bitmap);
10906 RUBY_ASSERT(trailing_zeros < (
sizeof(search->matches_bitmap) * CHAR_BIT));
10907 search->matches_bitmap >>= trailing_zeros;
10908 search->s += trailing_zeros;
10911 return search->trans_table[*search->s];
10917 const unsigned int needles_count = search->needles_count;
10918 if (needles_count) {
10921 if (search->matches_bitmap) {
10922 return tr_trans_pairs_next_match_sse2(search);
10925 if ((
size_t)(search->send - search->s) >=
sizeof(__m128i)) {
10929 const __m128i bytes = _mm_loadu_si128((__m128i
const *)search->s);
10931 __m128i matches[TR_TRANS_PAIRS_SIMD_MAX_NEEDLES];
10932 for (i = 0; i < needles_count; i++) {
10933 matches[i] = _mm_cmpeq_epi8(bytes, search->needle_masks[i]);
10936 for (i = 1; i < needles_count; i++) {
10937 matches[0] = _mm_or_si128(matches[0], matches[i]);
10940 const int bitmap = _mm_movemask_epi8(matches[0]);
10943 search->matches_bitmap = bitmap;
10944 return tr_trans_pairs_next_match_sse2(search);
10946 search->s +=
sizeof(__m128i);
10947 }
while ((
size_t)(search->send - search->s) >=
sizeof(__m128i));
10950 return tr_trans_pairs_search_basic(search);
10953#define tr_trans_pairs_search_impl tr_trans_pairs_search_sse2
10956#ifdef HAVE_SIMD_NEON
10961 size_t trailing_zeros = (size_t)ntz_int64(search->matches_bitmap);
10964 RUBY_ASSERT(trailing_zeros < (
sizeof(search->matches_bitmap) * CHAR_BIT));
10965 search->matches_bitmap >>= trailing_zeros;
10966 search->s += trailing_zeros / 4;
10969 return search->trans_table[*search->s];
10975 const unsigned int needles_count = search->needles_count;
10976 if (needles_count) {
10979 if (search->matches_bitmap) {
10980 return tr_trans_pairs_next_match_neon(search);
10983 if ((
size_t)(search->send - search->s) >=
sizeof(uint8x16_t)) {
10987 const uint8x16_t bytes = vld1q_u8(search->s);
10989 uint8x16_t matches[TR_TRANS_PAIRS_SIMD_MAX_NEEDLES];
10990 for (i = 0; i < needles_count; i++) {
10991 matches[i] = vceqq_u8(bytes, search->needle_masks[i]);
10994 for (i = 1; i < needles_count; i++) {
10995 matches[0] = vorrq_u8(matches[0], matches[i]);
10998 const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(matches[0]), 4);
10999 const uint64_t bitmap = vget_lane_u64(vreinterpret_u64_u8(res), 0);
11002 search->matches_bitmap = bitmap & 0x8888888888888888ull;
11003 return tr_trans_pairs_next_match_neon(search);
11005 search->s +=
sizeof(uint8x16_t);
11006 }
while ((
size_t)(search->send - search->s) >=
sizeof(uint8x16_t));
11009 return tr_trans_pairs_search_basic(search);
11012#define tr_trans_pairs_search_impl tr_trans_pairs_search_neon
11015#ifndef tr_trans_pairs_search_impl
11016#define tr_trans_pairs_search_impl tr_trans_pairs_search_basic
11024 search->matches_bitmap >>= 1;
11032 for (
size_t index = 0; index < pairs_count; index++) {
11033 struct tr_pair *pair = &pairs[index];
11035 char *ptr = RSTRING_PTR(pair->search);
11036 unsigned int codepoint = rb_enc_mbc_to_codepoint(ptr,
RSTRING_END(pair->search), enc);
11038 const unsigned char first_byte = (
unsigned char)*ptr;
11041 if (pairs_count <= TR_TRANS_PAIRS_SIMD_MAX_NEEDLES) {
11042#ifdef HAVE_SIMD_NEON
11043 search->needle_masks[index] = vdupq_n_u8(first_byte);
11045#ifdef HAVE_SIMD_SSE2
11046 search->needle_masks[index] = _mm_set1_epi8(first_byte);
11048 search->needles_count++;
11052 if (rb_enc_codelen(codepoint, enc) == 1) {
11053 search->trans_table[first_byte] = pair->replace;
11056 search->trans_table[first_byte] =
Qundef;
11058 hash =
rb_obj_hide(rb_hash_new_capa(pairs_count));
11060 rb_hash_aset(hash,
UINT2NUM(codepoint), pair->replace);
11071 mustnot_broken(str);
11072 rb_str_modify(str);
11074 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str) || pairs_count == 0)
return Qnil;
11076 VALUE pairs_handle;
11079 int cr = rb_enc_str_coderange(str);
11080 rb_encoding *enc = rb_str_enc_get(str);
11088 rb_encoding *e1 = coerce_args.enc;
11093 pairs_count = coerce_args.index;
11097 const unsigned char *sstart = (
unsigned char *)RSTRING_PTR(str);
11098 rb_len_t str_len = RSTRING_LEN(str);
11099 int termlen = rb_enc_mbminlen(e1);
11102 tr_buffer_init(&buffer, str_len);
11103 bool modify =
false;
11105 if (RB_LIKELY(rb_str_encindex_fastpath(rb_enc_to_index(e1)))) {
11109 .send = sstart + str_len,
11112 hash = tr_trans_pairs_search_prepare(&search, pairs_count, pairs, e1);
11114 const unsigned char *checkpoint = search.s;
11116 while ((repl = tr_trans_pairs_search_impl(&search))) {
11119 if (UNLIKELY(repl ==
Qundef)) {
11120 unsigned int c = rb_enc_mbc_to_codepoint((
char *)search.s, (
char *)search.send, e1);
11121 clen = rb_enc_codelen(c, e1);
11122 repl = rb_hash_lookup2(hash,
UINT2NUM(c), 0);
11124 tr_trans_pairs_consume_match(&search);
11132 if (checkpoint < search.s) {
11133 tr_buffer_append(&buffer, checkpoint, search.s - checkpoint);
11135 tr_buffer_append_str(&buffer, repl);
11136 checkpoint = search.s + clen;
11137 tr_trans_pairs_consume_match(&search);
11144 if (modify && checkpoint < search.s) {
11145 tr_buffer_append(&buffer, checkpoint, search.s - checkpoint);
11149 const unsigned char *s = sstart;
11150 const unsigned char *send = sstart + str_len;
11152 hash =
rb_obj_hide(rb_hash_new_capa(pairs_count));
11154 for (
size_t index = 0; index < pairs_count; index++) {
11155 struct tr_pair *pair = &pairs[index];
11157 unsigned int codepoint = rb_enc_mbc_to_codepoint(RSTRING_PTR(pair->search),
RSTRING_END(pair->search), e1);
11158 rb_hash_aset(hash,
UINT2NUM(codepoint), pair->replace);
11162 bool may_modify =
false;
11164 int r = rb_enc_precise_mbclen((
char *)s, (
char *)send, e1);
11166 tr_buffer_free(&buffer);
11167 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(e1));
11170 unsigned int c = rb_enc_mbc_to_codepoint((
char *)s, (
char *)send, e1);
11171 unsigned int c0 = c;
11173 rb_len_t tlen = enc == e1 ? clen : rb_enc_codelen(c, e1);
11176 if (
NIL_P(replacement)) {
11177 tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
11179 if (enc != e1) may_modify =
true;
11182 tlen = RSTRING_LEN(replacement);
11186 if (
NIL_P(replacement)) {
11187 tr_buffer_mbcput(&buffer, c, enc);
11190 tr_buffer_append_str(&buffer, replacement);
11193 if (may_modify && memcmp(s, buffer.ptr - tlen, tlen) != 0) {
11208 tr_buffer_free(&buffer);
11212 if (!STR_EMBED_P(str)) {
11213 SIZED_FREE_N(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
11215 tr_buffer_ensure_capa(&buffer, termlen);
11216 TERM_FILL((
char *)buffer.ptr, termlen);
11217 RSTRING(str)->as.heap.ptr = (
char *)buffer.buf;
11218 STR_SET_LEN(str, buffer.ptr - buffer.buf);
11219 STR_SET_NOEMBED(str);
11220 RSTRING(str)->as.heap.aux.capa = buffer.capa - termlen;
11226 rb_enc_associate(str, e1);
11244rb_str_tr_bang(
int argc,
VALUE *argv,
VALUE str)
11249 VALUE pairs = argv[0];
11250 return tr_trans_pairs(str, pairs);
11253 VALUE src = argv[0], repl = argv[1];
11254 return tr_trans(str, src, repl, 0);
11321 VALUE pairs = argv[0];
11322 VALUE result = tr_trans_pairs(str, pairs);
11323 if (
NIL_P(result)) result = str;
11327 VALUE src = argv[0], repl = argv[1];
11328 tr_trans(str, src, repl, 0);
11332#define TR_TABLE_MAX (UCHAR_MAX+1)
11333#define TR_TABLE_SIZE (TR_TABLE_MAX+1)
11335tr_setup_table(
VALUE str,
char stable[TR_TABLE_SIZE],
int first,
11336 VALUE *tablep,
VALUE *ctablep, rb_encoding *enc)
11338 const unsigned int errc = -1;
11339 char buf[TR_TABLE_MAX];
11342 VALUE table = 0, ptable = 0;
11343 int i, l, cflag = 0;
11345 tr.p = RSTRING_PTR(str);
tr.pend =
tr.p + RSTRING_LEN(str);
11346 tr.gen =
tr.now =
tr.max = 0;
11348 if (RSTRING_LEN(str) > 1 && rb_enc_ascget(
tr.p,
tr.pend, &l, enc) ==
'^') {
11353 for (i=0; i<TR_TABLE_MAX; i++) {
11356 stable[TR_TABLE_MAX] = cflag;
11358 else if (stable[TR_TABLE_MAX] && !cflag) {
11359 stable[TR_TABLE_MAX] = 0;
11361 for (i=0; i<TR_TABLE_MAX; i++) {
11365 while ((c = trnext(&
tr, enc)) != errc) {
11366 if (c < TR_TABLE_MAX) {
11367 buf[(
unsigned char)c] = !cflag;
11372 if (!table && (first || *tablep || stable[TR_TABLE_MAX])) {
11384 if (table && (!ptable || (cflag ^ !
NIL_P(rb_hash_aref(ptable, key))))) {
11385 rb_hash_aset(table, key,
Qtrue);
11389 for (i=0; i<TR_TABLE_MAX; i++) {
11390 stable[i] = stable[i] && buf[i];
11392 if (!table && !cflag) {
11399tr_find(
unsigned int c,
const char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
11401 if (c < TR_TABLE_MAX) {
11402 return table[c] != 0;
11408 if (!
NIL_P(rb_hash_lookup(del, v)) &&
11409 (!nodel ||
NIL_P(rb_hash_lookup(nodel, v)))) {
11413 else if (nodel && !
NIL_P(rb_hash_lookup(nodel, v))) {
11416 return table[TR_TABLE_MAX] ? TRUE : FALSE;
11431rb_str_delete_bang(
int argc,
VALUE *argv,
VALUE str)
11433 char squeez[TR_TABLE_SIZE];
11434 rb_encoding *enc = 0;
11435 char *s, *send, *t;
11436 VALUE del = 0, nodel = 0;
11438 int i, ascompat, cr;
11440 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
11442 for (i=0; i<argc; i++) {
11446 enc = rb_enc_check(str, s);
11447 tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
11450 str_modify_keep_cr(str);
11451 ascompat = rb_enc_asciicompat(enc);
11452 s = t = RSTRING_PTR(str);
11459 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
11464 if (t != s) *t = c;
11470 c = rb_enc_codepoint_len(s, send, &clen, enc);
11472 if (tr_find(c, squeez, del, nodel)) {
11476 if (t != s) rb_enc_mbcput(c, t, enc);
11483 TERM_FILL(t, TERM_LEN(str));
11484 STR_SET_LEN(str, t - RSTRING_PTR(str));
11487 if (modify)
return str;
11575rb_str_delete(
int argc,
VALUE *argv,
VALUE str)
11578 rb_str_delete_bang(argc, argv, str);
11596rb_str_squeeze_bang(
int argc,
VALUE *argv,
VALUE str)
11598 char squeez[TR_TABLE_SIZE];
11599 rb_encoding *enc = 0;
11600 VALUE del = 0, nodel = 0;
11601 unsigned char *s, *send, *t;
11603 int ascompat, singlebyte = single_byte_optimizable(str);
11607 enc = STR_ENC_GET(str);
11610 for (i=0; i<argc; i++) {
11614 enc = rb_enc_check(str, s);
11615 if (singlebyte && !single_byte_optimizable(s))
11617 tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
11621 str_modify_keep_cr(str);
11622 s = t = (
unsigned char *)RSTRING_PTR(str);
11623 if (!s || RSTRING_LEN(str) == 0)
return Qnil;
11626 ascompat = rb_enc_asciicompat(enc);
11630 unsigned int c = *s++;
11631 if (c != save || (argc > 0 && !squeez[c])) {
11641 if (ascompat && (c = *s) < 0x80) {
11642 if (c != save || (argc > 0 && !squeez[c])) {
11648 c = rb_enc_codepoint_len((
char *)s, (
char *)send, &clen, enc);
11650 if (c != save || (argc > 0 && !tr_find(c, squeez, del, nodel))) {
11651 if (t != s) rb_enc_mbcput(c, t, enc);
11660 TERM_FILL((
char *)t, TERM_LEN(str));
11661 if ((
char *)t - RSTRING_PTR(str) != RSTRING_LEN(str)) {
11662 STR_SET_LEN(str, (
char *)t - RSTRING_PTR(str));
11666 if (modify)
return str;
11712rb_str_squeeze(
int argc,
VALUE *argv,
VALUE str)
11715 rb_str_squeeze_bang(argc, argv, str);
11735 return tr_trans(str, src, repl, 1);
11763 tr_trans(str, src, repl, 1);
11849rb_str_count(
int argc,
VALUE *argv,
VALUE str)
11851 char table[TR_TABLE_SIZE];
11852 rb_encoding *enc = 0;
11853 VALUE del = 0, nodel = 0, tstr;
11854 const char *s, *send;
11863 enc = rb_enc_check(str, tstr);
11866 if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) &&
11867 (ptstr = RSTRING_PTR(tstr),
11868 ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (
const unsigned char *)ptstr, (
const unsigned char *)ptstr+1)) &&
11869 !is_broken_string(str)) {
11871 unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc);
11873 s = RSTRING_PTR(str);
11874 if (!s || RSTRING_LEN(str) == 0)
return INT2FIX(0);
11877 if (*(
unsigned char*)s++ == c) n++;
11883 tr_setup_table(tstr, table, TRUE, &del, &nodel, enc);
11884 for (i=1; i<argc; i++) {
11887 enc = rb_enc_check(str, tstr);
11888 tr_setup_table(tstr, table, FALSE, &del, &nodel, enc);
11891 s = RSTRING_PTR(str);
11892 if (!s || RSTRING_LEN(str) == 0)
return INT2FIX(0);
11894 ascompat = rb_enc_asciicompat(enc);
11898 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
11906 c = rb_enc_codepoint_len(s, send, &clen, enc);
11907 if (tr_find(c, table, del, nodel)) {
11918rb_fs_check(
VALUE val)
11922 if (
NIL_P(val))
return 0;
11927static const char isspacetable[256] = {
11928 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
11929 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11930 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11931 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11932 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11933 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11934 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11935 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11936 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11937 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11938 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11939 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11940 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11941 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11942 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11943 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
11946#define ascii_isspace(c) isspacetable[(unsigned char)(c)]
11951 if (empty_count >= 0 &&
len == 0) {
11952 return empty_count + 1;
11954 if (empty_count > 0) {
11959 }
while (--empty_count > 0);
11963 rb_yield(str_new_empty_String(str));
11964 }
while (--empty_count > 0);
11974 return empty_count;
11978 SPLIT_TYPE_AWK, SPLIT_TYPE_STRING, SPLIT_TYPE_REGEXP, SPLIT_TYPE_CHARS
11982literal_split_pattern(
VALUE spat, split_type_t default_type)
11984 rb_encoding *enc = STR_ENC_GET(spat);
11990 return SPLIT_TYPE_CHARS;
11992 else if (rb_enc_asciicompat(enc)) {
11993 if (
len == 1 && ptr[0] ==
' ') {
11994 return SPLIT_TYPE_AWK;
11999 if (rb_enc_ascget(ptr, ptr +
len, &l, enc) ==
' ' &&
len == l) {
12000 return SPLIT_TYPE_AWK;
12003 return default_type;
12116rb_str_split_m(
int argc,
VALUE *argv,
VALUE str)
12121 split_type_t split_type;
12122 rb_len_t beg, end, i = 0, empty_count = -1;
12127 if (
rb_scan_args(argc, argv,
"02", &spat, &limit) == 2) {
12129 if (lim <= 0) limit =
Qnil;
12130 else if (lim == 1) {
12131 if (RSTRING_LEN(str) == 0)
12142 if (
NIL_P(limit) && !lim) empty_count = 0;
12144 enc = STR_ENC_GET(str);
12145 split_type = SPLIT_TYPE_REGEXP;
12146 if (!
NIL_P(spat)) {
12147 spat = get_pat_quoted(spat, 0);
12150 split_type = SPLIT_TYPE_AWK;
12152 else if (!(spat = rb_fs_check(spat))) {
12153 rb_raise(
rb_eTypeError,
"value of $; must be String or Regexp");
12158 if (split_type != SPLIT_TYPE_AWK) {
12163 split_type = literal_split_pattern(tmp, SPLIT_TYPE_REGEXP);
12164 if (split_type == SPLIT_TYPE_AWK) {
12166 split_type = SPLIT_TYPE_STRING;
12171 mustnot_broken(spat);
12172 split_type = literal_split_pattern(spat, SPLIT_TYPE_STRING);
12180#define SPLIT_STR(beg, len) ( \
12181 empty_count = split_string(result, str, beg, len, empty_count), \
12182 str_mod_check(str, str_start, str_len))
12185 const char *ptr = RSTRING_PTR(str);
12186 const char *
const str_start = ptr;
12187 const rb_len_t str_len = RSTRING_LEN(str);
12188 const char *
const eptr = str_start + str_len;
12189 if (split_type == SPLIT_TYPE_AWK) {
12190 const char *bptr = ptr;
12196 if (is_ascii_string(str)) {
12197 while (ptr < eptr) {
12198 c = (
unsigned char)*ptr++;
12200 if (ascii_isspace(c)) {
12206 if (!
NIL_P(limit) && lim <= i)
break;
12209 else if (ascii_isspace(c)) {
12210 SPLIT_STR(beg, end-beg);
12213 if (!
NIL_P(limit)) ++i;
12221 while (ptr < eptr) {
12224 c = rb_enc_codepoint_len(ptr, eptr, &n, enc);
12233 if (!
NIL_P(limit) && lim <= i)
break;
12237 SPLIT_STR(beg, end-beg);
12240 if (!
NIL_P(limit)) ++i;
12248 else if (split_type == SPLIT_TYPE_STRING) {
12249 const char *substr_start = ptr;
12250 const char *sptr = RSTRING_PTR(spat);
12251 rb_len_t slen = RSTRING_LEN(spat);
12254 mustnot_broken(str);
12255 enc = rb_enc_check(str, spat);
12256 while (ptr < eptr &&
12257 (end =
rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
12260 if (t != ptr + end) {
12264 SPLIT_STR(substr_start - str_start, (ptr+end) - substr_start);
12265 str_mod_check(spat, sptr, slen);
12267 substr_start = ptr;
12268 if (!
NIL_P(limit) && lim <= ++i)
break;
12270 beg = substr_start - str_start;
12272 else if (split_type == SPLIT_TYPE_CHARS) {
12276 mustnot_broken(str);
12277 enc = rb_enc_get(str);
12278 while (ptr < eptr &&
12279 (n = rb_enc_precise_mbclen(ptr, eptr, enc)) > 0) {
12280 SPLIT_STR(ptr - str_start, n);
12282 if (!
NIL_P(limit) && lim <= ++i)
break;
12284 beg = ptr - str_start;
12295 VALUE search = str;
12298 (match ? (rb_match_unbusy(match),
rb_backref_set(match)) : (void)0)) {
12300 search =
RMATCH(match)->str;
12302 end = RMATCH_BEG(match, 0);
12303 if (start == end && RMATCH_BEG(match, 0) == RMATCH_END(match, 0)) {
12308 else if (last_null == 1) {
12309 SPLIT_STR(beg, rb_enc_fast_mbclen(ptr+beg, eptr, enc));
12316 start += rb_enc_fast_mbclen(ptr+start,eptr,enc);
12322 SPLIT_STR(beg, end-beg);
12323 beg = start = RMATCH_END(match, 0);
12327 for (idx = 1; idx < RMATCH_NREGS(match); idx++) {
12328 if (RMATCH_BEG(match, idx) == -1)
continue;
12329 SPLIT_STR(RMATCH_BEG(match, idx), RMATCH_END(match, idx) - RMATCH_BEG(match, idx));
12331 if (!
NIL_P(limit) && lim <= ++i)
break;
12333 if (match) rb_match_unbusy(match);
12335 if (RSTRING_LEN(str) > 0 && (!
NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
12336 SPLIT_STR(beg, RSTRING_LEN(str)-beg);
12339 return result ? result : str;
12349 return rb_str_split_m(1, &sep, str);
12352#define WANTARRAY(m, size) (!rb_block_given_p() ? rb_ary_new_capa(size) : 0)
12367#define ENUM_ELEM(ary, e) enumerator_element(ary, e)
12370chomp_newline(
const char *p,
const char *e, rb_encoding *enc)
12372 const char *prev = rb_enc_prev_char(p, e, e, enc);
12375 prev = rb_enc_prev_char(p, e, e, enc);
12376 if (prev && rb_enc_ascget(prev, e, NULL, enc) ==
'\r')
12388 RSTRING_LEN(rs) != 1 ||
12389 RSTRING_PTR(rs)[0] !=
'\n')) {
12395#define rb_rs get_rs()
12402 const char *pend, *subptr, *subend, *rsptr, *hit, *adjusted;
12408 if (!
NIL_P(opts)) {
12409 static ID keywords[1];
12410 if (!keywords[0]) {
12414 chomp = (!UNDEF_P(chomp) &&
RTEST(chomp));
12418 if (!ENUM_ELEM(ary, str)) {
12426 if (!RSTRING_LEN(str))
goto end;
12428 const char *
const ptr = subptr = RSTRING_PTR(str);
12432 rslen = RSTRING_LEN(rs);
12435 enc = rb_enc_get(str);
12437 enc = rb_enc_check(str, rs);
12442 const char *eol = NULL;
12444 while (subend < pend) {
12447 if (rb_enc_ascget(subend, pend, &n, enc) !=
'\r')
12449 rslen = n + rb_enc_mbclen(subend + n, pend, enc);
12451 if (eol == subend)
break;
12455 chomp_rslen = -rslen;
12459 if (!subptr) subptr = subend;
12463 }
while (subend < pend);
12464 if (!subptr)
break;
12465 if (rslen == 0) chomp_rslen = 0;
12467 subend - subptr + (chomp ? chomp_rslen : rslen));
12468 if (ENUM_ELEM(ary, line)) {
12469 str_mod_check(str, ptr,
len);
12471 subptr = eol = NULL;
12476 rsptr = RSTRING_PTR(rs);
12477 if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) &&
12486 rsptr = RSTRING_PTR(rs);
12487 rslen = RSTRING_LEN(rs);
12490 while (subptr < pend) {
12491 pos =
rb_memsearch(rsptr, rslen, subptr, pend - subptr, enc);
12492 if (pos < 0)
break;
12493 hit = subptr + pos;
12495 if (hit != adjusted) {
12499 subend = hit += rslen;
12502 subend = chomp_newline(subptr, subend, enc);
12509 if (ENUM_ELEM(ary, line)) {
12510 str_mod_check(str, ptr,
len);
12511 str_mod_check(rs, rsptr, rslen);
12516 if (subptr < pend) {
12519 pend = chomp_newline(subptr, pend, enc);
12521 else if (pend - subptr >= rslen &&
12522 memcmp(pend - rslen, rsptr, rslen) == 0) {
12527 ENUM_ELEM(ary, line);
12613rb_str_each_line(
int argc,
VALUE *argv,
VALUE str)
12616 return rb_str_enumerate_lines(argc, argv, str, 0);
12671rb_str_lines(
int argc,
VALUE *argv,
VALUE str)
12673 VALUE ary = WANTARRAY(
"lines", 0);
12674 return rb_str_enumerate_lines(argc, argv, str, ary);
12680 return LEN2NUM(RSTRING_LEN(str));
12688 for (i=0; i<RSTRING_LEN(str); i++) {
12689 ENUM_ELEM(ary,
INT2FIX((
unsigned char)RSTRING_PTR(str)[i]));
12719rb_str_each_byte(
VALUE str)
12722 return rb_str_enumerate_bytes(str, 0);
12740rb_str_bytes(
VALUE str)
12742 VALUE ary = WANTARRAY(
"bytes", RSTRING_LEN(str));
12743 return rb_str_enumerate_bytes(str, ary);
12761 ptr = RSTRING_PTR(str);
12762 len = RSTRING_LEN(str);
12763 enc = rb_enc_get(str);
12766 for (i = 0; i <
len; i += n) {
12767 n = rb_enc_fast_mbclen(ptr + i, ptr +
len, enc);
12772 for (i = 0; i <
len; i += n) {
12773 n = rb_enc_mbclen(ptr + i, ptr +
len, enc);
12810rb_str_each_char(
VALUE str)
12813 return rb_str_enumerate_chars(str, 0);
12831rb_str_chars(
VALUE str)
12834 return rb_str_enumerate_chars(str, ary);
12838rb_str_enumerate_codepoints(
VALUE str,
VALUE ary)
12843 const char *ptr, *end;
12845 int enc_asciicompat;
12847 if (single_byte_optimizable(str))
12848 return rb_str_enumerate_bytes(str, ary);
12851 ptr = RSTRING_PTR(str);
12853 enc = STR_ENC_GET(str);
12854 enc_asciicompat = rb_enc_asciicompat(enc);
12856 while (ptr < end) {
12861 c = (enc_asciicompat && ISASCII(*ptr)) ?
12862 (
unsigned char)*ptr : rb_enc_codepoint_len(ptr, end, &n, enc);
12900rb_str_each_codepoint(
VALUE str)
12903 return rb_str_enumerate_codepoints(str, 0);
12922rb_str_codepoints(
VALUE str)
12925 return rb_str_enumerate_codepoints(str, ary);
12929get_reg_grapheme_cluster(rb_encoding *enc)
12931 int encidx = rb_enc_to_index(enc);
12933 const OnigUChar source_ascii[] =
"\\X";
12934 const OnigUChar *source = source_ascii;
12935 size_t source_len =
sizeof(source_ascii) - 1;
12938#define CHARS_16BE(x) (OnigUChar)((x)>>8), (OnigUChar)(x)
12939#define CHARS_16LE(x) (OnigUChar)(x), (OnigUChar)((x)>>8)
12940#define CHARS_32BE(x) CHARS_16BE((x)>>16), CHARS_16BE(x)
12941#define CHARS_32LE(x) CHARS_16LE(x), CHARS_16LE((x)>>16)
12942#define CASE_UTF(e) \
12943 case ENCINDEX_UTF_##e: { \
12944 static const OnigUChar source_UTF_##e[] = {CHARS_##e('\\'), CHARS_##e('X')}; \
12945 source = source_UTF_##e; \
12946 source_len = sizeof(source_UTF_##e); \
12949 CASE_UTF(16BE); CASE_UTF(16LE); CASE_UTF(32BE); CASE_UTF(32LE);
12957 regex_t *reg_grapheme_cluster;
12959 int r = onig_new(®_grapheme_cluster, source, source + source_len,
12960 ONIG_OPTION_DEFAULT, enc, OnigDefaultSyntax, &einfo);
12962 UChar message[ONIG_MAX_ERROR_MESSAGE_LEN];
12963 onig_error_code_to_str(message, r, &einfo);
12964 rb_fatal(
"cannot compile grapheme cluster regexp: %s", (
char *)message);
12967 return reg_grapheme_cluster;
12971get_cached_reg_grapheme_cluster(rb_encoding *enc)
12973 int encidx = rb_enc_to_index(enc);
12974 static regex_t *reg_grapheme_cluster_utf8 = NULL;
12977 if (!reg_grapheme_cluster_utf8) {
12978 reg_grapheme_cluster_utf8 = get_reg_grapheme_cluster(enc);
12981 return reg_grapheme_cluster_utf8;
12990 size_t grapheme_cluster_count = 0;
12991 rb_encoding *enc = get_encoding(str);
12992 const char *ptr, *end;
12994 if (!rb_enc_unicode_p(enc)) {
12998 bool cached_reg_grapheme_cluster =
true;
12999 regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc);
13000 if (!reg_grapheme_cluster) {
13001 reg_grapheme_cluster = get_reg_grapheme_cluster(enc);
13002 cached_reg_grapheme_cluster =
false;
13005 ptr = RSTRING_PTR(str);
13008 while (ptr < end) {
13009 OnigPosition
len = onig_match(reg_grapheme_cluster,
13010 (
const OnigUChar *)ptr, (
const OnigUChar *)end,
13011 (
const OnigUChar *)ptr, NULL, 0);
13012 if (
len <= 0)
break;
13013 grapheme_cluster_count++;
13017 if (!cached_reg_grapheme_cluster) {
13018 onig_free(reg_grapheme_cluster);
13021 return SIZET2NUM(grapheme_cluster_count);
13025rb_str_enumerate_grapheme_clusters(
VALUE str,
VALUE ary)
13028 rb_encoding *enc = get_encoding(str);
13029 const char *ptr0, *ptr, *end;
13031 if (!rb_enc_unicode_p(enc)) {
13032 return rb_str_enumerate_chars(str, ary);
13037 bool cached_reg_grapheme_cluster =
true;
13038 regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc);
13039 if (!reg_grapheme_cluster) {
13040 reg_grapheme_cluster = get_reg_grapheme_cluster(enc);
13041 cached_reg_grapheme_cluster =
false;
13044 ptr0 = ptr = RSTRING_PTR(str);
13047 while (ptr < end) {
13048 OnigPosition
len = onig_match(reg_grapheme_cluster,
13049 (
const OnigUChar *)ptr, (
const OnigUChar *)end,
13050 (
const OnigUChar *)ptr, NULL, 0);
13051 if (
len <= 0)
break;
13056 if (!cached_reg_grapheme_cluster) {
13057 onig_free(reg_grapheme_cluster);
13095rb_str_each_grapheme_cluster(
VALUE str)
13098 return rb_str_enumerate_grapheme_clusters(str, 0);
13128rb_str_grapheme_clusters(
VALUE str)
13131 return rb_str_enumerate_grapheme_clusters(str, ary);
13135chopped_length(
VALUE str)
13137 rb_encoding *enc = STR_ENC_GET(str);
13138 const char *p, *p2, *beg, *end;
13140 beg = RSTRING_PTR(str);
13141 end = beg + RSTRING_LEN(str);
13142 if (beg >= end)
return 0;
13143 p = rb_enc_prev_char(beg, end, end, enc);
13145 if (p > beg && rb_enc_ascget(p, end, 0, enc) ==
'\n') {
13146 p2 = rb_enc_prev_char(beg, p, end, enc);
13147 if (p2 && rb_enc_ascget(p2, end, 0, enc) ==
'\r') p = p2;
13165rb_str_chop_bang(
VALUE str)
13167 str_modify_keep_cr(str);
13168 if (RSTRING_LEN(str) > 0) {
13170 len = chopped_length(str);
13171 STR_SET_LEN(str,
len);
13172 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
13207rb_str_chop(
VALUE str)
13213smart_chomp(
VALUE str,
const char *e,
const char *p)
13215 rb_encoding *enc = rb_enc_get(str);
13216 if (rb_enc_mbminlen(enc) > 1) {
13218 if (e - p < rb_enc_mbminlen(enc))
return e - p;
13223 pp = e - rb_enc_mbminlen(enc);
13226 if (rb_enc_ascget(pp, e, 0, enc) ==
'\r') {
13234 if (--e > p && *(e-1) ==
'\r') {
13251 const char *pp, *e, *rsptr;
13253 const char *
const p = RSTRING_PTR(str);
13256 if (
len == 0)
return 0;
13259 return smart_chomp(str, e, p);
13262 enc = rb_enc_get(str);
13265 if (rb_enc_mbminlen(enc) > 1) {
13266 while (e - p >= rb_enc_mbminlen(enc)) {
13270 pp -= rb_enc_mbminlen(enc);
13273 if (rb_enc_ascget(pp, e, 0, enc) ==
'\r') {
13280 while (e > p && *(e-1) ==
'\n') {
13282 if (e > p && *(e-1) ==
'\r')
13288 if (rslen >
len)
return len;
13290 enc = rb_enc_get(rs);
13291 newline = rsptr[rslen-1];
13292 if (rslen == rb_enc_mbminlen(enc)) {
13294 if (newline ==
'\n')
13295 return smart_chomp(str, e, p);
13299 return smart_chomp(str, e, p);
13303 enc = rb_enc_check(str, rs);
13304 if (is_broken_string(rs)) {
13308 if (p[
len-1] == newline &&
13310 memcmp(rsptr, pp, rslen) == 0)) {
13311 if (at_char_boundary(p, pp, e, enc))
13312 return len - rslen;
13324chomp_rs(
int argc,
const VALUE *argv)
13328 VALUE rs = argv[0];
13340 str_modify_keep_cr(str);
13341 STR_SET_LEN(str,
len);
13342 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
13354 if (
len >= olen)
return Qnil;
13355 return str_shrink(str,
len);
13371rb_str_chomp_bang(
int argc,
VALUE *argv,
VALUE str)
13374 str_modifiable(str);
13375 if (RSTRING_LEN(str) == 0 && argc < 2)
return Qnil;
13376 rs = chomp_rs(argc, argv);
13378 return rb_str_chomp_string(str, rs);
13421rb_str_chomp(
int argc,
VALUE *argv,
VALUE str)
13423 VALUE rs = chomp_rs(argc, argv);
13429tr_setup_table_multi(
char table[TR_TABLE_SIZE],
VALUE *tablep,
VALUE *ctablep,
13430 VALUE str,
int num_selectors,
VALUE *selectors)
13434 for (i=0; i<num_selectors; i++) {
13435 VALUE selector = selectors[i];
13439 enc = rb_enc_check(str, selector);
13440 tr_setup_table(selector, table, i==0, tablep, ctablep, enc);
13445lstrip_offset(
VALUE str,
const char *s,
const char *e, rb_encoding *enc)
13447 const char *
const start = s;
13449 if (!s || s >= e)
return 0;
13452 if (single_byte_optimizable(str)) {
13453 while (s < e && (*s ==
'\0' || ascii_isspace(*s))) s++;
13458 unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
13468lstrip_offset_table(
VALUE str,
const char *s,
const char *e, rb_encoding *enc,
13469 char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
13471 const char *
const start = s;
13473 if (!s || s >= e)
return 0;
13478 unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
13480 if (!tr_find(cc, table, del, nodel))
break;
13499rb_str_lstrip_bang(
int argc,
VALUE *argv,
VALUE str)
13505 str_modify_keep_cr(str);
13506 enc = STR_ENC_GET(str);
13509 char table[TR_TABLE_SIZE];
13510 VALUE del = 0, nodel = 0;
13512 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13515 str_modify_keep_cr(str);
13516 enc = STR_ENC_GET(str);
13519 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
13522 loffset = lstrip_offset(str, start, start+olen, enc);
13527 memmove(start, start + loffset,
len);
13528 STR_SET_LEN(str,
len);
13529 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
13564rb_str_lstrip(
int argc,
VALUE *argv,
VALUE str)
13571 char table[TR_TABLE_SIZE];
13572 VALUE del = 0, nodel = 0;
13574 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13579 loffset = lstrip_offset_table(str, start, start+
len, STR_ENC_GET(str), table, del, nodel);
13582 loffset = lstrip_offset(str, start, start+
len, STR_ENC_GET(str));
13584 if (loffset <= 0)
return str_duplicate(
rb_cString, str);
13589rstrip_offset(
VALUE str,
const char *s,
const char *e, rb_encoding *enc)
13593 rb_str_check_dummy_enc(enc);
13597 if (!s || s >= e)
return 0;
13601 if (single_byte_optimizable(str)) {
13603 while (s < t && ((c = *(t-1)) ==
'\0' || ascii_isspace(c))) t--;
13608 while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
13618rstrip_offset_table(
VALUE str,
const char *s,
const char *e, rb_encoding *enc,
13619 char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
13621 const char *t, *tp;
13623 rb_str_check_dummy_enc(enc);
13627 if (!s || s >= e)
return 0;
13631 while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
13633 if (!tr_find(c, table, del, nodel))
break;
13653rb_str_rstrip_bang(
int argc,
VALUE *argv,
VALUE str)
13659 str_modify_keep_cr(str);
13660 enc = STR_ENC_GET(str);
13663 char table[TR_TABLE_SIZE];
13664 VALUE del = 0, nodel = 0;
13666 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13669 str_modify_keep_cr(str);
13670 enc = STR_ENC_GET(str);
13673 roffset = rstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
13676 roffset = rstrip_offset(str, start, start+olen, enc);
13681 STR_SET_LEN(str,
len);
13682 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
13716rb_str_rstrip(
int argc,
VALUE *argv,
VALUE str)
13722 enc = STR_ENC_GET(str);
13725 char table[TR_TABLE_SIZE];
13726 VALUE del = 0, nodel = 0;
13728 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13731 enc = STR_ENC_GET(str);
13734 roffset = rstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
13737 roffset = rstrip_offset(str, start, start+olen, enc);
13739 if (roffset <= 0)
return str_duplicate(
rb_cString, str);
13757rb_str_strip_bang(
int argc,
VALUE *argv,
VALUE str)
13763 str_modify_keep_cr(str);
13764 enc = STR_ENC_GET(str);
13768 char table[TR_TABLE_SIZE];
13769 VALUE del = 0, nodel = 0;
13771 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13774 str_modify_keep_cr(str);
13775 enc = STR_ENC_GET(str);
13778 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
13779 roffset = rstrip_offset_table(str, start+loffset, start+olen, enc, table, del, nodel);
13782 loffset = lstrip_offset(str, start, start+olen, enc);
13783 roffset = rstrip_offset(str, start+loffset, start+olen, enc);
13786 if (loffset > 0 || roffset > 0) {
13790 memmove(start, start + loffset,
len);
13792 STR_SET_LEN(str,
len);
13793 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
13828rb_str_strip(
int argc,
VALUE *argv,
VALUE str)
13832 rb_encoding *enc = STR_ENC_GET(str);
13837 char table[TR_TABLE_SIZE];
13838 VALUE del = 0, nodel = 0;
13840 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
13843 enc = STR_ENC_GET(str);
13846 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
13847 roffset = rstrip_offset_table(str, start+loffset, start+olen, enc, table, del, nodel);
13850 loffset = lstrip_offset(str, start, start+olen, enc);
13851 roffset = rstrip_offset(str, start+loffset, start+olen, enc);
13854 if (loffset <= 0 && roffset <= 0)
return str_duplicate(
rb_cString, str);
13862 rb_len_t end, pos = rb_pat_search(pat, str, *start, set_backref_str);
13866 end = pos + RSTRING_LEN(pat);
13870 pos = RMATCH_BEG(match, 0);
13871 end = RMATCH_END(match, 0);
13875 rb_encoding *enc = STR_ENC_GET(str);
13879 if (RSTRING_LEN(str) > end)
13880 *start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end,
13889 if (
NIL_P(match) || RMATCH_NREGS(match) == 1) {
13894 int num_regs = RMATCH_NREGS(match);
13896 for (
int i = 1; i < num_regs; i++) {
13898 if (RMATCH_BEG(match, i) >= 0) {
13899 s =
rb_str_subseq(str, RMATCH_BEG(match, i), RMATCH_END(match, i) - RMATCH_BEG(match, i));
13962 const char *p = RSTRING_PTR(str);
13965 pat = get_pat_quoted(pat, 1);
13966 mustnot_broken(str);
13970 while (!
NIL_P(result = scan_once(str, pat, &start, 0))) {
13975 if (last >= 0) rb_pat_search(pat, str, last, 1);
13980 while (!
NIL_P(result = scan_once(str, pat, &start, 1))) {
13984 str_mod_check(str, p,
len);
13986 if (last >= 0) rb_pat_search(pat, str, last, 1);
14038rb_str_hex(
VALUE str)
14040 return rb_str_to_inum(str, 16, FALSE);
14124rb_str_oct(
VALUE str)
14126 return rb_str_to_inum(str, -8, FALSE);
14129#ifndef HAVE_CRYPT_R
14134 rb_nativethread_lock_t lock;
14135} crypt_mutex = {PTHREAD_MUTEX_INITIALIZER};
14204# define CRYPT_END() ALLOCV_END(databuf)
14207 extern char *crypt(
const char *,
const char *);
14208# define CRYPT_END() rb_nativethread_lock_unlock(&crypt_mutex.lock)
14211 const char *s, *saltp, *res;
14213 char salt_8bit_clean[3];
14217 mustnot_wchar(str);
14218 mustnot_wchar(salt);
14220 saltp = RSTRING_PTR(salt);
14221 if (RSTRING_LEN(salt) < 2 || !saltp[0] || !saltp[1]) {
14222 rb_raise(rb_eArgError,
"salt too short (need >=2 bytes)");
14226 if (!ISASCII((
unsigned char)saltp[0]) || !ISASCII((
unsigned char)saltp[1])) {
14227 salt_8bit_clean[0] = saltp[0] & 0x7f;
14228 salt_8bit_clean[1] = saltp[1] & 0x7f;
14229 salt_8bit_clean[2] =
'\0';
14230 saltp = salt_8bit_clean;
14235# ifdef HAVE_STRUCT_CRYPT_DATA_INITIALIZED
14236 data->initialized = 0;
14238 res = crypt_r(s, saltp, data);
14241 res = crypt(s, saltp);
14256 size_t res_size = strlen(res);
14257 tmp_buf =
ALLOCA_N(
char, res_size);
14258 memcpy(tmp_buf, res, res_size);
14311 char *ptr, *p, *pend;
14314 unsigned long sum0 = 0;
14319 ptr = p = RSTRING_PTR(str);
14320 len = RSTRING_LEN(str);
14326 str_mod_check(str, ptr,
len);
14329 sum0 += (
unsigned char)*p;
14340 if (bits < (
int)
sizeof(
long)*CHAR_BIT) {
14341 sum0 &= (((
unsigned long)1)<<bits)-1;
14361rb_str_justify(
int argc,
VALUE *argv,
VALUE str,
char jflag)
14368 const char *f =
" ";
14369 rb_len_t n, size, llen, rlen, llen2 = 0, rlen2 = 0;
14371 int singlebyte = 1, cr;
14375 enc = STR_ENC_GET(str);
14379 enc = rb_enc_check(str, pad);
14380 f = RSTRING_PTR(pad);
14381 flen = RSTRING_LEN(pad);
14382 fclen = str_strlen(pad, enc);
14383 singlebyte = single_byte_optimizable(pad);
14384 if (flen == 0 || fclen == 0) {
14385 rb_raise(rb_eArgError,
"zero width padding");
14388 termlen = rb_enc_mbminlen(enc);
14389 len = str_strlen(str, enc);
14390 if (width < 0 || len >= width)
return str_duplicate(
rb_cString, str);
14392 llen = (jflag ==
'l') ? 0 : ((jflag ==
'r') ? n : n/2);
14396 llen2 = str_offset(f, f + flen, llen % fclen, enc, singlebyte);
14397 rlen2 = str_offset(f, f + flen, rlen % fclen, enc, singlebyte);
14399 size = RSTRING_LEN(str);
14400 if ((
len = llen / fclen + rlen / fclen) >=
RB_LEN_MAX / flen ||
14403 rb_raise(rb_eArgError,
"argument too big");
14407 p = RSTRING_PTR(res);
14409 memset(p, *f, llen);
14413 while (llen >= fclen) {
14419 memcpy(p, f, llen2);
14423 memcpy(p, RSTRING_PTR(str), size);
14426 memset(p, *f, rlen);
14430 while (rlen >= fclen) {
14436 memcpy(p, f, rlen2);
14440 TERM_FILL(p, termlen);
14441 STR_SET_LEN(res, p-RSTRING_PTR(res));
14474rb_str_ljust(
int argc,
VALUE *argv,
VALUE str)
14476 return rb_str_justify(argc, argv, str,
'l');
14504rb_str_rjust(
int argc,
VALUE *argv,
VALUE str)
14506 return rb_str_justify(argc, argv, str,
'r');
14537rb_str_center(
int argc,
VALUE *argv,
VALUE str)
14539 return rb_str_justify(argc, argv, str,
'c');
14597 sep = get_pat_quoted(sep, 0);
14604 pos = RMATCH_BEG(match, 0);
14608 pos = rb_str_index(str, sep, 0);
14609 if (pos < 0)
goto failed;
14612 rb_len_t rpos = pos + RSTRING_LEN(sep);
14613 if (rpos > RSTRING_LEN(str))
goto failed;
14619 return rb_ary_new3(3, str_duplicate(
rb_cString, str), str_new_empty_String(str), str_new_empty_String(str));
14681 sep = get_pat_quoted(sep, 0);
14683 pos = RSTRING_LEN(str);
14689 pos = RMATCH_BEG(match, 0);
14695 pos = rb_str_rindex(str, sep, pos);
14701 rb_len_t rpos = pos + RSTRING_LEN(sep);
14702 if (rpos > RSTRING_LEN(str))
goto failed;
14707 return rb_ary_new3(3, str_new_empty_String(str), str_new_empty_String(str), str_duplicate(
rb_cString, str));
14734rb_str_start_with(
int argc,
VALUE *argv,
VALUE str)
14738 for (i=0; i<argc; i++) {
14739 VALUE tmp = argv[i];
14741 if (rb_reg_start_with_p(tmp, str))
14745 const char *p, *s, *e;
14750 enc = rb_enc_check(str, tmp);
14751 if ((tlen = RSTRING_LEN(tmp)) == 0)
return Qtrue;
14752 if ((slen = RSTRING_LEN(str)) < tlen)
continue;
14753 p = RSTRING_PTR(str);
14756 if (!at_char_right_boundary(p, s, e, enc))
14758 if (memcmp(p, RSTRING_PTR(tmp), tlen) == 0)
14782rb_str_end_with(
int argc,
VALUE *argv,
VALUE str)
14786 for (i=0; i<argc; i++) {
14787 VALUE tmp = argv[i];
14788 const char *p, *s, *e;
14793 enc = rb_enc_check(str, tmp);
14794 if ((tlen = RSTRING_LEN(tmp)) == 0)
return Qtrue;
14795 if ((slen = RSTRING_LEN(str)) < tlen)
continue;
14796 p = RSTRING_PTR(str);
14799 if (!at_char_boundary(p, s, e, enc))
14801 if (memcmp(s, RSTRING_PTR(tmp), tlen) == 0)
14817deleted_prefix_length(
VALUE str,
VALUE prefix)
14819 const char *strptr, *prefixptr;
14821 rb_encoding *enc = rb_enc_get(str);
14825 if (!is_broken_string(prefix) ||
14826 !rb_enc_asciicompat(enc) ||
14827 !rb_enc_asciicompat(rb_enc_get(prefix))) {
14828 enc = rb_enc_check(str, prefix);
14832 prefixlen = RSTRING_LEN(prefix);
14833 if (prefixlen <= 0)
return 0;
14834 olen = RSTRING_LEN(str);
14835 if (olen < prefixlen)
return 0;
14836 strptr = RSTRING_PTR(str);
14837 prefixptr = RSTRING_PTR(prefix);
14838 if (memcmp(strptr, prefixptr, prefixlen) != 0)
return 0;
14839 if (is_broken_string(prefix)) {
14840 if (!is_broken_string(str)) {
14844 const char *strend = strptr + olen;
14845 const char *after_prefix = strptr + prefixlen;
14846 if (!at_char_right_boundary(strptr, after_prefix, strend, enc)) {
14867rb_str_delete_prefix_bang(
VALUE str,
VALUE prefix)
14870 str_modify_keep_cr(str);
14872 prefixlen = deleted_prefix_length(str, prefix);
14873 if (prefixlen <= 0)
return Qnil;
14895rb_str_delete_prefix(
VALUE str,
VALUE prefix)
14899 prefixlen = deleted_prefix_length(str, prefix);
14900 if (prefixlen <= 0)
return str_duplicate(
rb_cString, str);
14902 return rb_str_subseq(str, prefixlen, RSTRING_LEN(str) - prefixlen);
14915deleted_suffix_length(
VALUE str,
VALUE suffix)
14917 const char *strptr, *suffixptr;
14922 if (is_broken_string(suffix))
return 0;
14923 enc = rb_enc_check(str, suffix);
14926 suffixlen = RSTRING_LEN(suffix);
14927 if (suffixlen <= 0)
return 0;
14928 olen = RSTRING_LEN(str);
14929 if (olen < suffixlen)
return 0;
14930 strptr = RSTRING_PTR(str);
14931 suffixptr = RSTRING_PTR(suffix);
14932 const char *strend = strptr + olen;
14933 const char *before_suffix = strend - suffixlen;
14934 if (memcmp(before_suffix, suffixptr, suffixlen) != 0)
return 0;
14935 if (!at_char_boundary(strptr, before_suffix, strend, enc))
return 0;
14951rb_str_delete_suffix_bang(
VALUE str,
VALUE suffix)
14954 str_modifiable(str);
14956 suffixlen = deleted_suffix_length(str, suffix);
14957 if (suffixlen <= 0)
return Qnil;
14959 return str_shrink(str, RSTRING_LEN(str) - suffixlen);
14980rb_str_delete_suffix(
VALUE str,
VALUE suffix)
14984 suffixlen = deleted_suffix_length(str, suffix);
14985 if (suffixlen <= 0)
return str_duplicate(
rb_cString, str);
14987 return rb_str_subseq(str, 0, RSTRING_LEN(str) - suffixlen);
14994 rb_raise(
rb_eTypeError,
"value of %"PRIsVALUE
" must be String", rb_id2str(
id));
15000nil_setter_warning(
ID id)
15002 rb_warn_deprecated(
"non-nil '%"PRIsVALUE
"'", NULL, rb_id2str(
id));
15009 if (!
NIL_P(*var)) {
15010 nil_setter_warning(
id);
15017 val = rb_fs_check(val);
15020 "value of %"PRIsVALUE
" must be String or Regexp",
15024 nil_setter_warning(
id);
15061 str_modifiable(str);
15063 rb_encoding *encoding = rb_to_encoding(enc);
15064 int idx = rb_enc_to_index(encoding);
15071 rb_enc_associate_index(str, idx);
15110 if (STR_EMBED_P(str)) {
15111 str2 = str_alloc_embed(
rb_cString, RSTRING_LEN(str) + TERM_LEN(str));
15116 str_replace_shared_without_enc(str2, str);
15118 if (rb_enc_asciicompat(STR_ENC_GET(str))) {
15141rb_str_valid_encoding_p(
VALUE str)
15143 int cr = rb_enc_str_coderange(str);
15150rb_str_is_ascii_only_p(
VALUE str)
15152 int cr = rb_enc_str_coderange(str);
15160 static const char ellipsis[] =
"...";
15161 const rb_len_t ellipsislen =
sizeof(ellipsis) - 1;
15162 rb_encoding *
const enc = rb_enc_get(str);
15163 const rb_len_t blen = RSTRING_LEN(str);
15164 const char *
const p = RSTRING_PTR(str), *e = p + blen;
15165 VALUE estr, ret = 0;
15168 if (
len * rb_enc_mbminlen(enc) >= blen ||
15172 else if (
len <= ellipsislen ||
15174 if (rb_enc_asciicompat(enc)) {
15176 rb_enc_associate(ret, enc);
15183 else if (ret =
rb_str_subseq(str, 0, e - p), rb_enc_asciicompat(enc)) {
15188 rb_enc_from_encoding(enc), 0,
Qnil);
15195str_compat_and_valid(
VALUE str, rb_encoding *enc)
15199 cr = rb_enc_str_coderange(str);
15201 rb_raise(rb_eArgError,
"replacement must be valid byte sequence '%+"PRIsVALUE
"'", str);
15204 rb_encoding *e = STR_ENC_GET(str);
15207 rb_enc_inspect_name(enc), rb_enc_inspect_name(e));
15213static VALUE enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl,
int cr);
15218 rb_encoding *enc = STR_ENC_GET(str);
15223rb_enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl)
15226 if (enc == STR_ENC_GET(str)) {
15231 return enc_str_scrub(enc, str, repl, cr);
15235enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl,
int cr)
15239 const char *rep, *p, *e, *p1, *sp;
15245 rb_raise(rb_eArgError,
"both of block and replacement given");
15252 if (!
NIL_P(repl)) {
15253 repl = str_compat_and_valid(repl, enc);
15256 if (rb_enc_dummy_p(enc)) {
15259 encidx = rb_enc_to_index(enc);
15261#define DEFAULT_REPLACE_CHAR(str) do { \
15262 RBIMPL_ATTR_NONSTRING() static const char replace[sizeof(str)-1] = str; \
15263 rep = replace; replen = (int)sizeof(replace); \
15266 slen = RSTRING_LEN(str);
15267 p = RSTRING_PTR(str);
15272 if (rb_enc_asciicompat(enc)) {
15278 else if (!
NIL_P(repl)) {
15279 rep = RSTRING_PTR(repl);
15280 replen = RSTRING_LEN(repl);
15284 DEFAULT_REPLACE_CHAR(
"\xEF\xBF\xBD");
15288 DEFAULT_REPLACE_CHAR(
"?");
15293 p = search_nonascii(p, e);
15298 int ret = rb_enc_precise_mbclen(p, e, enc);
15306 p = search_nonascii(p, e);
15323 if (e - p < clen) clen = e - p;
15330 for (; clen > 1; clen--) {
15331 ret = rb_enc_precise_mbclen(q, q + clen, enc);
15342 repl =
rb_yield(rb_enc_str_new(p, clen, enc));
15343 str_mod_check(str, sp, slen);
15344 repl = str_compat_and_valid(repl, enc);
15351 p = search_nonascii(p, e);
15377 repl =
rb_yield(rb_enc_str_new(p, e-p, enc));
15378 str_mod_check(str, sp, slen);
15379 repl = str_compat_and_valid(repl, enc);
15388 rb_len_t mbminlen = rb_enc_mbminlen(enc);
15392 else if (!
NIL_P(repl)) {
15393 rep = RSTRING_PTR(repl);
15394 replen = RSTRING_LEN(repl);
15396 else if (encidx == ENCINDEX_UTF_16BE) {
15397 DEFAULT_REPLACE_CHAR(
"\xFF\xFD");
15399 else if (encidx == ENCINDEX_UTF_16LE) {
15400 DEFAULT_REPLACE_CHAR(
"\xFD\xFF");
15402 else if (encidx == ENCINDEX_UTF_32BE) {
15403 DEFAULT_REPLACE_CHAR(
"\x00\x00\xFF\xFD");
15405 else if (encidx == ENCINDEX_UTF_32LE) {
15406 DEFAULT_REPLACE_CHAR(
"\xFD\xFF\x00\x00");
15409 DEFAULT_REPLACE_CHAR(
"?");
15413 int ret = rb_enc_precise_mbclen(p, e, enc);
15426 if (e - p < clen) clen = e - p;
15427 if (clen <= mbminlen * 2) {
15432 for (; clen > mbminlen; clen-=mbminlen) {
15433 ret = rb_enc_precise_mbclen(q, q + clen, enc);
15443 repl =
rb_yield(rb_enc_str_new(p, clen, enc));
15444 str_mod_check(str, sp, slen);
15445 repl = str_compat_and_valid(repl, enc);
15470 repl =
rb_yield(rb_enc_str_new(p, e-p, enc));
15471 str_mod_check(str, sp, slen);
15472 repl = str_compat_and_valid(repl, enc);
15478 rb_enc_associate(buf, enc);
15534str_scrub_bang(
int argc,
VALUE *argv,
VALUE str)
15542static ID id_normalize;
15543static ID id_normalized_p;
15544static VALUE mUnicodeNormalize;
15547unicode_normalize_common(
int argc,
VALUE *argv,
VALUE str,
ID id)
15549 static int UnicodeNormalizeRequired = 0;
15552 if (!UnicodeNormalizeRequired) {
15553 rb_require(
"unicode_normalize/normalize.rb");
15554 UnicodeNormalizeRequired = 1;
15558 return rb_funcallv(mUnicodeNormalize,
id, argc+1, argv2);
15596rb_str_unicode_normalize(
int argc,
VALUE *argv,
VALUE str)
15598 return unicode_normalize_common(argc, argv, str, id_normalize);
15612rb_str_unicode_normalize_bang(
int argc,
VALUE *argv,
VALUE str)
15614 return rb_str_replace(str, unicode_normalize_common(argc, argv, str, id_normalize));
15641rb_str_unicode_normalized_p(
int argc,
VALUE *argv,
VALUE str)
15643 return unicode_normalize_common(argc, argv, str, id_normalized_p);
15775#define sym_equal rb_obj_equal
15778sym_printable(
const char *s,
const char *send, rb_encoding *enc)
15782 int c = rb_enc_precise_mbclen(s, send, enc);
15786 c = rb_enc_mbc_to_codepoint(s, send, enc);
15794rb_str_symname_p(
VALUE sym)
15802 enc = STR_ENC_GET(sym);
15803 ptr = RSTRING_PTR(sym);
15804 len = RSTRING_LEN(sym);
15805 if ((resenc != enc && !rb_str_is_ascii_only_p(sym)) ||
len != (
rb_len_t)strlen(ptr) ||
15813rb_str_quote_unprintable(
VALUE str)
15818 rb_encoding *resenc;
15823 enc = STR_ENC_GET(str);
15824 ptr = RSTRING_PTR(str);
15825 len = RSTRING_LEN(str);
15826 if ((resenc != enc && !rb_str_is_ascii_only_p(str)) ||
15827 !sym_printable(ptr, ptr +
len, enc)) {
15828 return rb_str_escape(str);
15834rb_id_quote_unprintable(
ID id)
15836 VALUE str = rb_id2str(
id);
15837 if (!rb_str_symname_p(str)) {
15838 return rb_str_escape(str);
15856sym_inspect(
VALUE sym)
15863 if (!rb_str_symname_p(str)) {
15865 len = RSTRING_LEN(str);
15866 rb_str_resize(str,
len + 1);
15867 dest = RSTRING_PTR(str);
15868 memmove(dest + 1, dest,
len);
15871 rb_encoding *enc = STR_ENC_GET(str);
15872 VALUE orig_str = str;
15874 len = RSTRING_LEN(orig_str);
15875 str = rb_enc_str_new(0,
len + 1, enc);
15878 ptr = RSTRING_PTR(orig_str);
15879 dest = RSTRING_PTR(str);
15880 memcpy(dest + 1, ptr,
len);
15898rb_sym_proc_call(
ID mid,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_proc)
15903 rb_raise(rb_eArgError,
"no receiver given");
16057 return rb_str_match(
rb_sym2str(sym), other);
16072sym_match_m(
int argc,
VALUE *argv,
VALUE sym)
16074 return rb_str_match_m(argc, argv,
rb_sym2str(sym));
16087sym_match_m_p(
int argc,
VALUE *argv,
VALUE sym)
16089 return rb_str_match_m_p(argc, argv, sym);
16107 return rb_str_aref_m(argc, argv,
rb_sym2str(sym));
16118sym_length(
VALUE sym)
16152sym_downcase(
int argc,
VALUE *argv,
VALUE sym)
16168sym_capitalize(
int argc,
VALUE *argv,
VALUE sym)
16184sym_swapcase(
int argc,
VALUE *argv,
VALUE sym)
16198sym_start_with(
int argc,
VALUE *argv,
VALUE sym)
16200 return rb_str_start_with(argc, argv,
rb_sym2str(sym));
16213sym_end_with(
int argc,
VALUE *argv,
VALUE sym)
16215 return rb_str_end_with(argc, argv,
rb_sym2str(sym));
16227sym_encoding(
VALUE sym)
16233string_for_symbol(
VALUE name)
16238 rb_raise(
rb_eTypeError,
"%+"PRIsVALUE
" is not a symbol nor a string",
16252 name = string_for_symbol(name);
16253 return rb_intern_str(name);
16262 name = string_for_symbol(name);
16286 return rb_fstring(str);
16292 struct RString fake_str = {RBASIC_INIT};
16293 int encidx = ENCINDEX_US_ASCII;
16295 if (
len > 0 && search_nonascii(ptr, ptr +
len)) {
16296 encidx = ENCINDEX_ASCII_8BIT;
16299 VALUE str = setup_fake_str(&fake_str, ptr,
len, encidx);
16301 return register_fstring(str,
true,
false);
16313 if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) {
16314 rb_enc_autoload(enc);
16317 struct RString fake_str = {RBASIC_INIT};
16318 return register_fstring(rb_setup_fake_str(&fake_str, ptr,
len, enc),
true,
false);
16322rb_enc_literal_str(
const char *ptr,
rb_len_t len, rb_encoding *enc)
16324 if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) {
16325 rb_enc_autoload(enc);
16328 struct RString fake_str = {RBASIC_INIT};
16329 VALUE str = register_fstring(rb_setup_fake_str(&fake_str, ptr,
len, enc),
true,
true);
16340#if USE_YJIT || USE_ZJIT
16342rb_jit_str_concat_codepoint(
VALUE str,
VALUE codepoint)
16347 if (RB_LIKELY(code >= 0 && code < 0xff)) {
16348 rb_str_buf_cat_byte(str, (
char) code);
16358fstring_set_class_i(
VALUE *str,
void *data)
16362 return ST_CONTINUE;
16370 rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);
16537 mUnicodeNormalize = rb_define_module(
"UnicodeNormalize");
16548 rb_gc_register_address(&
rb_fs);
16586#include "string.rbinc"
@ RUBY_ENC_CODERANGE_7BIT
The object holds 0 to 127 inclusive and nothing else.
static enum ruby_coderange_type RB_ENC_CODERANGE_AND(enum ruby_coderange_type a, enum ruby_coderange_type b)
"Mix" two code ranges into one.
#define ISSPACE
@old{rb_isspace}
static int rb_isspace(int c)
Our own locale-insensitive version of isspace(3).
static int rb_isascii(int c)
Our own locale-insensitive version of isascii(3).
#define ISDIGIT
@old{rb_isdigit}
#define ISALPHA
@old{rb_isalpha}
#define TOLOWER
@old{rb_tolower}
#define ISPRINT
@old{rb_isprint}
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
static bool rb_enc_is_newline(const char *p, const char *e, rb_encoding *enc)
Queries if the passed pointer points to a newline character.
static bool rb_enc_isprint(OnigCodePoint c, rb_encoding *enc)
Identical to rb_isprint(), except it additionally takes an encoding.
static bool rb_enc_isctype(OnigCodePoint c, OnigCtype t, rb_encoding *enc)
Queries if the passed code point is of passed character type in the passed encoding.
VALUE rb_enc_sprintf(rb_encoding *enc, const char *fmt,...)
Identical to rb_sprintf(), except it additionally takes an encoding.
static VALUE RB_OBJ_FROZEN_RAW(VALUE obj)
This is an implementation detail of RB_OBJ_FROZEN().
static VALUE RB_FL_TEST_RAW(VALUE obj, VALUE flags)
This is an implementation detail of RB_FL_TEST().
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define TYPE(_)
Old name of rb_type.
#define ENCODING_SET_INLINED(obj, i)
Old name of RB_ENCODING_SET_INLINED.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define ENC_CODERANGE_VALID
Old name of RUBY_ENC_CODERANGE_VALID.
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
#define rb_str_buf_cat2
Old name of rb_usascii_str_new_cstr.
#define ALLOCV
Old name of RB_ALLOCV.
#define T_STRING
Old name of RUBY_T_STRING.
#define ENC_CODERANGE_CLEAN_P(cr)
Old name of RB_ENC_CODERANGE_CLEAN_P.
#define ENC_CODERANGE_AND(a, b)
Old name of RB_ENC_CODERANGE_AND.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#define LEN2NUM
Old name of RB_LEN2NUM.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define ENC_CODERANGE(obj)
Old name of RB_ENC_CODERANGE.
#define CLASS_OF
Old name of rb_class_of.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define SIZET2NUM
Old name of RB_SIZE2NUM.
#define FIXABLE
Old name of RB_FIXABLE.
#define xmalloc
Old name of ruby_xmalloc.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define LONG2FIX
Old name of RB_INT2FIX.
#define ENC_CODERANGE_MASK
Old name of RUBY_ENC_CODERANGE_MASK.
#define ZALLOC_N
Old name of RB_ZALLOC_N.
#define T_HASH
Old name of RUBY_T_HASH.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define FL_SET
Old name of RB_FL_SET.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define ENCODING_INLINE_MAX
Old name of RUBY_ENCODING_INLINE_MAX.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define FL_ANY_RAW
Old name of RB_FL_ANY_RAW.
#define MBCLEN_INVALID_P(ret)
Old name of ONIGENC_MBCLEN_INVALID_P.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define MBCLEN_NEEDMORE_P(ret)
Old name of ONIGENC_MBCLEN_NEEDMORE_P.
#define FIXNUM_MAX
Old name of RUBY_FIXNUM_MAX.
#define NUM2INT
Old name of RB_NUM2INT.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define ENC_CODERANGE_BROKEN
Old name of RUBY_ENC_CODERANGE_BROKEN.
#define scan_hex(s, l, e)
Old name of ruby_scan_hex.
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define NUM2ULL
Old name of RB_NUM2ULL.
#define DBL2NUM
Old name of rb_float_new.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define ENCODING_SHIFT
Old name of RUBY_ENCODING_SHIFT.
#define FL_TEST
Old name of RB_FL_TEST.
#define FL_FREEZE
Old name of RUBY_FL_FREEZE.
#define ENCODING_GET_INLINED(obj)
Old name of RB_ENCODING_GET_INLINED.
#define ENC_CODERANGE_CLEAR(obj)
Old name of RB_ENC_CODERANGE_CLEAR.
#define FL_UNSET
Old name of RB_FL_UNSET.
#define UINT2NUM
Old name of RB_UINT2NUM.
#define ENCODING_IS_ASCII8BIT(obj)
Old name of RB_ENCODING_IS_ASCII8BIT.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define NUM2LEN
Old name of RB_NUM2LEN.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define ENC_CODERANGE_SET(obj, cr)
Old name of RB_ENC_CODERANGE_SET.
#define ENCODING_CODERANGE_SET(obj, encindex, cr)
Old name of RB_ENCODING_CODERANGE_SET.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define OBJ_FROZEN_RAW
Old name of RB_OBJ_FROZEN_RAW.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
#define ENCODING_MASK
Old name of RUBY_ENCODING_MASK.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_syserr_fail(int e, const char *mesg)
Raises appropriate exception that represents a C errno.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEncCompatError
Encoding::CompatibilityError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_eArgError
ArgumentError exception.
VALUE rb_eIndexError
IndexError exception.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
VALUE rb_cObject
Object class.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
Identical to rb_class_new_instance(), except it passes the passed keywords if any to the #initialize ...
VALUE rb_obj_frozen_p(VALUE obj)
Same as RB_OBJ_FROZEN(), but returns Qtrue/Qfalse instead of bool.
double rb_str_to_dbl(VALUE str, int mode)
Identical to rb_cstr_to_dbl(), except it accepts a Ruby's string instead of C's.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_obj_dup(VALUE obj)
Duplicates the given object.
VALUE rb_cSymbol
Symbol class.
VALUE rb_cRange
Range class.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_obj_freeze(VALUE obj)
Same as RB_OBJ_FREEZE(), but returns the given object.
VALUE rb_mComparable
Comparable module.
VALUE rb_cString
String class.
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with RUBY_DEBUG.
#define RBIMPL_ASSERT_OR_ASSUME(...)
This is either RUBY_ASSERT or RBIMPL_ASSUME, depending on RUBY_DEBUG.
#define RUBY_ASSERT_BUILTIN_TYPE(obj, type)
A variant of RUBY_ASSERT that asserts when either RUBY_DEBUG or built-in type of obj is type.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
rb_encoding * rb_utf8_encoding(void)
Queries the encoding that represents UTF-8.
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
rb_encoding * rb_filesystem_encoding(void)
Queries the "filesystem" encoding.
rb_encoding * rb_default_internal_encoding(void)
Queries the "default internal" encoding.
static char * rb_enc_left_char_head(const char *s, const char *p, const char *e, rb_encoding *enc)
Queries the left boundary of a character.
int rb_utf8_encindex(void)
Identical to rb_utf8_encoding(), except it returns the encoding's index instead of the encoding itsel...
int rb_ascii8bit_encindex(void)
Identical to rb_ascii8bit_encoding(), except it returns the encoding's index instead of the encoding ...
static char * rb_enc_right_char_head(const char *s, const char *p, const char *e, rb_encoding *enc)
Queries the right boundary of a character.
static unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc)
Queries the code point of character pointed by the passed pointer.
rb_encoding * rb_default_external_encoding(void)
Queries the "default external" encoding.
static int rb_enc_mbmaxlen(rb_encoding *enc)
Queries the maximum number of bytes that the passed encoding needs to represent a character.
static int RB_ENCODING_GET_INLINED(VALUE obj)
Queries the encoding of the passed object.
rb_encoding * rb_locale_encoding(void)
Queries the encoding that represents the current locale.
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
static int rb_enc_code_to_mbclen(int c, rb_encoding *enc)
Identical to rb_enc_codelen(), except it returns 0 for invalid code points.
static char * rb_enc_step_back(const char *s, const char *p, const char *e, int n, rb_encoding *enc)
Scans the string backwards for n characters.
int rb_usascii_encindex(void)
Identical to rb_usascii_encoding(), except it returns the encoding's index instead of the encoding it...
rb_len_t rb_enc_strlen(const char *head, const char *tail, rb_encoding *enc)
Counts the number of characters of the passed string, according to the passed encoding.
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
Encoding conversion main routine.
rb_len_t rb_memsearch(const void *x, rb_len_t m, const void *y, rb_len_t n, rb_encoding *enc)
Looks for the passed string in the passed buffer.
VALUE rb_enc_str_new_static(const char *ptr, rb_len_t len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it takes a C string literal.
VALUE rb_external_str_new_with_enc(const char *ptr, rb_len_t len, rb_encoding *enc)
Identical to rb_external_str_new(), except it additionally takes an encoding.
VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts)
Identical to rb_str_conv_enc(), except it additionally takes IO encoder options.
VALUE rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_export_to_enc(VALUE obj, rb_encoding *enc)
Identical to rb_str_export(), except it additionally takes an encoding.
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, rb_len_t len, rb_encoding *enc)
Identical to rb_str_cat(), except it additionally takes an encoding.
int rb_enc_str_asciionly_p(VALUE str)
Queries if the passed string is "ASCII only".
VALUE rb_enc_interned_str(const char *ptr, rb_len_t len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it returns a "f"string.
VALUE rb_enc_interned_str_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new_cstr(), except it returns a "f"string.
char * rb_enc_nth(const char *head, const char *tail, rb_len_t nth, rb_encoding *enc)
Queries the n-th character.
int rb_enc_symname2_p(const char *name, rb_len_t len, rb_encoding *enc)
Identical to rb_enc_symname_p(), except it additionally takes the passed string's length.
rb_econv_result_t rb_econv_convert(rb_econv_t *ec, const unsigned char **source_buffer_ptr, const unsigned char *source_buffer_end, unsigned char **destination_buffer_ptr, unsigned char *destination_buffer_end, int flags)
Converts a string from an encoding to another.
rb_econv_result_t
return value of rb_econv_convert()
@ econv_finished
The conversion stopped after converting everything.
@ econv_destination_buffer_full
The conversion stopped because there is no destination.
rb_econv_t * rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE ecopts)
Identical to rb_econv_open(), except it additionally takes a hash of optional strings.
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
Converts the contents of the passed string from its encoding to the passed one.
void rb_econv_close(rb_econv_t *ec)
Destructs a converter.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcall(), except it takes the method arguments as a C array.
VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval, int kw_splat)
Identical to rb_funcallv_with_block(), except you can specify how to handle the last element of the g...
VALUE rb_ary_new_capa(rb_len_t capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_freeze(VALUE obj)
Freeze an array, preventing further modifications.
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
VALUE rb_fs
The field separator character for inputs, or the $;.
VALUE rb_default_rs
This is the default value of rb_rs, i.e.
VALUE rb_backref_get(void)
Queries the last match, or Regexp.last_match, or the $~.
VALUE rb_sym_all_symbols(void)
Collects every single bits of symbols that have ever interned in the entire history of the current pr...
void rb_backref_set(VALUE md)
Updates $~.
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Deconstructs a range into its components.
VALUE rb_range_beg_len(VALUE range, rb_len_t *begp, rb_len_t *lenp, rb_len_t len, int err)
Deconstructs a numerical range.
int rb_reg_backref_number(VALUE match, VALUE backref)
Queries the index of the given named capture.
int rb_reg_options(VALUE re)
Queries the options of the passed regular expression.
VALUE rb_reg_match(VALUE re, VALUE str)
This is the match operator.
void rb_match_busy(VALUE md)
Asserts that the given MatchData is "occupied".
VALUE rb_reg_nth_match(int n, VALUE md)
Queries the nth captured substring.
VALUE rb_filesystem_str_new(const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it generates a string of "filesystem" encoding.
void rb_str_modify_expand(VALUE str, rb_len_t capa)
Identical to rb_str_modify(), except it additionally expands the capacity of the receiver.
void rb_str_free(VALUE str)
Destroys the given string for no reason.
rb_len_t rb_str_offset(VALUE str, rb_len_t pos)
"Inverse" of rb_str_sublen().
VALUE rb_str_subseq(VALUE str, rb_len_t beg, rb_len_t len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
rb_len_t rb_str_strlen(VALUE str)
Counts the number of characters (not bytes) that are stored inside of the given string.
VALUE rb_str_new_shared(VALUE str)
Identical to rb_str_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_str_plus(VALUE lhs, VALUE rhs)
Generates a new string, concatenating the former to the latter.
#define rb_utf8_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "UTF-8" encoding.
#define rb_hash_end(h)
Just another name of st_hash_end.
#define rb_hash_uint32(h, i)
Just another name of st_hash_uint32.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
VALUE rb_str_tmp_new(rb_len_t len)
Allocates a "temporary" string.
VALUE rb_sym_to_s(VALUE sym)
This is an rb_sym2str() + rb_str_dup() combo.
VALUE rb_str_times(VALUE str, VALUE num)
Repetition of a string.
VALUE rb_str_succ(VALUE orig)
Searches for the "successor" of a string.
int rb_str_hash_cmp(VALUE str1, VALUE str2)
Compares two strings.
VALUE rb_utf8_str_new_static(const char *ptr, rb_len_t len)
Identical to rb_str_new_static(), except it generates a string of "UTF-8" encoding instead of "binary...
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
void rb_str_shared_replace(VALUE dst, VALUE src)
Replaces the contents of the former with the latter.
#define rb_str_buf_cat
Just another name of rb_str_cat.
#define rb_usascii_str_new(str, len)
Identical to rb_str_new, except it generates a string of "US ASCII" encoding.
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
rb_len_t rb_str_sublen(VALUE str, rb_len_t pos)
Byte offset to character offset conversion.
VALUE rb_external_str_new(const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it generates a string of "defaultexternal" encoding.
VALUE rb_str_new_frozen(VALUE str)
Creates a frozen copy of the string, if necessary.
void rb_str_set_len(VALUE str, rb_len_t len)
Overwrites the length of the string.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
st_index_t rb_str_hash(VALUE str)
Calculates a hash value of a string.
VALUE rb_str_ellipsize(VALUE str, rb_len_t len)
Shortens str and adds three dots, an ellipsis, if it is longer than len characters.
VALUE rb_str_cat(VALUE dst, const char *src, rb_len_t srclen)
Destructively appends the passed contents to the string.
VALUE rb_str_locktmp(VALUE str)
Obtains a "temporary lock" of the string.
VALUE rb_str_resurrect(VALUE str)
Like rb_str_dup(), but always create an instance of rb_cString regardless of the given object's class...
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
VALUE rb_str_new_static(const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it takes a C string literal.
#define rb_usascii_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "US ASCII" encoding.
VALUE rb_str_new_with_class(VALUE obj, const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it takes the class of the allocating object.
VALUE rb_str_replace(VALUE dst, VALUE src)
Replaces the contents of the former object with the stringised contents of the latter.
VALUE rb_str_no_gvl_safe_acquire(VALUE orig)
Creates a frozen copy of orig that guarantees the RSTRING_PTR is safe to use in operations that relea...
rb_gvar_setter_t rb_str_setter
This is a rb_gvar_setter_t that refutes non-string assignments.
VALUE rb_interned_str_cstr(const char *ptr)
Identical to rb_interned_str(), except it assumes the passed pointer is a pointer to a C's string.
VALUE rb_filesystem_str_new_cstr(const char *ptr)
Identical to rb_filesystem_str_new(), except it assumes the passed pointer is a pointer to a C string...
VALUE rb_str_drop_bytes(VALUE str, rb_len_t len)
Shrinks the given string for the given number of bytes.
#define rb_external_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "defaultexternal" encoding.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
st_index_t rb_memhash(const void *ptr, rb_len_t len)
This is a universal hash function.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
void rb_str_no_gvl_safe_release(VALUE orig, VALUE tmp)
Releases a string created from rb_str_no_gvl_safe_acquire.
void rb_str_update(VALUE dst, rb_len_t beg, rb_len_t len, VALUE src)
Replaces some (or all) of the contents of the given string.
VALUE rb_str_inspect(VALUE str)
Generates a "readable" version of the receiver.
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
VALUE rb_str_substr(VALUE str, rb_len_t beg, rb_len_t len)
This is the implementation of two-argumented String#slice.
int rb_str_cmp(VALUE lhs, VALUE rhs)
Compares two strings, as in strcmp(3).
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
int rb_str_comparable(VALUE str1, VALUE str2)
Checks if two strings are comparable each other or not.
VALUE rb_usascii_str_new_static(const char *ptr, rb_len_t len)
Identical to rb_str_new_static(), except it generates a string of "US ASCII" encoding instead of "bin...
#define rb_strlen_lit(str)
Length of a string literal.
VALUE rb_interned_str(const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it returns an infamous "f"string.
VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src)
Identical to rb_str_cat_cstr(), except it additionally assumes the source string be a NUL terminated ...
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
char * rb_str_subpos(VALUE str, rb_len_t beg, rb_len_t *len)
Identical to rb_str_substr(), except it returns a C's string instead of Ruby's.
VALUE rb_str_scrub(VALUE str, VALUE repl)
"Cleanses" the string.
#define rb_locale_str_new_cstr(str)
Identical to rb_external_str_new_cstr, except it generates a string of "locale" encoding instead of "...
VALUE rb_str_buf_new(rb_len_t capa)
Allocates a "string buffer".
#define rb_str_dup_frozen
Just another name of rb_str_new_frozen.
VALUE rb_locale_str_new(const char *ptr, rb_len_t len)
Identical to rb_str_new(), except it generates a string of "locale" encoding.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_unlocktmp(VALUE str)
Releases a lock formerly obtained by rb_str_locktmp().
#define rb_utf8_str_new(str, len)
Identical to rb_str_new, except it generates a string of "UTF-8" encoding.
VALUE rb_str_dump(VALUE str)
"Inverse" of rb_eval_string().
VALUE rb_str_length(VALUE)
Identical to rb_str_strlen(), except it returns the value in rb_cInteger.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_str_split(VALUE str, const char *delim)
Divides the given string based on the given delimiter.
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_ivar_defined(VALUE obj, ID name)
Queries if the instance variable is defined at the object.
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
ID rb_to_id(VALUE str)
Identical to rb_intern_str(), except it tries to convert the parameter object to an instance of rb_cS...
int capa
Designed capacity of the buffer.
int off
Offset inside of ptr.
int len
Length of the buffer.
#define RB_OBJ_SET_SHAREABLE(obj)
Wrapper of rb_obj_set_shareable().
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
rb_len_t rb_reg_search(VALUE re, VALUE str, rb_len_t pos, int dir)
Runs the passed regular expression over the passed string.
VALUE rb_reg_regcomp(VALUE str)
Creates a new instance of rb_cRegexp.
int ruby_thread_has_gvl_p(void)
Whether the current thread is holding the GVL.
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
VALUE rb_yield(VALUE val)
Yields the block.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
void rb_define_hooked_variable(const char *q, VALUE *w, type *e, void_type *r)
Define a function-backended global variable.
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
VALUE rb_ensure(type *q, VALUE w, type *e, VALUE r)
An equivalent of ensure clause.
Defines RBIMPL_ATTR_NONSTRING.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define RHASH_SIZE(h)
Queries the size of the hash.
#define RMATCH(obj)
Convenient casting macro.
static VALUE RREGEXP_SRC(VALUE rexp)
Convenient getter function.
#define StringValue(v)
Ensures that the parameter object is a String.
VALUE rb_str_export_locale(VALUE obj)
Identical to rb_str_export(), except it converts into the locale encoding instead.
char * rb_string_value_cstr(volatile VALUE *ptr)
Identical to rb_string_value_ptr(), except it additionally checks for the contents for viability as a...
static int RSTRING_LENINT(VALUE str)
Identical to RSTRING_LEN(), except it differs for the return type.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
static rb_len_t RSTRING_LEN(VALUE str)
Queries the length of the string.
VALUE rb_string_value(volatile VALUE *ptr)
Identical to rb_str_to_str(), except it fills the passed pointer with the converted object.
#define RSTRING(obj)
Convenient casting macro.
VALUE rb_str_export(VALUE obj)
Identical to rb_str_to_str(), except it additionally converts the string into default external encodi...
char * rb_string_value_ptr(volatile VALUE *ptr)
Identical to rb_str_to_str(), except it returns the converted string's backend memory region.
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
static char * RSTRING_PTR(VALUE str)
Queries the contents pointer of the string.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define DATA_PTR(obj)
Convenient casting macro for backward compatibility.
#define TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
VALUE rb_require(const char *feature)
Identical to rb_require_string(), except it takes C's string instead of Ruby's.
#define errno
Ractor-aware version of errno.
#define RB_NUM2SSIZE
Converts an instance of rb_cInteger into C's ssize_t.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
VALUE flags
Per-object flags.
rb_len_t len
Length of the string, not including terminating NUL character.
struct RBasic basic
Basic part, including flags and class.
union RString::@157025041137035241047331270155043025061071337053::@157067065136062356112324002106172053054013023024::@365170260060164113275356137374160141226332013204 aux
Auxiliary info.
struct RString::@157025041137035241047331270155043025061071337053::@153056146250355212360325351117351053336274231135 embed
Embedded contents.
VALUE shared
Parent of the string.
char * ptr
Pointer to the contents of the string.
rb_len_t capa
Capacity of *ptr.
union RString::@157025041137035241047331270155043025061071337053 as
String's specific fields.
struct RString::@157025041137035241047331270155043025061071337053::@157067065136062356112324002106172053054013023024 heap
Strings that use separated memory region for contents use this pattern.
void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock)
Blocks until the current thread obtains a lock.
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
#define RB_LEN_MAX
Maximum possible value that a rb_len_t can take.
#define RB_LEN_MIN
Minimum possible value that a rb_len_t can take.
unsigned long rb_ulen_t
An unsigned integer type that has the same width with rb_len_t.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static enum ruby_value_type rb_type(VALUE obj)
Identical to RB_BUILTIN_TYPE(), except it can also accept special constants.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
ruby_value_type
C-level type of an object.