14#include "ruby/internal/config.h"
24#include "debug_counter.h"
28#include "internal/array.h"
29#include "internal/compar.h"
30#include "internal/compilers.h"
31#include "internal/concurrent_set.h"
32#include "internal/encoding.h"
33#include "internal/error.h"
34#include "internal/gc.h"
35#include "internal/hash.h"
36#include "internal/numeric.h"
37#include "internal/object.h"
38#include "internal/proc.h"
39#include "internal/re.h"
40#include "internal/sanitizers.h"
41#include "internal/string.h"
42#include "internal/transcode.h"
49#include "ruby_assert.h"
54#if defined HAVE_CRYPT_R
55# if defined HAVE_CRYPT_H
58#elif !defined HAVE_CRYPT
59# include "missing/crypt.h"
60# define HAVE_CRYPT_R 1
63#define BEG(no) (regs->beg[(no)])
64#define END(no) (regs->end[(no)])
67#undef rb_usascii_str_new
71#undef rb_usascii_str_new_cstr
72#undef rb_utf8_str_new_cstr
73#undef rb_enc_str_new_cstr
74#undef rb_external_str_new_cstr
75#undef rb_locale_str_new_cstr
76#undef rb_str_dup_frozen
77#undef rb_str_buf_new_cstr
131#define RUBY_MAX_CHAR_LEN 16
132#define STR_PRECOMPUTED_HASH FL_USER4
133#define STR_SHARED_ROOT FL_USER5
134#define STR_BORROWED FL_USER6
135#define STR_TMPLOCK FL_USER7
136#define STR_NOFREE FL_USER18
137#define STR_FAKESTR FL_USER19
139#define STR_SET_NOEMBED(str) do {\
140 FL_SET((str), STR_NOEMBED);\
141 FL_UNSET((str), STR_SHARED | STR_SHARED_ROOT | STR_BORROWED);\
143#define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED | STR_SHARED | STR_NOFREE)
145#define STR_SET_LEN(str, n) do { \
146 RSTRING(str)->len = (n); \
150str_encindex_fastpath(
int encindex)
154 case ENCINDEX_ASCII_8BIT:
156 case ENCINDEX_US_ASCII:
164str_enc_fastpath(
VALUE str)
169#define TERM_LEN(str) (str_enc_fastpath(str) ? 1 : rb_enc_mbminlen(rb_enc_from_index(ENCODING_GET(str))))
170#define TERM_FILL(ptr, termlen) do {\
171 char *const term_fill_ptr = (ptr);\
172 const int term_fill_len = (termlen);\
173 *term_fill_ptr = '\0';\
174 if (UNLIKELY(term_fill_len > 1))\
175 memset(term_fill_ptr, 0, term_fill_len);\
178#define RESIZE_CAPA(str,capacity) do {\
179 const int termlen = TERM_LEN(str);\
180 RESIZE_CAPA_TERM(str,capacity,termlen);\
182#define RESIZE_CAPA_TERM(str,capacity,termlen) do {\
183 if (STR_EMBED_P(str)) {\
184 if (str_embed_capa(str) < capacity + termlen) {\
185 char *const tmp = ALLOC_N(char, (size_t)(capacity) + (termlen));\
186 const long tlen = RSTRING_LEN(str);\
187 memcpy(tmp, RSTRING_PTR(str), str_embed_capa(str));\
188 RSTRING(str)->as.heap.ptr = tmp;\
189 RSTRING(str)->len = tlen;\
190 STR_SET_NOEMBED(str);\
191 RSTRING(str)->as.heap.aux.capa = (capacity);\
195 RUBY_ASSERT(!FL_TEST((str), STR_SHARED)); \
196 SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \
197 (size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \
198 RSTRING(str)->as.heap.aux.capa = (capacity);\
202#define STR_SET_SHARED(str, shared_str) do { \
203 if (!FL_TEST(str, STR_FAKESTR)) { \
204 RUBY_ASSERT(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \
205 RUBY_ASSERT(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \
206 RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \
207 FL_SET((str), STR_SHARED); \
208 FL_SET((shared_str), STR_SHARED_ROOT); \
209 if (RBASIC_CLASS((shared_str)) == 0) \
210 FL_SET_RAW((shared_str), STR_BORROWED); \
214#define STR_HEAP_PTR(str) (RSTRING(str)->as.heap.ptr)
215#define STR_HEAP_SIZE(str) ((size_t)RSTRING(str)->as.heap.aux.capa + TERM_LEN(str))
218#define STR_ENC_GET(str) get_encoding(str)
220#if !defined SHARABLE_MIDDLE_SUBSTRING
221# define SHARABLE_MIDDLE_SUBSTRING 0
223#if !SHARABLE_MIDDLE_SUBSTRING
224#define SHARABLE_SUBSTRING_P(beg, len, end) ((beg) + (len) == (end))
226#define SHARABLE_SUBSTRING_P(beg, len, end) 1
231str_embed_capa(
VALUE str)
233 return rb_gc_obj_slot_size(str) - offsetof(
struct RString, as.embed.ary);
237rb_str_reembeddable_p(
VALUE str)
239 return !
FL_TEST(str, STR_NOFREE|STR_SHARED_ROOT|STR_SHARED);
243rb_str_embed_size(
long capa,
long termlen)
245 size_t size = offsetof(
struct RString, as.embed.ary) +
capa + termlen;
251rb_str_size_as_embedded(
VALUE str)
254 if (STR_EMBED_P(str)) {
256 if (
FL_TEST_RAW(str, STR_PRECOMPUTED_HASH))
capa +=
sizeof(st_index_t);
258 real_size = rb_str_embed_size(
capa, TERM_LEN(str));
262 else if (rb_str_reembeddable_p(str)) {
264 if (
FL_TEST_RAW(str, STR_PRECOMPUTED_HASH))
capa +=
sizeof(st_index_t);
266 real_size = rb_str_embed_size(
capa, TERM_LEN(str));
269 real_size =
sizeof(
struct RString);
276STR_EMBEDDABLE_P(
long len,
long termlen)
278 return rb_gc_size_allocatable_p(rb_str_embed_size(
len, termlen));
283static VALUE str_new_frozen_buffer(
VALUE klass,
VALUE orig,
int copy_encoding);
284static VALUE str_new_static(
VALUE klass,
const char *
ptr,
long len,
int encindex);
286static void str_make_independent_expand(
VALUE str,
long len,
long expand,
const int termlen);
287static inline void str_modifiable(
VALUE str);
292str_make_independent(
VALUE str)
294 long len = RSTRING_LEN(str);
295 int termlen = TERM_LEN(str);
296 str_make_independent_expand((str),
len, 0L, termlen);
299static inline int str_dependent_p(
VALUE str);
302rb_str_make_independent(
VALUE str)
304 if (str_dependent_p(str)) {
305 str_make_independent(str);
310rb_str_make_embedded(
VALUE str)
315 char *buf =
RSTRING(str)->as.heap.ptr;
319 STR_SET_LEN(str,
len);
322 memcpy(RSTRING_PTR(str), buf,
len);
326 TERM_FILL(
RSTRING(str)->as.embed.ary +
len, TERM_LEN(str));
334rb_str_make_heap(
VALUE str)
336 if (STR_EMBED_P(str)) {
337 const int termlen = TERM_LEN(str);
338 long len = RSTRING_LEN(str);
344rb_debug_rstring_null_ptr(
const char *func)
346 fprintf(stderr,
"%s is returning NULL!! "
347 "SIGSEGV is highly expected to follow immediately.\n"
348 "If you could reproduce, attach your debugger here, "
349 "and look at the passed string.\n",
354static VALUE sym_ascii, sym_turkic, sym_lithuanian, sym_fold;
357get_encoding(
VALUE str)
363mustnot_broken(
VALUE str)
365 if (is_broken_string(str)) {
366 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str)));
371mustnot_wchar(
VALUE str)
373 rb_encoding *enc = STR_ENC_GET(str);
374 if (rb_enc_mbminlen(enc) > 1) {
375 rb_raise(rb_eArgError,
"wide char encoding: %s", rb_enc_name(enc));
379static VALUE register_fstring(
VALUE str,
bool copy,
bool force_precompute_hash);
381#if SIZEOF_LONG == SIZEOF_VOIDP
382#define PRECOMPUTED_FAKESTR_HASH 1
387BARE_STRING_P(
VALUE str)
389 return RBASIC_CLASS(str) ==
rb_cString && !rb_shape_obj_has_ivars(str);
392static inline st_index_t
393str_do_hash(
VALUE str)
395 st_index_t h =
rb_memhash((
const void *)RSTRING_PTR(str), RSTRING_LEN(str));
397 if (e && !is_ascii_string(str)) {
404str_store_precomputed_hash(
VALUE str, st_index_t hash)
410 size_t used_bytes = (RSTRING_LEN(str) + TERM_LEN(str));
411 size_t free_bytes = str_embed_capa(str) - used_bytes;
415 memcpy(RSTRING_END(str) + TERM_LEN(str), &hash,
sizeof(hash));
417 FL_SET(str, STR_PRECOMPUTED_HASH);
430 if (
FL_TEST(str, RSTRING_FSTR))
433 bare = BARE_STRING_P(str);
435 if (STR_EMBED_P(str)) {
440 if (
FL_TEST_RAW(str, STR_SHARED_ROOT | STR_SHARED) == STR_SHARED_ROOT) {
447 rb_str_resize(str, RSTRING_LEN(str));
449 fstr = register_fstring(str,
false,
false);
452 str_replace_shared_without_enc(str, fstr);
459static VALUE fstring_table_obj;
462fstring_concurrent_set_hash(
VALUE str)
464#ifdef PRECOMPUTED_FAKESTR_HASH
468 h = (st_index_t)
RSTRING(str)->as.heap.aux.capa;
485 const char *aptr, *bptr;
492 return (alen == blen &&
494 memcmp(aptr, bptr, alen) == 0);
499 bool force_precompute_hash;
503fstring_concurrent_set_create(
VALUE str,
void *data)
513 long len = RSTRING_LEN(str);
514 long capa =
len +
sizeof(st_index_t);
515 int term_len = TERM_LEN(str);
517 if (arg->force_precompute_hash && STR_EMBEDDABLE_P(
capa, term_len)) {
519 memcpy(RSTRING_PTR(new_str), RSTRING_PTR(str),
len);
520 STR_SET_LEN(new_str, RSTRING_LEN(str));
521 TERM_FILL(RSTRING_END(new_str), TERM_LEN(str));
522 rb_enc_copy(new_str, str);
523 str_store_precomputed_hash(new_str, str_do_hash(str));
527 rb_enc_copy(new_str, str);
528#ifdef PRECOMPUTED_FAKESTR_HASH
529 if (
rb_str_capacity(new_str) >= RSTRING_LEN(str) + term_len +
sizeof(st_index_t)) {
530 str_store_precomputed_hash(new_str, (st_index_t)
RSTRING(str)->as.heap.aux.capa);
544 if (!
OBJ_FROZEN(str) || CHILLED_STRING_P(str)) {
547 if (STR_SHARED_P(str)) {
549 str_make_independent(str);
552 if (!BARE_STRING_P(str)) {
558 RBASIC(str)->flags |= RSTRING_FSTR;
560 RB_OBJ_SET_SHAREABLE(str);
574 .hash = fstring_concurrent_set_hash,
575 .cmp = fstring_concurrent_set_cmp,
576 .create = fstring_concurrent_set_create,
581Init_fstring_table(
void)
583 fstring_table_obj = rb_concurrent_set_new(&fstring_concurrent_set_funcs, 8192);
584 rb_gc_register_address(&fstring_table_obj);
588register_fstring(
VALUE str,
bool copy,
bool force_precompute_hash)
592 .force_precompute_hash = force_precompute_hash
595#if SIZEOF_VOIDP == SIZEOF_LONG
599 RSTRING(str)->as.heap.aux.capa = (long)str_do_hash(str);
603 VALUE result = rb_concurrent_set_find_or_insert(&fstring_table_obj, str, &args);
605 RUBY_ASSERT(!rb_objspace_garbage_object_p(result));
617rb_obj_is_fstring_table(
VALUE obj)
621 return obj == fstring_table_obj;
625rb_gc_free_fstring(
VALUE obj)
627 ASSERT_vm_locking_with_barrier();
633 rb_concurrent_set_delete_by_identity(fstring_table_obj, obj);
635 RB_DEBUG_COUNTER_INC(obj_str_fstr);
641rb_fstring_foreach_with_replace(
int (*callback)(
VALUE *str,
void *data),
void *data)
643 if (fstring_table_obj) {
644 rb_concurrent_set_foreach_with_replace(fstring_table_obj, callback, data);
649setup_fake_str(
struct RString *fake_str,
const char *name,
long len,
int encidx)
652 RBASIC_SET_SHAPE_ID((
VALUE)fake_str, ROOT_SHAPE_ID);
663 fake_str->as.heap.ptr = (
char *)name;
664 fake_str->as.heap.aux.capa =
len;
665 return (
VALUE)fake_str;
672rb_setup_fake_str(
struct RString *fake_str,
const char *name,
long len, rb_encoding *enc)
674 return setup_fake_str(fake_str, name,
len, rb_enc_to_index(enc));
683rb_fstring_new(
const char *
ptr,
long len)
685 struct RString fake_str = {RBASIC_INIT};
686 return register_fstring(setup_fake_str(&fake_str,
ptr,
len, ENCINDEX_US_ASCII),
false,
false);
690rb_fstring_enc_new(
const char *
ptr,
long len, rb_encoding *enc)
692 struct RString fake_str = {RBASIC_INIT};
693 return register_fstring(rb_setup_fake_str(&fake_str,
ptr,
len, enc),
false,
false);
697rb_fstring_cstr(
const char *
ptr)
699 return rb_fstring_new(
ptr, strlen(
ptr));
703single_byte_optimizable(
VALUE str)
707 case ENCINDEX_ASCII_8BIT:
708 case ENCINDEX_US_ASCII:
719 if (rb_enc_mbmaxlen(rb_enc_from_index(encindex)) == 1) {
730static inline const char *
731search_nonascii(
const char *p,
const char *e)
735#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
736# if SIZEOF_UINTPTR_T == 8
737# define NONASCII_MASK UINT64_C(0x8080808080808080)
738# elif SIZEOF_UINTPTR_T == 4
739# define NONASCII_MASK UINT32_C(0x80808080)
741# error "don't know what to do."
744# if SIZEOF_UINTPTR_T == 8
745# define NONASCII_MASK ((uintptr_t)0x80808080UL << 32 | (uintptr_t)0x80808080UL)
746# elif SIZEOF_UINTPTR_T == 4
747# define NONASCII_MASK 0x80808080UL
749# error "don't know what to do."
753 if (UNALIGNED_WORD_ACCESS || e - p >= SIZEOF_VOIDP) {
754#if !UNALIGNED_WORD_ACCESS
755 if ((uintptr_t)p % SIZEOF_VOIDP) {
756 int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP;
761 case 7:
if (p[-7]&0x80)
return p-7;
762 case 6:
if (p[-6]&0x80)
return p-6;
763 case 5:
if (p[-5]&0x80)
return p-5;
764 case 4:
if (p[-4]&0x80)
return p-4;
766 case 3:
if (p[-3]&0x80)
return p-3;
767 case 2:
if (p[-2]&0x80)
return p-2;
768 case 1:
if (p[-1]&0x80)
return p-1;
773#if defined(HAVE_BUILTIN___BUILTIN_ASSUME_ALIGNED) &&! UNALIGNED_WORD_ACCESS
774#define aligned_ptr(value) \
775 __builtin_assume_aligned((value), sizeof(uintptr_t))
777#define aligned_ptr(value) (value)
780 t = (e - (SIZEOF_VOIDP-1));
782 for (;s < t; s +=
sizeof(uintptr_t)) {
784 memcpy(&word, s,
sizeof(word));
785 if (word & NONASCII_MASK) {
786#ifdef WORDS_BIGENDIAN
787 return (
const char *)s + (nlz_intptr(word&NONASCII_MASK)>>3);
789 return (
const char *)s + (ntz_intptr(word&NONASCII_MASK)>>3);
799 case 7:
if (e[-7]&0x80)
return e-7;
800 case 6:
if (e[-6]&0x80)
return e-6;
801 case 5:
if (e[-5]&0x80)
return e-5;
802 case 4:
if (e[-4]&0x80)
return e-4;
804 case 3:
if (e[-3]&0x80)
return e-3;
805 case 2:
if (e[-2]&0x80)
return e-2;
806 case 1:
if (e[-1]&0x80)
return e-1;
812coderange_scan(
const char *p,
long len, rb_encoding *enc)
814 const char *e = p +
len;
816 if (rb_enc_to_index(enc) == rb_ascii8bit_encindex()) {
818 p = search_nonascii(p, e);
822 if (rb_enc_asciicompat(enc)) {
823 p = search_nonascii(p, e);
826 int ret = rb_enc_precise_mbclen(p, e, enc);
830 p = search_nonascii(p, e);
836 int ret = rb_enc_precise_mbclen(p, e, enc);
845rb_str_coderange_scan_restartable(
const char *s,
const char *e, rb_encoding *enc,
int *cr)
852 if (rb_enc_to_index(enc) == rb_ascii8bit_encindex()) {
855 p = search_nonascii(p, e);
859 else if (rb_enc_asciicompat(enc)) {
860 p = search_nonascii(p, e);
866 int ret = rb_enc_precise_mbclen(p, e, enc);
873 p = search_nonascii(p, e);
879 int ret = rb_enc_precise_mbclen(p, e, enc);
902 RUBY_ASSERT(TERM_LEN(str2) <= TERM_LEN(str1) || str_dependent_p(str1) ||
903 (STR_EMBED_P(str1) &&
904 str_embed_capa(str1) >= RSTRING_LEN(str1) + TERM_LEN(str2)));
905 int inlined_encoding = RB_ENCODING_GET_INLINED(str2);
907 rb_enc_set_index(str1, rb_enc_get_index(str2));
915rb_enc_cr_str_copy_for_substr(
VALUE dest,
VALUE src)
920 str_enc_copy(dest, src);
921 if (RSTRING_LEN(dest) == 0) {
922 if (!rb_enc_asciicompat(STR_ENC_GET(src)))
933 if (!rb_enc_asciicompat(STR_ENC_GET(src)) ||
934 search_nonascii(RSTRING_PTR(dest), RSTRING_END(dest)))
945rb_enc_cr_str_exact_copy(
VALUE dest,
VALUE src)
947 str_enc_copy(dest, src);
952enc_coderange_scan(
VALUE str, rb_encoding *enc)
954 return coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), enc);
958rb_enc_str_coderange_scan(
VALUE str, rb_encoding *enc)
960 return enc_coderange_scan(str, enc);
969 cr = enc_coderange_scan(str, get_encoding(str));
976rb_enc_str_asciicompat(
VALUE str)
979 return str_encindex_fastpath(encindex) || rb_enc_asciicompat(rb_enc_get_from_index(encindex));
987 return rb_enc_str_asciicompat(str) && is_ascii_string(str);
996str_mod_check(
VALUE s,
const char *p,
long len)
998 if (RSTRING_PTR(s) != p || RSTRING_LEN(s) !=
len){
1004str_capacity(
VALUE str,
const int termlen)
1006 if (STR_EMBED_P(str)) {
1007 return str_embed_capa(str) - termlen;
1009 else if (
FL_ANY_RAW(str, STR_SHARED|STR_NOFREE)) {
1013 return RSTRING(str)->as.heap.aux.capa;
1020 return str_capacity(str, TERM_LEN(str));
1024must_not_null(
const char *
ptr)
1027 rb_raise(rb_eArgError,
"NULL pointer given");
1032str_alloc_embed(
VALUE klass,
size_t capa)
1034 size_t size = rb_str_embed_size(
capa, 0);
1038 NEWOBJ_OF(str,
struct RString, klass,
1042 str->as.embed.ary[0] = 0;
1048str_alloc_heap(
VALUE klass)
1050 NEWOBJ_OF(str,
struct RString, klass,
1054 str->as.heap.aux.capa = 0;
1055 str->as.heap.ptr = NULL;
1061empty_str_alloc(
VALUE klass)
1063 RUBY_DTRACE_CREATE_HOOK(STRING, 0);
1064 VALUE str = str_alloc_embed(klass, 0);
1065 memset(
RSTRING(str)->as.embed.ary, 0, str_embed_capa(str));
1071str_enc_new(
VALUE klass,
const char *
ptr,
long len, rb_encoding *enc)
1076 rb_raise(rb_eArgError,
"negative string size (or size too big)");
1080 enc = rb_ascii8bit_encoding();
1083 RUBY_DTRACE_CREATE_HOOK(STRING,
len);
1085 int termlen = rb_enc_mbminlen(enc);
1087 if (STR_EMBEDDABLE_P(
len, termlen)) {
1088 str = str_alloc_embed(klass,
len + termlen);
1094 str = str_alloc_heap(klass);
1100 rb_xmalloc_mul_add_mul(
sizeof(
char),
len,
sizeof(
char), termlen);
1103 rb_enc_raw_set(str, enc);
1106 memcpy(RSTRING_PTR(str),
ptr,
len);
1109 memset(RSTRING_PTR(str), 0,
len);
1112 STR_SET_LEN(str,
len);
1113 TERM_FILL(RSTRING_PTR(str) +
len, termlen);
1120 return str_enc_new(klass,
ptr,
len, rb_ascii8bit_encoding());
1142rb_enc_str_new(
const char *
ptr,
long len, rb_encoding *enc)
1155 __msan_unpoison_string(
ptr);
1175 if (rb_enc_mbminlen(enc) != 1) {
1176 rb_raise(rb_eArgError,
"wchar encoding given");
1178 return rb_enc_str_new(
ptr, strlen(
ptr), enc);
1182str_new_static(
VALUE klass,
const char *
ptr,
long len,
int encindex)
1187 rb_raise(rb_eArgError,
"negative string size (or size too big)");
1191 str = str_enc_new(klass,
ptr,
len, rb_enc_from_index(encindex));
1194 RUBY_DTRACE_CREATE_HOOK(STRING,
len);
1195 str = str_alloc_heap(klass);
1199 RBASIC(str)->flags |= STR_NOFREE;
1200 rb_enc_associate_index(str, encindex);
1229static VALUE str_cat_conv_enc_opts(
VALUE newstr,
long ofs,
const char *
ptr,
long len,
1230 rb_encoding *from, rb_encoding *to,
1231 int ecflags,
VALUE ecopts);
1234is_enc_ascii_string(
VALUE str, rb_encoding *enc)
1236 int encidx = rb_enc_to_index(enc);
1237 if (rb_enc_get_index(str) == encidx)
1238 return is_ascii_string(str);
1249 if (!to)
return str;
1250 if (!from) from = rb_enc_get(str);
1251 if (from == to)
return str;
1252 if ((rb_enc_asciicompat(to) && is_enc_ascii_string(str, from)) ||
1253 rb_is_ascii8bit_enc(to)) {
1254 if (STR_ENC_GET(str) != to) {
1256 rb_enc_associate(str, to);
1263 from, to, ecflags, ecopts);
1264 if (
NIL_P(newstr)) {
1272rb_str_cat_conv_enc_opts(
VALUE newstr,
long ofs,
const char *
ptr,
long len,
1273 rb_encoding *from,
int ecflags,
VALUE ecopts)
1277 olen = RSTRING_LEN(newstr);
1278 if (ofs < -olen || olen < ofs)
1280 if (ofs < 0) ofs += olen;
1282 STR_SET_LEN(newstr, ofs);
1286 rb_str_modify(newstr);
1287 return str_cat_conv_enc_opts(newstr, ofs,
ptr,
len, from,
1293rb_str_initialize(
VALUE str,
const char *
ptr,
long len, rb_encoding *enc)
1295 STR_SET_LEN(str, 0);
1296 rb_enc_associate(str, enc);
1302str_cat_conv_enc_opts(
VALUE newstr,
long ofs,
const char *
ptr,
long len,
1303 rb_encoding *from, rb_encoding *to,
1304 int ecflags,
VALUE ecopts)
1309 VALUE econv_wrapper;
1310 const unsigned char *start, *sp;
1311 unsigned char *dest, *dp;
1312 size_t converted_output = (size_t)ofs;
1317 RBASIC_CLEAR_CLASS(econv_wrapper);
1319 if (!ec)
return Qnil;
1322 sp = (
unsigned char*)
ptr;
1324 while ((dest = (
unsigned char*)RSTRING_PTR(newstr)),
1325 (dp = dest + converted_output),
1329 size_t converted_input = sp - start;
1330 size_t rest =
len - converted_input;
1331 converted_output = dp - dest;
1333 if (converted_input && converted_output &&
1334 rest < (LONG_MAX / converted_output)) {
1335 rest = (rest * converted_output) / converted_input;
1340 olen += rest < 2 ? 2 : rest;
1341 rb_str_resize(newstr, olen);
1348 len = dp - (
unsigned char*)RSTRING_PTR(newstr);
1350 rb_enc_associate(newstr, to);
1369 const int eidx = rb_enc_to_index(eenc);
1372 return rb_enc_str_new(
ptr,
len, eenc);
1376 if ((eidx == rb_ascii8bit_encindex()) ||
1377 (eidx == rb_usascii_encindex() && search_nonascii(
ptr,
ptr +
len))) {
1381 ienc = rb_default_internal_encoding();
1382 if (!ienc || eenc == ienc) {
1383 return rb_enc_str_new(
ptr,
len, eenc);
1387 if ((eidx == rb_ascii8bit_encindex()) ||
1388 (eidx == rb_usascii_encindex()) ||
1389 (rb_enc_asciicompat(eenc) && !search_nonascii(
ptr,
ptr +
len))) {
1390 return rb_enc_str_new(
ptr,
len, ienc);
1393 str = rb_enc_str_new(NULL, 0, ienc);
1396 if (
NIL_P(rb_str_cat_conv_enc_opts(str, 0,
ptr,
len, eenc, 0,
Qnil))) {
1397 rb_str_initialize(str,
ptr,
len, eenc);
1403rb_external_str_with_enc(
VALUE str, rb_encoding *eenc)
1405 int eidx = rb_enc_to_index(eenc);
1406 if (eidx == rb_usascii_encindex() &&
1407 !is_ascii_string(str)) {
1408 rb_enc_associate_index(str, rb_ascii8bit_encindex());
1411 rb_enc_associate_index(str, eidx);
1470str_replace_shared_without_enc(
VALUE str2,
VALUE str)
1472 const int termlen = TERM_LEN(str);
1477 if (str_embed_capa(str2) >=
len + termlen) {
1478 char *ptr2 =
RSTRING(str2)->as.embed.ary;
1479 STR_SET_EMBED(str2);
1480 memcpy(ptr2, RSTRING_PTR(str),
len);
1481 TERM_FILL(ptr2+
len, termlen);
1485 if (STR_SHARED_P(str)) {
1486 root =
RSTRING(str)->as.heap.aux.shared;
1495 if (!STR_EMBED_P(str2) && !
FL_TEST_RAW(str2, STR_SHARED|STR_NOFREE)) {
1497 rb_fatal(
"about to free a possible shared root");
1499 char *ptr2 = STR_HEAP_PTR(str2);
1501 ruby_sized_xfree(ptr2, STR_HEAP_SIZE(str2));
1504 FL_SET(str2, STR_NOEMBED);
1506 STR_SET_SHARED(str2, root);
1509 STR_SET_LEN(str2,
len);
1517 str_replace_shared_without_enc(str2, str);
1518 rb_enc_cr_str_exact_copy(str2, str);
1525 return str_replace_shared(str_alloc_heap(klass), str);
1542rb_str_new_frozen_String(
VALUE orig)
1550rb_str_frozen_bare_string(
VALUE orig)
1552 if (RB_LIKELY(BARE_STRING_P(orig) &&
OBJ_FROZEN_RAW(orig)))
return orig;
1557rb_str_tmp_frozen_acquire(
VALUE orig)
1560 return str_new_frozen_buffer(0, orig, FALSE);
1564rb_str_tmp_frozen_no_embed_acquire(
VALUE orig)
1567 if (STR_SHARED_P(orig) && !STR_EMBED_P(
RSTRING(orig)->as.heap.aux.shared))
return rb_str_tmp_frozen_acquire(orig);
1569 VALUE str = str_alloc_heap(0);
1572 FL_SET(str, STR_SHARED_ROOT);
1574 size_t capa = str_capacity(orig, TERM_LEN(orig));
1580 if (STR_EMBED_P(orig) ||
FL_TEST_RAW(orig, STR_SHARED | STR_SHARED_ROOT | RSTRING_FSTR)) {
1581 RSTRING(str)->as.heap.ptr = rb_xmalloc_mul_add_mul(
sizeof(
char),
capa,
sizeof(
char), TERM_LEN(orig));
1582 memcpy(
RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig),
capa);
1588 RBASIC(str)->flags |=
RBASIC(orig)->flags & STR_NOFREE;
1589 RBASIC(orig)->flags &= ~STR_NOFREE;
1590 STR_SET_SHARED(orig, str);
1592 RB_OBJ_SET_SHAREABLE(str);
1604rb_str_tmp_frozen_release(
VALUE orig,
VALUE tmp)
1606 if (RBASIC_CLASS(tmp) != 0)
1609 if (STR_EMBED_P(tmp)) {
1612 else if (
FL_TEST_RAW(orig, STR_SHARED | STR_TMPLOCK) == STR_SHARED &&
1616 if (shared == tmp && !
FL_TEST_RAW(tmp, STR_BORROWED)) {
1618 RUBY_ASSERT(RSTRING_LEN(orig) == RSTRING_LEN(tmp));
1622 RSTRING(orig)->as.heap.aux.capa =
RSTRING(tmp)->as.heap.aux.capa;
1623 RBASIC(orig)->flags |=
RBASIC(tmp)->flags & STR_NOFREE;
1628 STR_SET_LEN(tmp, 0);
1636 return str_new_frozen_buffer(klass, orig, TRUE);
1646 VALUE str = str_alloc_heap(klass);
1647 STR_SET_LEN(str, RSTRING_LEN(orig));
1648 RSTRING(str)->as.heap.ptr = RSTRING_PTR(orig);
1649 RSTRING(str)->as.heap.aux.capa =
RSTRING(orig)->as.heap.aux.capa;
1650 RBASIC(str)->flags |=
RBASIC(orig)->flags & STR_NOFREE;
1651 RBASIC(orig)->flags &= ~STR_NOFREE;
1652 STR_SET_SHARED(orig, str);
1659str_new_frozen_buffer(
VALUE klass,
VALUE orig,
int copy_encoding)
1663 long len = RSTRING_LEN(orig);
1664 rb_encoding *enc = copy_encoding ? STR_ENC_GET(orig) : rb_ascii8bit_encoding();
1665 int termlen = copy_encoding ? TERM_LEN(orig) : 1;
1667 if (STR_EMBED_P(orig) || STR_EMBEDDABLE_P(
len, termlen)) {
1668 str = str_enc_new(klass, RSTRING_PTR(orig),
len, enc);
1674 long ofs =
RSTRING(orig)->as.heap.ptr - RSTRING_PTR(shared);
1675 long rest = RSTRING_LEN(shared) - ofs - RSTRING_LEN(orig);
1681 if ((ofs > 0) || (rest > 0) ||
1682 (klass !=
RBASIC(shared)->klass) ||
1684 str = str_new_shared(klass, shared);
1686 RSTRING(str)->as.heap.ptr += ofs;
1687 STR_SET_LEN(str, RSTRING_LEN(str) - (ofs + rest));
1690 if (RBASIC_CLASS(shared) == 0)
1695 else if (STR_EMBEDDABLE_P(RSTRING_LEN(orig), TERM_LEN(orig))) {
1696 str = str_alloc_embed(klass, RSTRING_LEN(orig) + TERM_LEN(orig));
1698 memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig));
1699 STR_SET_LEN(str, RSTRING_LEN(orig));
1701 TERM_FILL(RSTRING_END(str), TERM_LEN(orig));
1705 str = str_enc_new(klass, RSTRING_PTR(orig), RSTRING_LEN(orig), enc);
1708 str = heap_str_make_shared(klass, orig);
1713 if (copy_encoding) rb_enc_cr_str_exact_copy(str, orig);
1725str_new_empty_String(
VALUE str)
1728 rb_enc_copy(v, str);
1732#define STR_BUF_MIN_SIZE 63
1737 if (STR_EMBEDDABLE_P(
capa, 1)) {
1745 RSTRING(str)->as.heap.ptr[0] =
'\0';
1765 return str_new(0, 0,
len);
1771 if (STR_EMBED_P(str)) {
1772 RB_DEBUG_COUNTER_INC(obj_str_embed);
1774 else if (
FL_TEST(str, STR_SHARED | STR_NOFREE)) {
1775 (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared,
FL_TEST(str, STR_SHARED));
1776 (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared,
FL_TEST(str, STR_NOFREE));
1779 RB_DEBUG_COUNTER_INC(obj_str_ptr);
1780 ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
1785rb_str_memsize(
VALUE str)
1787 if (
FL_TEST(str, STR_NOEMBED|STR_SHARED|STR_NOFREE) == STR_NOEMBED) {
1788 return STR_HEAP_SIZE(str);
1798 return rb_convert_type_with_id(str,
T_STRING,
"String", idTo_str);
1801static inline void str_discard(
VALUE str);
1802static void str_shared_replace(
VALUE str,
VALUE str2);
1807 if (str != str2) str_shared_replace(str, str2);
1818 enc = STR_ENC_GET(str2);
1821 termlen = rb_enc_mbminlen(enc);
1823 STR_SET_LEN(str, RSTRING_LEN(str2));
1825 if (str_embed_capa(str) >= RSTRING_LEN(str2) + termlen) {
1827 memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), (
size_t)RSTRING_LEN(str2) + termlen);
1830 if (STR_EMBED_P(str2)) {
1832 long len = RSTRING_LEN(str2);
1835 char *new_ptr =
ALLOC_N(
char,
len + termlen);
1836 memcpy(new_ptr,
RSTRING(str2)->as.embed.ary,
len + termlen);
1837 RSTRING(str2)->as.heap.ptr = new_ptr;
1838 STR_SET_LEN(str2,
len);
1840 STR_SET_NOEMBED(str2);
1843 STR_SET_NOEMBED(str);
1845 RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
1847 if (
FL_TEST(str2, STR_SHARED)) {
1849 STR_SET_SHARED(str, shared);
1852 RSTRING(str)->as.heap.aux.capa =
RSTRING(str2)->as.heap.aux.capa;
1856 STR_SET_EMBED(str2);
1857 RSTRING_PTR(str2)[0] = 0;
1858 STR_SET_LEN(str2, 0);
1863 rb_enc_raw_set(str, enc);
1876 return rb_obj_as_string_result(str, obj);
1892 len = RSTRING_LEN(str2);
1893 if (STR_SHARED_P(str2)) {
1896 STR_SET_NOEMBED(str);
1897 STR_SET_LEN(str,
len);
1898 RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2);
1899 STR_SET_SHARED(str, shared);
1900 rb_enc_cr_str_exact_copy(str, str2);
1903 str_replace_shared(str, str2);
1912 size_t size = rb_str_embed_size(
capa, 0);
1916 NEWOBJ_OF(str,
struct RString, klass,
1927 NEWOBJ_OF(str,
struct RString, klass,
1930 str->as.heap.aux.capa = 0;
1931 str->as.heap.ptr = NULL;
1941 encidx = rb_enc_get_index(str);
1945 if (encidx) rb_enc_associate_index(dup, encidx);
1955 long len = RSTRING_LEN(str);
1960 STR_SET_LEN(dup, RSTRING_LEN(str));
1961 return str_duplicate_setup_encoding(str, dup, flags);
1970 root =
RSTRING(str)->as.heap.aux.shared;
1973 root = str = str_new_frozen(klass, str);
1979 RSTRING(dup)->as.heap.ptr = RSTRING_PTR(str);
1980 FL_SET(root, STR_SHARED_ROOT);
1982 flags |= RSTRING_NOEMBED | STR_SHARED;
1984 STR_SET_LEN(dup, RSTRING_LEN(str));
1985 return str_duplicate_setup_encoding(str, dup, flags);
1991 if (STR_EMBED_P(str)) {
1992 return str_duplicate_setup_embed(klass, str, dup);
1995 return str_duplicate_setup_heap(klass, str, dup);
2003 if (STR_EMBED_P(str)) {
2004 dup = str_alloc_embed(klass, RSTRING_LEN(str) + TERM_LEN(str));
2007 dup = str_alloc_heap(klass);
2010 return str_duplicate_setup(klass, str, dup);
2021rb_str_dup_m(
VALUE str)
2023 if (LIKELY(BARE_STRING_P(str))) {
2034 RUBY_DTRACE_CREATE_HOOK(STRING, RSTRING_LEN(str));
2041 RUBY_DTRACE_CREATE_HOOK(STRING, RSTRING_LEN(str));
2045 new_str = ec_str_alloc_embed(ec, klass, RSTRING_LEN(str) + TERM_LEN(str));
2046 str_duplicate_setup_embed(klass, str, new_str);
2049 new_str = ec_str_alloc_heap(ec, klass);
2050 str_duplicate_setup_heap(klass, str, new_str);
2059rb_str_with_debug_created_info(
VALUE str,
VALUE path,
int line)
2061 VALUE debug_info = rb_ary_new_from_args(2, path,
INT2FIX(line));
2085 static ID keyword_ids[2];
2086 VALUE orig, opt, venc, vcapa;
2088 rb_encoding *enc = 0;
2091 if (!keyword_ids[0]) {
2092 keyword_ids[0] = rb_id_encoding();
2093 CONST_ID(keyword_ids[1],
"capacity");
2101 if (!UNDEF_P(venc) && !
NIL_P(venc)) {
2102 enc = rb_to_encoding(venc);
2104 if (!UNDEF_P(vcapa) && !
NIL_P(vcapa)) {
2109 if (
capa < STR_BUF_MIN_SIZE) {
2110 capa = STR_BUF_MIN_SIZE;
2114 len = RSTRING_LEN(orig);
2118 if (orig == str) n = 0;
2120 termlen = enc ? rb_enc_mbminlen(enc) : TERM_LEN(n == 1 ? orig : str);
2121 str_modifiable(str);
2122 if (STR_EMBED_P(str) ||
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2124 const size_t size = (size_t)
capa + termlen;
2125 const char *
const old_ptr = RSTRING_PTR(str);
2126 const size_t osize = RSTRING_LEN(str) + TERM_LEN(str);
2127 char *new_ptr =
ALLOC_N(
char, size);
2128 if (STR_EMBED_P(str))
RUBY_ASSERT((
long)osize <= str_embed_capa(str));
2129 memcpy(new_ptr, old_ptr, osize < size ? osize : size);
2131 RSTRING(str)->as.heap.ptr = new_ptr;
2133 else if (STR_HEAP_SIZE(str) != (
size_t)
capa + termlen) {
2134 SIZED_REALLOC_N(
RSTRING(str)->as.heap.ptr,
char,
2135 (
size_t)
capa + termlen, STR_HEAP_SIZE(str));
2137 STR_SET_LEN(str,
len);
2138 TERM_FILL(&
RSTRING(str)->as.heap.ptr[
len], termlen);
2140 memcpy(
RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig),
len);
2141 if (!enc || rb_enc_get(orig) == enc) {
2142 rb_enc_cr_str_exact_copy(str, orig);
2146 FL_SET(str, STR_NOEMBED);
2153 str_modifiable(str);
2154 if (UNDEF_P(vcapa) ||
NIL_P(vcapa)) {
2155 rb_enc_associate(str, enc);
2159 rb_enc_raw_set(str, enc);
2172rb_str_s_new(
int argc,
VALUE *argv,
VALUE klass)
2178 static ID keyword_ids[2];
2181 rb_encoding *enc = NULL;
2188 keyword_ids[0] = rb_id_encoding();
2189 CONST_ID(keyword_ids[1],
"capacity");
2191 encoding = kwargs[0];
2192 capacity = kwargs[1];
2201 if (UNDEF_P(encoding)) {
2203 encoding = rb_obj_encoding(orig);
2207 if (!UNDEF_P(encoding)) {
2208 enc = rb_to_encoding(encoding);
2212 if (UNDEF_P(capacity)) {
2214 VALUE empty_str = str_new(klass,
"", 0);
2216 rb_enc_associate(empty_str, enc);
2220 VALUE copy = str_duplicate(klass, orig);
2221 rb_enc_associate(copy, enc);
2234 if (orig_capa >
capa) {
2239 VALUE str = str_enc_new(klass, NULL,
capa, enc);
2240 STR_SET_LEN(str, 0);
2241 TERM_FILL(RSTRING_PTR(str), enc ? rb_enc_mbmaxlen(enc) : 1);
2251#define is_utf8_lead_byte(c) (((c)&0xC0) != 0x80)
2266static inline uintptr_t
2267count_utf8_lead_bytes_with_word(
const uintptr_t *s)
2272 d = (d>>6) | (~d>>7);
2273 d &= NONASCII_MASK >> 7;
2276#if defined(HAVE_BUILTIN___BUILTIN_POPCOUNT) && defined(__POPCNT__)
2278 return rb_popcount_intptr(d);
2282# if SIZEOF_VOIDP == 8
2291enc_strlen(
const char *p,
const char *e, rb_encoding *enc,
int cr)
2296 if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
2297 long diff = (long)(e - p);
2298 return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
2303 if ((
int)
sizeof(uintptr_t) * 2 < e - p) {
2304 const uintptr_t *s, *t;
2305 const uintptr_t lowbits =
sizeof(uintptr_t) - 1;
2306 s = (
const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
2307 t = (
const uintptr_t*)(~lowbits & (uintptr_t)e);
2308 while (p < (
const char *)s) {
2309 if (is_utf8_lead_byte(*p))
len++;
2313 len += count_utf8_lead_bytes_with_word(s);
2316 p = (
const char *)s;
2319 if (is_utf8_lead_byte(*p))
len++;
2325 else if (rb_enc_asciicompat(enc)) {
2330 q = search_nonascii(p, e);
2336 p += rb_enc_fast_mbclen(p, e, enc);
2343 q = search_nonascii(p, e);
2349 p += rb_enc_mbclen(p, e, enc);
2356 for (c=0; p<e; c++) {
2357 p += rb_enc_mbclen(p, e, enc);
2372rb_enc_strlen_cr(
const char *p,
const char *e, rb_encoding *enc,
int *cr)
2379 if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
2380 long diff = (long)(e - p);
2381 return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc));
2383 else if (rb_enc_asciicompat(enc)) {
2387 q = search_nonascii(p, e);
2395 ret = rb_enc_precise_mbclen(p, e, enc);
2410 for (c=0; p<e; c++) {
2411 ret = rb_enc_precise_mbclen(p, e, enc);
2418 if (p + rb_enc_mbminlen(enc) <= e)
2419 p += rb_enc_mbminlen(enc);
2430str_strlen(
VALUE str, rb_encoding *enc)
2435 if (single_byte_optimizable(str))
return RSTRING_LEN(str);
2436 if (!enc) enc = STR_ENC_GET(str);
2437 p = RSTRING_PTR(str);
2438 e = RSTRING_END(str);
2442 long n = rb_enc_strlen_cr(p, e, enc, &cr);
2447 return enc_strlen(p, e, enc, cr);
2454 return str_strlen(str, NULL);
2468 return LONG2NUM(str_strlen(str, NULL));
2480rb_str_bytesize(
VALUE str)
2499rb_str_empty(
VALUE str)
2501 return RBOOL(RSTRING_LEN(str) == 0);
2520 char *ptr1, *ptr2, *ptr3;
2525 enc = rb_enc_check_str(str1, str2);
2528 termlen = rb_enc_mbminlen(enc);
2529 if (len1 > LONG_MAX - len2) {
2530 rb_raise(rb_eArgError,
"string size too big");
2532 str3 = str_enc_new(
rb_cString, 0, len1+len2, enc);
2533 ptr3 = RSTRING_PTR(str3);
2534 memcpy(ptr3, ptr1, len1);
2535 memcpy(ptr3+len1, ptr2, len2);
2536 TERM_FILL(&ptr3[len1+len2], termlen);
2552 MAYBE_UNUSED(
char) *ptr1, *ptr2;
2555 int enc1 = rb_enc_get_index(str1);
2556 int enc2 = rb_enc_get_index(str2);
2561 else if (enc2 < 0) {
2564 else if (enc1 != enc2) {
2567 else if (len1 > LONG_MAX - len2) {
2601 rb_enc_copy(str2, str);
2606 rb_raise(rb_eArgError,
"negative argument");
2608 if (RSTRING_LEN(str) == 1 && RSTRING_PTR(str)[0] == 0) {
2609 if (STR_EMBEDDABLE_P(
len, 1)) {
2611 memset(RSTRING_PTR(str2), 0,
len + 1);
2618 STR_SET_LEN(str2,
len);
2619 rb_enc_copy(str2, str);
2622 if (
len && LONG_MAX/
len < RSTRING_LEN(str)) {
2623 rb_raise(rb_eArgError,
"argument too big");
2626 len *= RSTRING_LEN(str);
2627 termlen = TERM_LEN(str);
2629 ptr2 = RSTRING_PTR(str2);
2631 n = RSTRING_LEN(str);
2632 memcpy(ptr2, RSTRING_PTR(str), n);
2633 while (n <=
len/2) {
2634 memcpy(ptr2 + n, ptr2, n);
2637 memcpy(ptr2 + n, ptr2,
len-n);
2639 STR_SET_LEN(str2,
len);
2640 TERM_FILL(&ptr2[
len], termlen);
2641 rb_enc_cr_str_copy_for_substr(str2, str);
2680rb_check_lockedtmp(
VALUE str)
2682 if (
FL_TEST(str, STR_TMPLOCK)) {
2689#define STR_UNMODIFIABLE_MASK (FL_FREEZE | STR_TMPLOCK | STR_CHILLED)
2691str_modifiable(
VALUE str)
2695 if (RB_UNLIKELY(
FL_ANY_RAW(str, STR_UNMODIFIABLE_MASK))) {
2696 if (CHILLED_STRING_P(str)) {
2697 CHILLED_STRING_MUTATED(str);
2699 rb_check_lockedtmp(str);
2700 rb_check_frozen(str);
2705str_dependent_p(
VALUE str)
2707 if (STR_EMBED_P(str) || !
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2717#define STR_DEPENDANT_MASK (STR_UNMODIFIABLE_MASK | STR_SHARED | STR_NOFREE)
2719str_independent(
VALUE str)
2723 if (RB_UNLIKELY(
FL_ANY_RAW(str, STR_DEPENDANT_MASK))) {
2724 str_modifiable(str);
2725 return !str_dependent_p(str);
2731str_make_independent_expand(
VALUE str,
long len,
long expand,
const int termlen)
2741 if (!STR_EMBED_P(str) && str_embed_capa(str) >=
capa + termlen) {
2745 TERM_FILL(
RSTRING(str)->as.embed.ary +
len, termlen);
2746 STR_SET_LEN(str,
len);
2751 oldptr = RSTRING_PTR(str);
2753 memcpy(
ptr, oldptr,
len);
2755 if (
FL_TEST_RAW(str, STR_NOEMBED|STR_NOFREE|STR_SHARED) == STR_NOEMBED) {
2758 STR_SET_NOEMBED(str);
2759 FL_UNSET(str, STR_SHARED|STR_NOFREE);
2760 TERM_FILL(
ptr +
len, termlen);
2762 STR_SET_LEN(str,
len);
2769 if (!str_independent(str))
2770 str_make_independent(str);
2779 int termlen = TERM_LEN(str);
2780 long len = RSTRING_LEN(str);
2783 rb_raise(rb_eArgError,
"negative expanding string size");
2785 if (expand > LONG_MAX - termlen -
len) {
2786 rb_raise(rb_eArgError,
"string size too big");
2789 if (!str_independent(str)) {
2790 str_make_independent_expand(str,
len, expand, termlen);
2792 else if (expand > 0) {
2793 RESIZE_CAPA_TERM(str,
len + expand, termlen);
2800str_modify_keep_cr(
VALUE str)
2802 if (!str_independent(str))
2803 str_make_independent(str);
2810str_discard(
VALUE str)
2812 str_modifiable(str);
2813 if (!STR_EMBED_P(str) && !
FL_TEST(str, STR_SHARED|STR_NOFREE)) {
2814 ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
2815 RSTRING(str)->as.heap.ptr = 0;
2816 STR_SET_LEN(str, 0);
2823 int encindex = rb_enc_get_index(str);
2825 if (RB_UNLIKELY(encindex == -1)) {
2829 if (RB_LIKELY(str_encindex_fastpath(encindex))) {
2833 rb_encoding *enc = rb_enc_from_index(encindex);
2834 if (!rb_enc_asciicompat(enc)) {
2856 return RSTRING_PTR(str);
2860zero_filled(
const char *s,
int n)
2862 for (; n > 0; --n) {
2869str_null_char(
const char *s,
long len,
const int minlen, rb_encoding *enc)
2871 const char *e = s +
len;
2873 for (; s + minlen <= e; s += rb_enc_mbclen(s, e, enc)) {
2874 if (zero_filled(s, minlen))
return s;
2880str_fill_term(
VALUE str,
char *s,
long len,
int termlen)
2885 if (str_dependent_p(str)) {
2886 if (!zero_filled(s +
len, termlen))
2887 str_make_independent_expand(str,
len, 0L, termlen);
2890 TERM_FILL(s +
len, termlen);
2893 return RSTRING_PTR(str);
2897rb_str_change_terminator_length(
VALUE str,
const int oldtermlen,
const int termlen)
2899 long capa = str_capacity(str, oldtermlen) + oldtermlen;
2900 long len = RSTRING_LEN(str);
2904 rb_check_lockedtmp(str);
2905 str_make_independent_expand(str,
len, 0L, termlen);
2907 else if (str_dependent_p(str)) {
2908 if (termlen > oldtermlen)
2909 str_make_independent_expand(str,
len, 0L, termlen);
2912 if (!STR_EMBED_P(str)) {
2917 if (termlen > oldtermlen) {
2918 TERM_FILL(RSTRING_PTR(str) +
len, termlen);
2926str_null_check(
VALUE str,
int *w)
2928 char *s = RSTRING_PTR(str);
2929 long len = RSTRING_LEN(str);
2930 rb_encoding *enc = rb_enc_get(str);
2931 const int minlen = rb_enc_mbminlen(enc);
2935 if (str_null_char(s,
len, minlen, enc)) {
2938 return str_fill_term(str, s,
len, minlen);
2941 if (!s || memchr(s, 0,
len)) {
2945 s = str_fill_term(str, s,
len, minlen);
2951rb_str_to_cstr(
VALUE str)
2954 return str_null_check(str, &w);
2962 char *s = str_null_check(str, &w);
2965 rb_raise(rb_eArgError,
"string contains null char");
2967 rb_raise(rb_eArgError,
"string contains null byte");
2973rb_str_fill_terminator(
VALUE str,
const int newminlen)
2975 char *s = RSTRING_PTR(str);
2976 long len = RSTRING_LEN(str);
2977 return str_fill_term(str, s,
len, newminlen);
2983 str = rb_check_convert_type_with_id(str,
T_STRING,
"String", idTo_str);
3009str_nth_len(
const char *p,
const char *e,
long *nthp, rb_encoding *enc)
3012 if (rb_enc_mbmaxlen(enc) == 1) {
3015 else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
3016 p += nth * rb_enc_mbmaxlen(enc);
3018 else if (rb_enc_asciicompat(enc)) {
3019 const char *p2, *e2;
3022 while (p < e && 0 < nth) {
3029 p2 = search_nonascii(p, e2);
3038 n = rb_enc_mbclen(p, e, enc);
3049 while (p < e && nth--) {
3050 p += rb_enc_mbclen(p, e, enc);
3059rb_enc_nth(
const char *p,
const char *e,
long nth, rb_encoding *enc)
3061 return str_nth_len(p, e, &nth, enc);
3065str_nth(
const char *p,
const char *e,
long nth, rb_encoding *enc,
int singlebyte)
3070 p = str_nth_len(p, e, &nth, enc);
3079str_offset(
const char *p,
const char *e,
long nth, rb_encoding *enc,
int singlebyte)
3081 const char *pp = str_nth(p, e, nth, enc, singlebyte);
3082 if (!pp)
return e - p;
3089 return str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
3090 STR_ENC_GET(str), single_byte_optimizable(str));
3095str_utf8_nth(
const char *p,
const char *e,
long *nthp)
3098 if ((
int)SIZEOF_VOIDP * 2 < e - p && (
int)SIZEOF_VOIDP * 2 < nth) {
3099 const uintptr_t *s, *t;
3100 const uintptr_t lowbits = SIZEOF_VOIDP - 1;
3101 s = (
const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits));
3102 t = (
const uintptr_t*)(~lowbits & (uintptr_t)e);
3103 while (p < (
const char *)s) {
3104 if (is_utf8_lead_byte(*p)) nth--;
3108 nth -= count_utf8_lead_bytes_with_word(s);
3110 }
while (s < t && (
int)SIZEOF_VOIDP <= nth);
3114 if (is_utf8_lead_byte(*p)) {
3115 if (nth == 0)
break;
3125str_utf8_offset(
const char *p,
const char *e,
long nth)
3127 const char *pp = str_utf8_nth(p, e, &nth);
3136 if (single_byte_optimizable(str) || pos < 0)
3139 char *p = RSTRING_PTR(str);
3140 return enc_strlen(p, p + pos, STR_ENC_GET(str),
ENC_CODERANGE(str));
3145str_subseq(
VALUE str,
long beg,
long len)
3153 const int termlen = TERM_LEN(str);
3154 if (!SHARABLE_SUBSTRING_P(beg,
len, RSTRING_LEN(str))) {
3155 str2 = rb_enc_str_new(RSTRING_PTR(str) + beg,
len, STR_ENC_GET(str));
3161 if (str_embed_capa(str2) >=
len + termlen) {
3162 char *ptr2 =
RSTRING(str2)->as.embed.ary;
3163 STR_SET_EMBED(str2);
3164 memcpy(ptr2, RSTRING_PTR(str) + beg,
len);
3165 TERM_FILL(ptr2+
len, termlen);
3167 STR_SET_LEN(str2,
len);
3171 str_replace_shared(str2, str);
3174 RSTRING(str2)->as.heap.ptr += beg;
3175 if (RSTRING_LEN(str2) >
len) {
3176 STR_SET_LEN(str2,
len);
3186 VALUE str2 = str_subseq(str, beg,
len);
3187 rb_enc_cr_str_copy_for_substr(str2, str);
3196 const long blen = RSTRING_LEN(str);
3197 rb_encoding *enc = STR_ENC_GET(str);
3198 char *p, *s = RSTRING_PTR(str), *e = s + blen;
3200 if (
len < 0)
return 0;
3201 if (beg == LONG_MIN)
return 0;
3205 if (single_byte_optimizable(str)) {
3206 if (beg > blen)
return 0;
3209 if (beg < 0)
return 0;
3211 if (
len > blen - beg)
3213 if (
len < 0)
return 0;
3218 if (
len > -beg)
len = -beg;
3220 (-beg * rb_enc_mbmaxlen(enc) < blen / 8)) {
3222 while (beg-- >
len && (e = rb_enc_prev_char(s, e, e, enc)) != 0);
3225 while (
len-- > 0 && (p = rb_enc_prev_char(s, p, e, enc)) != 0);
3231 slen = str_strlen(str, enc);
3233 if (beg < 0)
return 0;
3235 if (
len == 0)
goto end;
3238 else if (beg > 0 && beg > blen) {
3242 if (beg > str_strlen(str, enc))
return 0;
3247 enc == rb_utf8_encoding()) {
3248 p = str_utf8_nth(s, e, &beg);
3249 if (beg > 0)
return 0;
3250 len = str_utf8_offset(p, e,
len);
3253 else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) {
3254 int char_sz = rb_enc_mbmaxlen(enc);
3256 p = s + beg * char_sz;
3260 else if (
len * char_sz > e - p)
3265 else if ((p = str_nth_len(s, e, &beg, enc)) == e) {
3266 if (beg > 0)
return 0;
3270 len = str_offset(p, e,
len, enc, 0);
3278static VALUE str_substr(
VALUE str,
long beg,
long len,
int empty);
3283 return str_substr(str, beg,
len, TRUE);
3293str_substr(
VALUE str,
long beg,
long len,
int empty)
3297 if (!p)
return Qnil;
3298 if (!
len && !empty)
return Qnil;
3300 beg = p - RSTRING_PTR(str);
3302 VALUE str2 = str_subseq(str, beg,
len);
3303 rb_enc_cr_str_copy_for_substr(str2, str);
3311 if (CHILLED_STRING_P(str)) {
3316 rb_str_resize(str, RSTRING_LEN(str));
3334 if (
OBJ_FROZEN(str) || CHILLED_STRING_P(str)) {
3377str_uminus(
VALUE str)
3382 return rb_fstring(str);
3386#define rb_str_dup_frozen rb_str_new_frozen
3391 rb_check_frozen(str);
3392 if (
FL_TEST(str, STR_TMPLOCK)) {
3395 FL_SET(str, STR_TMPLOCK);
3402 rb_check_frozen(str);
3403 if (!
FL_TEST(str, STR_TMPLOCK)) {
3423 const int termlen = TERM_LEN(str);
3425 str_modifiable(str);
3426 if (STR_SHARED_P(str)) {
3429 if (
len > (
capa = (
long)str_capacity(str, termlen)) ||
len < 0) {
3430 rb_bug(
"probable buffer overflow: %ld for %ld",
len,
capa);
3441 else if (
len > RSTRING_LEN(str)) {
3444 const char *
const prev_end = RSTRING_END(str);
3445 const char *
const new_end = RSTRING_PTR(str) +
len;
3446 rb_encoding *enc = rb_enc_get(str);
3447 rb_str_coderange_scan_restartable(prev_end, new_end, enc, &cr);
3455 else if (
len < RSTRING_LEN(str)) {
3463 STR_SET_LEN(str,
len);
3464 TERM_FILL(&RSTRING_PTR(str)[
len], termlen);
3471 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3474 int independent = str_independent(str);
3475 long slen = RSTRING_LEN(str);
3476 const int termlen = TERM_LEN(str);
3477 if (
len > LONG_MAX - termlen) {
3478 rb_raise(rb_eArgError,
"string size too big");
3481 if (slen >
len || (termlen != 1 && slen <
len)) {
3487 if (STR_EMBED_P(str)) {
3488 if (
len == slen)
return str;
3489 if (str_embed_capa(str) >=
len + termlen) {
3490 STR_SET_LEN(str,
len);
3491 TERM_FILL(
RSTRING(str)->as.embed.ary +
len, termlen);
3494 str_make_independent_expand(str, slen,
len - slen, termlen);
3496 else if (str_embed_capa(str) >=
len + termlen) {
3497 char *
ptr = STR_HEAP_PTR(str);
3499 if (slen >
len) slen =
len;
3501 TERM_FILL(
RSTRING(str)->as.embed.ary +
len, termlen);
3502 STR_SET_LEN(str,
len);
3503 if (independent) ruby_xfree(
ptr);
3506 else if (!independent) {
3507 if (
len == slen)
return str;
3508 str_make_independent_expand(str, slen,
len - slen, termlen);
3512 SIZED_REALLOC_N(
RSTRING(str)->as.heap.ptr,
char,
3513 (
size_t)
len + termlen, STR_HEAP_SIZE(str));
3516 else if (
len == slen)
return str;
3517 STR_SET_LEN(str,
len);
3518 TERM_FILL(
RSTRING(str)->as.heap.ptr +
len, termlen);
3524str_ensure_available_capa(
VALUE str,
long len)
3526 str_modify_keep_cr(str);
3528 const int termlen = TERM_LEN(str);
3529 long olen = RSTRING_LEN(str);
3531 if (RB_UNLIKELY(olen > LONG_MAX -
len)) {
3532 rb_raise(rb_eArgError,
"string sizes too big");
3535 long total = olen +
len;
3536 long capa = str_capacity(str, termlen);
3539 if (total >= LONG_MAX / 2) {
3542 while (total >
capa) {
3545 RESIZE_CAPA_TERM(str,
capa, termlen);
3550str_buf_cat4(
VALUE str,
const char *
ptr,
long len,
bool keep_cr)
3553 str_modify_keep_cr(str);
3558 if (
len == 0)
return 0;
3560 long total, olen,
off = -1;
3562 const int termlen = TERM_LEN(str);
3565 if (
ptr >= sptr &&
ptr <= sptr + olen) {
3569 long capa = str_capacity(str, termlen);
3571 if (olen > LONG_MAX -
len) {
3572 rb_raise(rb_eArgError,
"string sizes too big");
3576 if (total >= LONG_MAX / 2) {
3579 while (total >
capa) {
3582 RESIZE_CAPA_TERM(str,
capa, termlen);
3583 sptr = RSTRING_PTR(str);
3588 memcpy(sptr + olen,
ptr,
len);
3589 STR_SET_LEN(str, total);
3590 TERM_FILL(sptr + total, termlen);
3595#define str_buf_cat(str, ptr, len) str_buf_cat4((str), (ptr), len, false)
3596#define str_buf_cat2(str, ptr) str_buf_cat4((str), (ptr), rb_strlen_lit(ptr), false)
3601 if (
len == 0)
return str;
3603 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3605 return str_buf_cat(str,
ptr,
len);
3616rb_str_buf_cat_byte(
VALUE str,
unsigned char byte)
3618 RUBY_ASSERT(RB_ENCODING_GET_INLINED(str) == ENCINDEX_ASCII_8BIT || RB_ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII);
3621 if (UNLIKELY(!str_independent(str))) {
3622 str_make_independent(str);
3625 long string_length = -1;
3626 const int null_terminator_length = 1;
3631 if (UNLIKELY(string_length > LONG_MAX - 1)) {
3632 rb_raise(rb_eArgError,
"string sizes too big");
3635 long string_capacity = str_capacity(str, null_terminator_length);
3641 if (LIKELY(string_capacity >= string_length + 1)) {
3643 sptr[string_length] = byte;
3644 STR_SET_LEN(str, string_length + 1);
3645 TERM_FILL(sptr + string_length + 1, null_terminator_length);
3649 str_buf_cat(str, (
char *)&
byte, 1);
3657 if (ISASCII(
byte)) {
3664 if (UNLIKELY(RB_ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII)) {
3665 rb_enc_associate_index(str, ENCINDEX_ASCII_8BIT);
3676rb_enc_cr_str_buf_cat(
VALUE str,
const char *
ptr,
long len,
3677 int ptr_encindex,
int ptr_cr,
int *ptr_cr_ret)
3682 rb_encoding *str_enc, *ptr_enc;
3686 if (str_encindex == ptr_encindex) {
3688 ptr_cr = coderange_scan(
ptr,
len, rb_enc_from_index(ptr_encindex));
3692 str_enc = rb_enc_from_index(str_encindex);
3693 ptr_enc = rb_enc_from_index(ptr_encindex);
3694 if (!rb_enc_asciicompat(str_enc) || !rb_enc_asciicompat(ptr_enc)) {
3697 if (RSTRING_LEN(str) == 0) {
3700 rb_str_change_terminator_length(str, rb_enc_mbminlen(str_enc), rb_enc_mbminlen(ptr_enc));
3706 ptr_cr = coderange_scan(
ptr,
len, ptr_enc);
3715 *ptr_cr_ret = ptr_cr;
3717 if (str_encindex != ptr_encindex &&
3720 str_enc = rb_enc_from_index(str_encindex);
3721 ptr_enc = rb_enc_from_index(ptr_encindex);
3726 res_encindex = str_encindex;
3731 res_encindex = str_encindex;
3735 res_encindex = ptr_encindex;
3740 res_encindex = str_encindex;
3747 res_encindex = str_encindex;
3753 rb_raise(rb_eArgError,
"negative string size (or size too big)");
3755 str_buf_cat(str,
ptr,
len);
3761 rb_enc_inspect_name(str_enc), rb_enc_inspect_name(ptr_enc));
3768 return rb_enc_cr_str_buf_cat(str,
ptr,
len,
3777 rb_encoding *enc = rb_enc_from_index(encindex);
3778 if (rb_enc_asciicompat(enc)) {
3779 return rb_enc_cr_str_buf_cat(str,
ptr, strlen(
ptr),
3783 char *buf =
ALLOCA_N(
char, rb_enc_mbmaxlen(enc));
3785 unsigned int c = (
unsigned char)*
ptr;
3786 int len = rb_enc_codelen(c, enc);
3787 rb_enc_mbcput(c, buf, enc);
3788 rb_enc_cr_str_buf_cat(str, buf,
len,
3799 str_modify_keep_cr(str);
3803 if (str_enc_fastpath(str)) {
3807 str_buf_cat4(str, RSTRING_PTR(str2), RSTRING_LEN(str2),
true);
3813 str_buf_cat4(str, RSTRING_PTR(str2), RSTRING_LEN(str2),
true);
3825 rb_enc_cr_str_buf_cat(str, RSTRING_PTR(str2), RSTRING_LEN(str2),
3840rb_str_concat_literals(
size_t num,
const VALUE *strary)
3844 unsigned long len = 1;
3849 for (i = 0; i < num; ++i) {
len += RSTRING_LEN(strary[i]); }
3853 for (i = s; i < num; ++i) {
3854 const VALUE v = strary[i];
3858 if (encidx != ENCINDEX_US_ASCII) {
3860 rb_enc_associate_index(str, encidx);
3873rb_str_concat_multi(
int argc,
VALUE *argv,
VALUE str)
3875 str_modifiable(str);
3880 else if (argc > 1) {
3883 rb_enc_copy(arg_str, str);
3884 for (i = 0; i < argc; i++) {
3919rb_str_append_as_bytes(
int argc,
VALUE *argv,
VALUE str)
3921 long needed_capacity = 0;
3924 str_modify_keep_cr(str);
3928 for (
int index = 0; index < argc; index++) {
3929 VALUE obj = argv[index];
3937 needed_capacity += RSTRING_LEN(obj);
3942 "wrong argument type %"PRIsVALUE
" (expected String or Integer)",
3949 str_ensure_available_capa(str, needed_capacity);
3950 char *sptr = RSTRING_END(str);
3952 for (
int index = 0; index < argc; index++) {
3953 VALUE obj = argv[index];
3958 argv[index] = obj = rb_int_and(obj,
INT2FIX(0xff));
3959 char byte = (char)(
NUM2INT(obj) & 0xFF);
3973 rb_bug(
"append_as_bytes arguments should have been validated");
3977 STR_SET_LEN(str, RSTRING_LEN(str) + needed_capacity);
3978 TERM_FILL(sptr, TERM_LEN(str));
3983 for (
int index = 0; index < argc; index++) {
3984 VALUE obj = argv[index];
4001 rb_bug(
"append_as_bytes arguments should have been validated");
4082 str_modify_keep_cr(str1);
4083 enc = STR_ENC_GET(str1);
4086 if (rb_num_to_uint(str2, &code) == 0) {
4099 encidx = rb_ascii8bit_appendable_encoding_index(enc, code);
4102 rb_str_buf_cat_byte(str1, (
unsigned char)code);
4105 long pos = RSTRING_LEN(str1);
4110 switch (
len = rb_enc_codelen(code, enc)) {
4111 case ONIGERR_INVALID_CODE_POINT_VALUE:
4112 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
4114 case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
4120 rb_enc_mbcput(code, buf, enc);
4121 if (rb_enc_precise_mbclen(buf, buf +
len + 1, enc) !=
len) {
4122 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
4124 rb_str_resize(str1, pos+
len);
4125 memcpy(RSTRING_PTR(str1) + pos, buf,
len);
4138rb_ascii8bit_appendable_encoding_index(rb_encoding *enc,
unsigned int code)
4140 int encidx = rb_enc_to_index(enc);
4142 if (encidx == ENCINDEX_ASCII_8BIT || encidx == ENCINDEX_US_ASCII) {
4147 if (encidx == ENCINDEX_US_ASCII && code > 127) {
4148 return ENCINDEX_ASCII_8BIT;
4170rb_str_prepend_multi(
int argc,
VALUE *argv,
VALUE str)
4172 str_modifiable(str);
4177 else if (argc > 1) {
4180 rb_enc_copy(arg_str, str);
4181 for (i = 0; i < argc; i++) {
4194 st_index_t precomputed_hash;
4195 memcpy(&precomputed_hash, RSTRING_END(str) + TERM_LEN(str),
sizeof(precomputed_hash));
4197 RUBY_ASSERT(precomputed_hash == str_do_hash(str));
4198 return precomputed_hash;
4201 return str_do_hash(str);
4208 const char *ptr1, *ptr2;
4211 return (len1 != len2 ||
4213 memcmp(ptr1, ptr2, len1) != 0);
4225rb_str_hash_m(
VALUE str)
4231#define lesser(a,b) (((a)>(b))?(b):(a))
4239 if (RSTRING_LEN(str1) == 0)
return TRUE;
4240 if (RSTRING_LEN(str2) == 0)
return TRUE;
4243 if (idx1 == idx2)
return TRUE;
4248 if (rb_enc_asciicompat(rb_enc_from_index(idx2)))
4252 if (rb_enc_asciicompat(rb_enc_from_index(idx1)))
4262 const char *ptr1, *ptr2;
4265 if (str1 == str2)
return 0;
4268 if (ptr1 == ptr2 || (retval = memcmp(ptr1, ptr2, lesser(len1, len2))) == 0) {
4277 if (len1 > len2)
return 1;
4280 if (retval > 0)
return 1;
4314 if (str1 == str2)
return Qtrue;
4321 return rb_str_eql_internal(str1, str2);
4335 if (str1 == str2)
return Qtrue;
4337 return rb_str_eql_internal(str1, str2);
4375 return rb_invcmp(str1, str2);
4417 return str_casecmp(str1, s);
4425 const char *p1, *p1end, *p2, *p2end;
4427 enc = rb_enc_compatible(str1, str2);
4432 p1 = RSTRING_PTR(str1); p1end = RSTRING_END(str1);
4433 p2 = RSTRING_PTR(str2); p2end = RSTRING_END(str2);
4434 if (single_byte_optimizable(str1) && single_byte_optimizable(str2)) {
4435 while (p1 < p1end && p2 < p2end) {
4437 unsigned int c1 =
TOLOWER(*p1 & 0xff);
4438 unsigned int c2 =
TOLOWER(*p2 & 0xff);
4440 return INT2FIX(c1 < c2 ? -1 : 1);
4447 while (p1 < p1end && p2 < p2end) {
4448 int l1, c1 = rb_enc_ascget(p1, p1end, &l1, enc);
4449 int l2, c2 = rb_enc_ascget(p2, p2end, &l2, enc);
4451 if (0 <= c1 && 0 <= c2) {
4455 return INT2FIX(c1 < c2 ? -1 : 1);
4459 l1 = rb_enc_mbclen(p1, p1end, enc);
4460 l2 = rb_enc_mbclen(p2, p2end, enc);
4461 len = l1 < l2 ? l1 : l2;
4462 r = memcmp(p1, p2,
len);
4464 return INT2FIX(r < 0 ? -1 : 1);
4466 return INT2FIX(l1 < l2 ? -1 : 1);
4472 if (p1 == p1end && p2 == p2end)
return INT2FIX(0);
4473 if (p1 == p1end)
return INT2FIX(-1);
4506 return str_casecmp_p(str1, s);
4513 VALUE folded_str1, folded_str2;
4514 VALUE fold_opt = sym_fold;
4516 enc = rb_enc_compatible(str1, str2);
4521 folded_str1 = rb_str_downcase(1, &fold_opt, str1);
4522 folded_str2 = rb_str_downcase(1, &fold_opt, str2);
4524 return rb_str_eql(folded_str1, folded_str2);
4528strseq_core(
const char *str_ptr,
const char *str_ptr_end,
long str_len,
4529 const char *sub_ptr,
long sub_len,
long offset, rb_encoding *enc)
4531 const char *search_start = str_ptr;
4532 long pos, search_len = str_len - offset;
4536 pos =
rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc);
4537 if (pos < 0)
return pos;
4538 t = rb_enc_right_char_head(search_start, search_start+pos, str_ptr_end, enc);
4539 if (t == search_start + pos)
break;
4540 search_len -= t - search_start;
4541 if (search_len <= 0)
return -1;
4542 offset += t - search_start;
4545 return pos + offset;
4549#define rb_str_index(str, sub, offset) rb_strseq_index(str, sub, offset, 0)
4550#define rb_str_byteindex(str, sub, offset) rb_strseq_index(str, sub, offset, 1)
4553rb_strseq_index(
VALUE str,
VALUE sub,
long offset,
int in_byte)
4555 const char *str_ptr, *str_ptr_end, *sub_ptr;
4556 long str_len, sub_len;
4559 enc = rb_enc_check(str, sub);
4560 if (is_broken_string(sub))
return -1;
4562 str_ptr = RSTRING_PTR(str);
4563 str_ptr_end = RSTRING_END(str);
4564 str_len = RSTRING_LEN(str);
4565 sub_ptr = RSTRING_PTR(sub);
4566 sub_len = RSTRING_LEN(sub);
4568 if (str_len < sub_len)
return -1;
4571 long str_len_char, sub_len_char;
4572 int single_byte = single_byte_optimizable(str);
4573 str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc);
4574 sub_len_char = in_byte ? sub_len : str_strlen(sub, enc);
4576 offset += str_len_char;
4577 if (offset < 0)
return -1;
4579 if (str_len_char - offset < sub_len_char)
return -1;
4580 if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte);
4583 if (sub_len == 0)
return offset;
4586 return strseq_core(str_ptr, str_ptr_end, str_len, sub_ptr, sub_len, offset, enc);
4599rb_str_index_m(
int argc,
VALUE *argv,
VALUE str)
4603 rb_encoding *enc = STR_ENC_GET(str);
4606 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
4607 long slen = str_strlen(str, enc);
4609 if (pos < 0 ? (pos += slen) < 0 : pos > slen) {
4621 pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
4622 enc, single_byte_optimizable(str));
4633 pos = rb_str_index(str, sub, pos);
4647str_ensure_byte_pos(
VALUE str,
long pos)
4649 if (!single_byte_optimizable(str)) {
4650 const char *s = RSTRING_PTR(str);
4651 const char *e = RSTRING_END(str);
4652 const char *p = s + pos;
4653 if (!at_char_boundary(s, p, e, rb_enc_get(str))) {
4655 "offset %ld does not land on character boundary", pos);
4728rb_str_byteindex_m(
int argc,
VALUE *argv,
VALUE str)
4734 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
4736 long slen = RSTRING_LEN(str);
4737 if (pos < 0 ? (pos += slen) < 0 : pos > slen) {
4748 str_ensure_byte_pos(str, pos);
4760 pos = rb_str_byteindex(str, sub, pos);
4761 if (pos >= 0)
return LONG2NUM(pos);
4768memrchr(
const char *search_str,
int chr,
long search_len)
4770 const char *
ptr = search_str + search_len;
4771 while (
ptr > search_str) {
4772 if ((
unsigned char)*(--
ptr) == chr)
return (
void *)
ptr;
4780str_rindex(
VALUE str,
VALUE sub,
const char *s, rb_encoding *enc)
4782 char *hit, *adjusted;
4784 long slen, searchlen;
4787 sbeg = RSTRING_PTR(str);
4788 slen = RSTRING_LEN(sub);
4789 if (slen == 0)
return s - sbeg;
4790 e = RSTRING_END(str);
4791 t = RSTRING_PTR(sub);
4793 searchlen = s - sbeg + 1;
4795 if (s + slen <= e && memcmp(s, t, slen) == 0) {
4800 hit = memrchr(sbeg, c, searchlen);
4802 adjusted = rb_enc_left_char_head(sbeg, hit, e, enc);
4803 if (hit != adjusted) {
4804 searchlen = adjusted - sbeg;
4807 if (hit + slen <= e && memcmp(hit, t, slen) == 0)
4809 searchlen = adjusted - sbeg;
4810 }
while (searchlen > 0);
4824 enc = rb_enc_check(str, sub);
4825 if (is_broken_string(sub))
return -1;
4826 singlebyte = single_byte_optimizable(str);
4827 len = singlebyte ? RSTRING_LEN(str) : str_strlen(str, enc);
4828 slen = str_strlen(sub, enc);
4831 if (
len < slen)
return -1;
4833 if (
len - pos < slen) pos =
len - slen;
4834 if (
len == 0)
return pos;
4836 sbeg = RSTRING_PTR(str);
4839 if (RSTRING_LEN(sub) <= RSTRING_LEN(str) &&
4840 memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0) {
4848 s = str_nth(sbeg, RSTRING_END(str), pos, enc, singlebyte);
4849 return str_rindex(str, sub, s, enc);
4861rb_str_rindex_m(
int argc,
VALUE *argv,
VALUE str)
4865 rb_encoding *enc = STR_ENC_GET(str);
4866 long pos,
len = str_strlen(str, enc);
4868 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
4870 if (pos < 0 && (pos +=
len) < 0) {
4876 if (pos >
len) pos =
len;
4884 pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos,
4885 enc, single_byte_optimizable(str));
4896 pos = rb_str_rindex(str, sub, pos);
4906rb_str_byterindex(
VALUE str,
VALUE sub,
long pos)
4912 enc = rb_enc_check(str, sub);
4913 if (is_broken_string(sub))
return -1;
4914 len = RSTRING_LEN(str);
4915 slen = RSTRING_LEN(sub);
4918 if (
len < slen)
return -1;
4919 if (
len - pos < slen) pos =
len - slen;
4920 if (
len == 0)
return pos;
4922 sbeg = RSTRING_PTR(str);
4925 if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0)
4932 return str_rindex(str, sub, s, enc);
5022rb_str_byterindex_m(
int argc,
VALUE *argv,
VALUE str)
5028 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
5030 long len = RSTRING_LEN(str);
5031 if (pos < 0 && (pos +=
len) < 0) {
5037 if (pos >
len) pos =
len;
5040 pos = RSTRING_LEN(str);
5043 str_ensure_byte_pos(str, pos);
5055 pos = rb_str_byterindex(str, sub, pos);
5056 if (pos >= 0)
return LONG2NUM(pos);
5095 switch (OBJ_BUILTIN_TYPE(y)) {
5149rb_str_match_m(
int argc,
VALUE *argv,
VALUE str)
5153 rb_check_arity(argc, 1, 2);
5156 result = rb_funcallv(get_pat(re), rb_intern(
"match"), argc, argv);
5187rb_str_match_m_p(
int argc,
VALUE *argv,
VALUE str)
5190 rb_check_arity(argc, 1, 2);
5191 re = get_pat(argv[0]);
5192 return rb_reg_match_p(re, str, argc > 1 ?
NUM2LONG(argv[1]) : 0);
5201static enum neighbor_char
5202enc_succ_char(
char *p,
long len, rb_encoding *enc)
5207 if (rb_enc_mbminlen(enc) > 1) {
5209 int r = rb_enc_precise_mbclen(p, p +
len, enc), c;
5211 return NEIGHBOR_NOT_CHAR;
5213 c = rb_enc_mbc_to_codepoint(p, p +
len, enc) + 1;
5214 l = rb_enc_code_to_mbclen(c, enc);
5215 if (!l)
return NEIGHBOR_NOT_CHAR;
5216 if (l !=
len)
return NEIGHBOR_WRAPPED;
5217 rb_enc_mbcput(c, p, enc);
5218 r = rb_enc_precise_mbclen(p, p +
len, enc);
5220 return NEIGHBOR_NOT_CHAR;
5222 return NEIGHBOR_FOUND;
5225 for (i =
len-1; 0 <= i && (
unsigned char)p[i] == 0xff; i--)
5228 return NEIGHBOR_WRAPPED;
5229 ++((
unsigned char*)p)[i];
5230 l = rb_enc_precise_mbclen(p, p+
len, enc);
5234 return NEIGHBOR_FOUND;
5237 memset(p+l, 0xff,
len-l);
5243 for (len2 =
len-1; 0 < len2; len2--) {
5244 l2 = rb_enc_precise_mbclen(p, p+len2, enc);
5248 memset(p+len2+1, 0xff,
len-(len2+1));
5253static enum neighbor_char
5254enc_pred_char(
char *p,
long len, rb_encoding *enc)
5258 if (rb_enc_mbminlen(enc) > 1) {
5260 int r = rb_enc_precise_mbclen(p, p +
len, enc), c;
5262 return NEIGHBOR_NOT_CHAR;
5264 c = rb_enc_mbc_to_codepoint(p, p +
len, enc);
5265 if (!c)
return NEIGHBOR_NOT_CHAR;
5267 l = rb_enc_code_to_mbclen(c, enc);
5268 if (!l)
return NEIGHBOR_NOT_CHAR;
5269 if (l !=
len)
return NEIGHBOR_WRAPPED;
5270 rb_enc_mbcput(c, p, enc);
5271 r = rb_enc_precise_mbclen(p, p +
len, enc);
5273 return NEIGHBOR_NOT_CHAR;
5275 return NEIGHBOR_FOUND;
5278 for (i =
len-1; 0 <= i && (
unsigned char)p[i] == 0; i--)
5281 return NEIGHBOR_WRAPPED;
5282 --((
unsigned char*)p)[i];
5283 l = rb_enc_precise_mbclen(p, p+
len, enc);
5287 return NEIGHBOR_FOUND;
5290 memset(p+l, 0,
len-l);
5296 for (len2 =
len-1; 0 < len2; len2--) {
5297 l2 = rb_enc_precise_mbclen(p, p+len2, enc);
5301 memset(p+len2+1, 0,
len-(len2+1));
5315static enum neighbor_char
5316enc_succ_alnum_char(
char *p,
long len, rb_encoding *enc,
char *carry)
5318 enum neighbor_char ret;
5322 char save[ONIGENC_CODE_TO_MBC_MAXLEN];
5326 const int max_gaps = 1;
5328 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5329 if (rb_enc_isctype(c, ONIGENC_CTYPE_DIGIT, enc))
5330 ctype = ONIGENC_CTYPE_DIGIT;
5331 else if (rb_enc_isctype(c, ONIGENC_CTYPE_ALPHA, enc))
5332 ctype = ONIGENC_CTYPE_ALPHA;
5334 return NEIGHBOR_NOT_CHAR;
5337 for (
try = 0;
try <= max_gaps; ++
try) {
5338 ret = enc_succ_char(p,
len, enc);
5339 if (ret == NEIGHBOR_FOUND) {
5340 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5341 if (rb_enc_isctype(c, ctype, enc))
5342 return NEIGHBOR_FOUND;
5349 ret = enc_pred_char(p,
len, enc);
5350 if (ret == NEIGHBOR_FOUND) {
5351 c = rb_enc_mbc_to_codepoint(p, p+
len, enc);
5352 if (!rb_enc_isctype(c, ctype, enc)) {
5364 return NEIGHBOR_NOT_CHAR;
5367 if (ctype != ONIGENC_CTYPE_DIGIT) {
5369 return NEIGHBOR_WRAPPED;
5373 enc_succ_char(carry,
len, enc);
5374 return NEIGHBOR_WRAPPED;
5392 str = str_enc_new(
rb_cString, RSTRING_PTR(orig), RSTRING_LEN(orig), STR_ENC_GET(orig));
5393 rb_enc_cr_str_copy_for_substr(str, orig);
5394 return str_succ(str);
5401 char *sbeg, *s, *e, *last_alnum = 0;
5402 int found_alnum = 0;
5404 char carry[ONIGENC_CODE_TO_MBC_MAXLEN] =
"\1";
5405 long carry_pos = 0, carry_len = 1;
5406 enum neighbor_char neighbor = NEIGHBOR_FOUND;
5408 slen = RSTRING_LEN(str);
5409 if (slen == 0)
return str;
5411 enc = STR_ENC_GET(str);
5412 sbeg = RSTRING_PTR(str);
5413 s = e = sbeg + slen;
5415 while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
5416 if (neighbor == NEIGHBOR_NOT_CHAR && last_alnum) {
5422 l = rb_enc_precise_mbclen(s, e, enc);
5423 if (!ONIGENC_MBCLEN_CHARFOUND_P(l))
continue;
5424 l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
5425 neighbor = enc_succ_alnum_char(s, l, enc, carry);
5427 case NEIGHBOR_NOT_CHAR:
5429 case NEIGHBOR_FOUND:
5431 case NEIGHBOR_WRAPPED:
5436 carry_pos = s - sbeg;
5441 while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) {
5442 enum neighbor_char neighbor;
5443 char tmp[ONIGENC_CODE_TO_MBC_MAXLEN];
5444 l = rb_enc_precise_mbclen(s, e, enc);
5445 if (!ONIGENC_MBCLEN_CHARFOUND_P(l))
continue;
5446 l = ONIGENC_MBCLEN_CHARFOUND_LEN(l);
5448 neighbor = enc_succ_char(tmp, l, enc);
5450 case NEIGHBOR_FOUND:
5454 case NEIGHBOR_WRAPPED:
5457 case NEIGHBOR_NOT_CHAR:
5460 if (rb_enc_precise_mbclen(s, s+l, enc) != l) {
5462 enc_succ_char(s, l, enc);
5464 if (!rb_enc_asciicompat(enc)) {
5465 MEMCPY(carry, s,
char, l);
5468 carry_pos = s - sbeg;
5472 RESIZE_CAPA(str, slen + carry_len);
5473 sbeg = RSTRING_PTR(str);
5474 s = sbeg + carry_pos;
5475 memmove(s + carry_len, s, slen - carry_pos);
5476 memmove(s, carry, carry_len);
5478 STR_SET_LEN(str, slen);
5479 TERM_FILL(&sbeg[slen], rb_enc_mbminlen(enc));
5495rb_str_succ_bang(
VALUE str)
5503all_digits_p(
const char *s,
long len)
5531 VALUE end, exclusive;
5535 return rb_str_upto_each(beg, end,
RTEST(exclusive), str_upto_i,
Qnil);
5541 VALUE current, after_end;
5548 enc = rb_enc_check(beg, end);
5549 ascii = (is_ascii_string(beg) && is_ascii_string(end));
5551 if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1 && ascii) {
5552 char c = RSTRING_PTR(beg)[0];
5553 char e = RSTRING_PTR(end)[0];
5555 if (c > e || (excl && c == e))
return beg;
5557 VALUE str = rb_enc_str_new(&c, 1, enc);
5559 if ((*each)(str, arg))
break;
5560 if (!excl && c == e)
break;
5562 if (excl && c == e)
break;
5567 if (ascii &&
ISDIGIT(RSTRING_PTR(beg)[0]) &&
ISDIGIT(RSTRING_PTR(end)[0]) &&
5568 all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) &&
5569 all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) {
5573 width = RSTRING_LENINT(beg);
5574 b = rb_str_to_inum(beg, 10, FALSE);
5575 e = rb_str_to_inum(end, 10, FALSE);
5579 rb_encoding *usascii = rb_usascii_encoding();
5582 if (excl && bi == ei)
break;
5583 if ((*each)(
rb_enc_sprintf(usascii,
"%.*ld", width, bi), arg))
break;
5588 ID op = excl ?
'<' : idLE;
5589 VALUE args[2], fmt = rb_fstring_lit(
"%.*d");
5594 if ((*each)(
rb_str_format(numberof(args), args, fmt), arg))
break;
5595 b = rb_funcallv(b, succ, 0, 0);
5602 if (n > 0 || (excl && n == 0))
return beg;
5604 after_end = rb_funcallv(end, succ, 0, 0);
5609 next = rb_funcallv(current, succ, 0, 0);
5610 if ((*each)(current, arg))
break;
5611 if (
NIL_P(next))
break;
5615 if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0)
5630 if (is_ascii_string(beg) &&
ISDIGIT(RSTRING_PTR(beg)[0]) &&
5631 all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg))) {
5632 VALUE b, args[2], fmt = rb_fstring_lit(
"%.*d");
5633 int width = RSTRING_LENINT(beg);
5634 b = rb_str_to_inum(beg, 10, FALSE);
5637 rb_encoding *usascii = rb_usascii_encoding();
5640 if ((*each)(
rb_enc_sprintf(usascii,
"%.*ld", width, bi), arg))
break;
5648 if ((*each)(
rb_str_format(numberof(args), args, fmt), arg))
break;
5649 b = rb_funcallv(b, succ, 0, 0);
5655 VALUE next = rb_funcallv(current, succ, 0, 0);
5656 if ((*each)(current, arg))
break;
5659 if (RSTRING_LEN(current) == 0)
5670 if (!
rb_equal(str, *argp))
return 0;
5684 if (rb_enc_asciicompat(STR_ENC_GET(beg)) &&
5685 rb_enc_asciicompat(STR_ENC_GET(end)) &&
5686 rb_enc_asciicompat(STR_ENC_GET(val))) {
5687 const char *bp = RSTRING_PTR(beg);
5688 const char *ep = RSTRING_PTR(end);
5689 const char *vp = RSTRING_PTR(val);
5690 if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
5691 if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
5698 if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
5699 if (b <= v && v < e)
return Qtrue;
5700 return RBOOL(!
RTEST(exclusive) && b <= v && v == e);
5707 all_digits_p(bp, RSTRING_LEN(beg)) &&
5708 all_digits_p(ep, RSTRING_LEN(end))) {
5713 rb_str_upto_each(beg, end,
RTEST(exclusive), include_range_i, (
VALUE)&val);
5715 return RBOOL(
NIL_P(val));
5737 else if (RB_TYPE_P(indx,
T_REGEXP)) {
5738 return rb_str_subpat(str, indx,
INT2FIX(0));
5740 else if (RB_TYPE_P(indx,
T_STRING)) {
5741 if (rb_str_index(str, indx, 0) != -1)
5747 long beg,
len = str_strlen(str, NULL);
5759 return str_substr(str, idx, 1, FALSE);
5776rb_str_aref_m(
int argc,
VALUE *argv,
VALUE str)
5779 if (RB_TYPE_P(argv[0],
T_REGEXP)) {
5780 return rb_str_subpat(str, argv[0], argv[1]);
5783 return rb_str_substr_two_fixnums(str, argv[0], argv[1], TRUE);
5786 rb_check_arity(argc, 1, 2);
5787 return rb_str_aref(str, argv[0]);
5793 str_modifiable(str);
5798 if (
len > olen)
len = olen;
5799 long nlen = olen -
len;
5800 if (str_embed_capa(str) >= nlen + TERM_LEN(str)) {
5802 int fl = (int)(
RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE));
5805 memmove(
ptr, oldptr +
len, nlen);
5806 if (fl == STR_NOEMBED)
xfree(oldptr);
5809 if (!STR_SHARED_P(str)) {
5811 rb_enc_cr_str_exact_copy(shared, str);
5816 STR_SET_LEN(str, nlen);
5818 if (!SHARABLE_MIDDLE_SUBSTRING) {
5819 TERM_FILL(
ptr + nlen, TERM_LEN(str));
5826rb_str_update_1(
VALUE str,
long beg,
long len,
VALUE val,
long vbeg,
long vlen)
5832 if (beg == 0 && vlen == 0) {
5837 str_modify_keep_cr(str);
5841 RESIZE_CAPA(str, slen + vlen -
len);
5842 sptr = RSTRING_PTR(str);
5851 memmove(sptr + beg + vlen,
5853 slen - (beg +
len));
5855 if (vlen < beg &&
len < 0) {
5859 memmove(sptr + beg, RSTRING_PTR(val) + vbeg, vlen);
5862 STR_SET_LEN(str, slen);
5863 TERM_FILL(&sptr[slen], TERM_LEN(str));
5870 rb_str_update_1(str, beg,
len, val, 0, RSTRING_LEN(val));
5879 int singlebyte = single_byte_optimizable(str);
5885 enc = rb_enc_check(str, val);
5886 slen = str_strlen(str, enc);
5888 if ((slen < beg) || ((beg < 0) && (beg + slen < 0))) {
5897 if (
len > slen - beg) {
5900 p = str_nth(RSTRING_PTR(str), RSTRING_END(str), beg, enc, singlebyte);
5901 if (!p) p = RSTRING_END(str);
5902 e = str_nth(p, RSTRING_END(str),
len, enc, singlebyte);
5903 if (!e) e = RSTRING_END(str);
5905 beg = p - RSTRING_PTR(str);
5907 rb_str_update_0(str, beg,
len, val);
5908 rb_enc_associate(str, enc);
5919 long start, end,
len;
5928 regs = RMATCH_REGS(match);
5930 if (nth >= regs->num_regs || nth + regs->num_regs <= 0) {
5934 nth += regs->num_regs;
5945 if (start +
len > RSTRING_LEN(str)) {
5949 enc = rb_enc_check_str(str, val);
5950 rb_str_update_0(str, start,
len, val);
5951 rb_enc_associate(str, enc);
5959 switch (
TYPE(indx)) {
5961 rb_str_subpat_set(str, indx,
INT2FIX(0), val);
5965 beg = rb_str_index(str, indx, 0);
6004rb_str_aset_m(
int argc,
VALUE *argv,
VALUE str)
6007 if (RB_TYPE_P(argv[0],
T_REGEXP)) {
6008 rb_str_subpat_set(str, argv[0], argv[1], argv[2]);
6015 rb_check_arity(argc, 2, 3);
6016 return rb_str_aset(str, argv[0], argv[1]);
6068rb_str_slice_bang(
int argc,
VALUE *argv,
VALUE str)
6075 rb_check_arity(argc, 1, 2);
6076 str_modify_keep_cr(str);
6084 if ((nth += regs->num_regs) <= 0)
return Qnil;
6086 else if (nth >= regs->num_regs)
return Qnil;
6088 len = END(nth) - beg;
6090 if (beg > RSTRING_LEN(str))
return Qnil;
6091 if (
len > RSTRING_LEN(str) - beg)
len = RSTRING_LEN(str) - beg;
6094 else if (argc == 2) {
6103 beg = p - RSTRING_PTR(str);
6106 else if (RB_TYPE_P(indx,
T_STRING)) {
6107 beg = rb_str_index(str, indx, 0);
6108 if (beg == -1)
return Qnil;
6109 len = RSTRING_LEN(indx);
6121 beg = p - RSTRING_PTR(str);
6130 beg = p - RSTRING_PTR(str);
6133 result = str_enc_new(
rb_cString, RSTRING_PTR(str)+beg,
len, STR_ENC_GET(str));
6134 rb_enc_cr_str_copy_for_substr(result, str);
6142 char *sptr = RSTRING_PTR(str);
6143 long slen = RSTRING_LEN(str);
6144 if (beg +
len > slen)
6148 slen - (beg +
len));
6150 STR_SET_LEN(str, slen);
6151 TERM_FILL(&sptr[slen], TERM_LEN(str));
6162 switch (OBJ_BUILTIN_TYPE(pat)) {
6181get_pat_quoted(
VALUE pat,
int check)
6185 switch (OBJ_BUILTIN_TYPE(pat)) {
6199 if (check && is_broken_string(pat)) {
6206rb_pat_search0(
VALUE pat,
VALUE str,
long pos,
int set_backref_str,
VALUE *match)
6209 pos = rb_str_byteindex(str, pat, pos);
6210 if (set_backref_str) {
6212 str = rb_str_new_frozen_String(str);
6213 VALUE match_data = rb_backref_set_string(str, pos, RSTRING_LEN(pat));
6215 *match = match_data;
6225 return rb_reg_search0(pat, str, pos, 0, set_backref_str, match);
6230rb_pat_search(
VALUE pat,
VALUE str,
long pos,
int set_backref_str)
6232 return rb_pat_search0(pat, str, pos, set_backref_str, NULL);
6250rb_str_sub_bang(
int argc,
VALUE *argv,
VALUE str)
6258 rb_check_arity(argc, min_arity, 2);
6264 hash = rb_check_hash_type(argv[1]);
6270 pat = get_pat_quoted(argv[0], 1);
6272 str_modifiable(str);
6273 beg = rb_pat_search(pat, str, 0, 1);
6284 regs = RMATCH_REGS(match);
6287 end0 = beg0 + RSTRING_LEN(pat);
6296 if (iter || !
NIL_P(hash)) {
6297 p = RSTRING_PTR(str);
len = RSTRING_LEN(str);
6303 repl = rb_hash_aref(hash,
rb_str_subseq(str, beg0, end0 - beg0));
6306 str_mod_check(str, p,
len);
6307 rb_check_frozen(str);
6313 enc = rb_enc_compatible(str, repl);
6315 rb_encoding *str_enc = STR_ENC_GET(str);
6316 p = RSTRING_PTR(str);
len = RSTRING_LEN(str);
6320 rb_enc_inspect_name(str_enc),
6321 rb_enc_inspect_name(STR_ENC_GET(repl)));
6323 enc = STR_ENC_GET(repl);
6326 rb_enc_associate(str, enc);
6336 rlen = RSTRING_LEN(repl);
6337 len = RSTRING_LEN(str);
6339 RESIZE_CAPA(str,
len + rlen - plen);
6341 p = RSTRING_PTR(str);
6343 memmove(p + beg0 + rlen, p + beg0 + plen,
len - beg0 - plen);
6345 rp = RSTRING_PTR(repl);
6346 memmove(p + beg0, rp, rlen);
6348 STR_SET_LEN(str,
len);
6349 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
6372 rb_str_sub_bang(argc, argv, str);
6377str_gsub(
int argc,
VALUE *argv,
VALUE str,
int bang)
6380 long beg, beg0, end0;
6381 long offset, blen, slen,
len, last;
6382 enum {STR, ITER, FAST_MAP, MAP} mode = STR;
6384 int need_backref_str = -1;
6385 rb_encoding *str_enc;
6394 hash = rb_check_hash_type(argv[1]);
6398 else if (rb_hash_default_unredefined(hash) && !
FL_TEST_RAW(hash, RHASH_PROC_DEFAULT)) {
6406 rb_error_arity(argc, 1, 2);
6409 pat = get_pat_quoted(argv[0], 1);
6410 beg = rb_pat_search0(pat, str, 0, need_backref_str, &match);
6413 if (bang)
return Qnil;
6418 blen = RSTRING_LEN(str) + 30;
6420 sp = RSTRING_PTR(str);
6421 slen = RSTRING_LEN(str);
6423 str_enc = STR_ENC_GET(str);
6424 rb_enc_associate(dest, str_enc);
6431 end0 = beg0 + RSTRING_LEN(pat);
6445 struct RString fake_str = {RBASIC_INIT};
6447 if (mode == FAST_MAP) {
6456 val = rb_hash_aref(hash, key);
6459 str_mod_check(str, sp, slen);
6464 else if (need_backref_str) {
6466 if (need_backref_str < 0) {
6467 need_backref_str = val != repl;
6474 len = beg0 - offset;
6488 if (RSTRING_LEN(str) <= end0)
break;
6489 len = rb_enc_fast_mbclen(RSTRING_PTR(str)+end0, RSTRING_END(str), str_enc);
6491 offset = end0 +
len;
6493 cp = RSTRING_PTR(str) + offset;
6494 if (offset > RSTRING_LEN(str))
break;
6497 if (mode != FAST_MAP && mode != STR) {
6500 beg = rb_pat_search0(pat, str, offset, need_backref_str, &match);
6505 if (RSTRING_LEN(str) > offset) {
6508 rb_pat_search0(pat, str, last, 1, &match);
6510 str_shared_replace(str, dest);
6535rb_str_gsub_bang(
int argc,
VALUE *argv,
VALUE str)
6537 str_modify_keep_cr(str);
6538 return str_gsub(argc, argv, str, 1);
6588 return str_gsub(argc, argv, str, 0);
6608 str_modifiable(str);
6609 if (str == str2)
return str;
6613 return str_replace(str, str2);
6630rb_str_clear(
VALUE str)
6634 STR_SET_LEN(str, 0);
6635 RSTRING_PTR(str)[0] = 0;
6636 if (rb_enc_asciicompat(STR_ENC_GET(str)))
6652rb_str_chr(
VALUE str)
6670 pos += RSTRING_LEN(str);
6671 if (pos < 0 || RSTRING_LEN(str) <= pos)
6674 return INT2FIX((
unsigned char)RSTRING_PTR(str)[pos]);
6694 char *
ptr, *head, *left = 0;
6700 char byte = (char)(
NUM2INT(w) & 0xFF);
6702 if (!str_independent(str))
6703 str_make_independent(str);
6705 long len = RSTRING_LEN(str);
6706 if (pos < -
len ||
len <= pos)
6711 enc = STR_ENC_GET(str);
6712 head = RSTRING_PTR(str);
6714 if (!STR_EMBED_P(str)) {
6720 if (ISASCII(
byte))
goto end;
6721 nlen = rb_enc_precise_mbclen(left, head+
len, enc);
6728 left = rb_enc_left_char_head(head,
ptr, head+
len, enc);
6729 width = rb_enc_precise_mbclen(left, head+
len, enc);
6731 nlen = rb_enc_precise_mbclen(left, head+
len, enc);
6747str_byte_substr(
VALUE str,
long beg,
long len,
int empty)
6749 long n = RSTRING_LEN(str);
6751 if (beg > n ||
len < 0)
return Qnil;
6754 if (beg < 0)
return Qnil;
6759 if (!empty)
return Qnil;
6763 VALUE str2 = str_subseq(str, beg,
len);
6765 str_enc_copy_direct(str2, str);
6767 if (RSTRING_LEN(str2) == 0) {
6768 if (!rb_enc_asciicompat(STR_ENC_GET(str)))
6802 long beg,
len = RSTRING_LEN(str);
6810 return str_byte_substr(str, beg,
len, TRUE);
6815 return str_byte_substr(str, idx, 1, FALSE);
6827rb_str_byteslice(
int argc,
VALUE *argv,
VALUE str)
6832 return str_byte_substr(str, beg,
len, TRUE);
6834 rb_check_arity(argc, 1, 2);
6835 return str_byte_aref(str, argv[0]);
6839str_check_beg_len(
VALUE str,
long *beg,
long *
len)
6841 long end, slen = RSTRING_LEN(str);
6844 if ((slen < *beg) || ((*beg < 0) && (*beg + slen < 0))) {
6853 if (*
len > slen - *beg) {
6857 str_ensure_byte_pos(str, *beg);
6858 str_ensure_byte_pos(str, end);
6872rb_str_bytesplice(
int argc,
VALUE *argv,
VALUE str)
6874 long beg,
len, vbeg, vlen;
6878 rb_check_arity(argc, 2, 5);
6879 if (!(argc == 2 || argc == 3 || argc == 5)) {
6880 rb_raise(rb_eArgError,
"wrong number of arguments (given %d, expected 2, 3, or 5)", argc);
6884 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Range)",
6885 rb_builtin_class_name(argv[0]));
6892 vlen = RSTRING_LEN(val);
6897 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Range)",
6898 rb_builtin_class_name(argv[2]));
6910 vlen = RSTRING_LEN(val);
6918 str_check_beg_len(str, &beg, &
len);
6919 str_check_beg_len(val, &vbeg, &vlen);
6920 str_modify_keep_cr(str);
6923 rb_enc_associate(str, rb_enc_check(str, val));
6926 rb_str_update_1(str, beg,
len, val, vbeg, vlen);
6948rb_str_reverse(
VALUE str)
6955 if (RSTRING_LEN(str) <= 1)
return str_duplicate(
rb_cString, str);
6956 enc = STR_ENC_GET(str);
6957 rev = str_enc_new(
rb_cString, 0, RSTRING_LEN(str), enc);
6958 s = RSTRING_PTR(str); e = RSTRING_END(str);
6959 p = RSTRING_END(rev);
6962 if (RSTRING_LEN(str) > 1) {
6963 if (single_byte_optimizable(str)) {
6970 int clen = rb_enc_fast_mbclen(s, e, enc);
6978 cr = rb_enc_asciicompat(enc) ?
6981 int clen = rb_enc_mbclen(s, e, enc);
6990 STR_SET_LEN(rev, RSTRING_LEN(str));
7012rb_str_reverse_bang(
VALUE str)
7014 if (RSTRING_LEN(str) > 1) {
7015 if (single_byte_optimizable(str)) {
7018 str_modify_keep_cr(str);
7019 s = RSTRING_PTR(str);
7020 e = RSTRING_END(str) - 1;
7028 str_shared_replace(str, rb_str_reverse(str));
7032 str_modify_keep_cr(str);
7061 i = rb_str_index(str, arg, 0);
7063 return RBOOL(i != -1);
7106 if (rb_check_arity(argc, 0, 1) && (base =
NUM2INT(argv[0])) < 0) {
7107 rb_raise(rb_eArgError,
"invalid radix %d", base);
7109 return rb_str_to_inum(str, base, FALSE);
7134rb_str_to_f(
VALUE str)
7151rb_str_to_s(
VALUE str)
7161str_cat_char(
VALUE str,
unsigned int c, rb_encoding *enc)
7163 char s[RUBY_MAX_CHAR_LEN];
7164 int n = rb_enc_codelen(c, enc);
7166 rb_enc_mbcput(c, s, enc);
7171#define CHAR_ESC_LEN 13
7174rb_str_buf_cat_escaped_char(
VALUE result,
unsigned int c,
int unicode_p)
7176 char buf[CHAR_ESC_LEN + 1];
7184 snprintf(buf, CHAR_ESC_LEN,
"%c", c);
7186 else if (c < 0x10000) {
7187 snprintf(buf, CHAR_ESC_LEN,
"\\u%04X", c);
7190 snprintf(buf, CHAR_ESC_LEN,
"\\u{%X}", c);
7195 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", c);
7198 snprintf(buf, CHAR_ESC_LEN,
"\\x{%X}", c);
7201 l = (int)strlen(buf);
7207ruby_escaped_char(
int c)
7210 case '\0':
return "\\0";
7211 case '\n':
return "\\n";
7212 case '\r':
return "\\r";
7213 case '\t':
return "\\t";
7214 case '\f':
return "\\f";
7215 case '\013':
return "\\v";
7216 case '\010':
return "\\b";
7217 case '\007':
return "\\a";
7218 case '\033':
return "\\e";
7219 case '\x7f':
return "\\c?";
7225rb_str_escape(
VALUE str)
7228 rb_encoding *enc = rb_enc_from_index(encidx);
7229 const char *p = RSTRING_PTR(str);
7230 const char *pend = RSTRING_END(str);
7231 const char *prev = p;
7232 char buf[CHAR_ESC_LEN + 1];
7234 int unicode_p = rb_enc_unicode_p(enc);
7235 int asciicompat = rb_enc_asciicompat(enc);
7240 int n = rb_enc_precise_mbclen(p, pend, enc);
7242 if (p > prev) str_buf_cat(result, prev, p - prev);
7243 n = rb_enc_mbminlen(enc);
7245 n = (int)(pend - p);
7247 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", *p & 0377);
7248 str_buf_cat(result, buf, strlen(buf));
7254 c = rb_enc_mbc_to_codepoint(p, pend, enc);
7256 cc = ruby_escaped_char(c);
7258 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
7259 str_buf_cat(result, cc, strlen(cc));
7262 else if (asciicompat && rb_enc_isascii(c, enc) &&
ISPRINT(c)) {
7265 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
7266 rb_str_buf_cat_escaped_char(result, c, unicode_p);
7270 if (p > prev) str_buf_cat(result, prev, p - prev);
7288 rb_encoding *enc = rb_enc_from_index(encidx);
7289 const char *p, *pend, *prev;
7290 char buf[CHAR_ESC_LEN + 1];
7292 rb_encoding *resenc = rb_default_internal_encoding();
7293 int unicode_p = rb_enc_unicode_p(enc);
7294 int asciicompat = rb_enc_asciicompat(enc);
7296 if (resenc == NULL) resenc = rb_default_external_encoding();
7297 if (!rb_enc_asciicompat(resenc)) resenc = rb_usascii_encoding();
7298 rb_enc_associate(result, resenc);
7299 str_buf_cat2(result,
"\"");
7301 p = RSTRING_PTR(str); pend = RSTRING_END(str);
7307 n = rb_enc_precise_mbclen(p, pend, enc);
7309 if (p > prev) str_buf_cat(result, prev, p - prev);
7310 n = rb_enc_mbminlen(enc);
7312 n = (int)(pend - p);
7314 snprintf(buf, CHAR_ESC_LEN,
"\\x%02X", *p & 0377);
7315 str_buf_cat(result, buf, strlen(buf));
7321 c = rb_enc_mbc_to_codepoint(p, pend, enc);
7323 if ((asciicompat || unicode_p) &&
7324 (c ==
'"'|| c ==
'\\' ||
7328 (cc = rb_enc_codepoint(p,pend,enc),
7329 (cc ==
'$' || cc ==
'@' || cc ==
'{'))))) {
7330 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
7331 str_buf_cat2(result,
"\\");
7332 if (asciicompat || enc == resenc) {
7338 case '\n': cc =
'n';
break;
7339 case '\r': cc =
'r';
break;
7340 case '\t': cc =
't';
break;
7341 case '\f': cc =
'f';
break;
7342 case '\013': cc =
'v';
break;
7343 case '\010': cc =
'b';
break;
7344 case '\007': cc =
'a';
break;
7345 case 033: cc =
'e';
break;
7346 default: cc = 0;
break;
7349 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
7352 str_buf_cat(result, buf, 2);
7364 if ((enc == resenc && rb_enc_isprint(c, enc) && c != 0x85) ||
7365 (asciicompat && rb_enc_isascii(c, enc) &&
ISPRINT(c))) {
7369 if (p - n > prev) str_buf_cat(result, prev, p - n - prev);
7370 rb_str_buf_cat_escaped_char(result, c, unicode_p);
7375 if (p > prev) str_buf_cat(result, prev, p - prev);
7376 str_buf_cat2(result,
"\"");
7381#define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
7394 int encidx = rb_enc_get_index(str);
7395 rb_encoding *enc = rb_enc_from_index(encidx);
7397 const char *p, *pend;
7400 int u8 = (encidx == rb_utf8_encindex());
7401 static const char nonascii_suffix[] =
".dup.force_encoding(\"%s\")";
7404 if (!rb_enc_asciicompat(enc)) {
7406 len += strlen(enc->name);
7409 p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
7412 unsigned char c = *p++;
7415 case '"':
case '\\':
7416 case '\n':
case '\r':
7417 case '\t':
case '\f':
7418 case '\013':
case '\010':
case '\007':
case '\033':
7423 clen = IS_EVSTR(p, pend) ? 2 : 1;
7431 if (u8 && c > 0x7F) {
7432 int n = rb_enc_precise_mbclen(p-1, pend, enc);
7434 unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
7437 else if (cc <= 0xFFFFF)
7450 if (clen > LONG_MAX -
len) {
7457 p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str);
7458 q = RSTRING_PTR(result); qend = q +
len + 1;
7462 unsigned char c = *p++;
7464 if (c ==
'"' || c ==
'\\') {
7468 else if (c ==
'#') {
7469 if (IS_EVSTR(p, pend)) *q++ =
'\\';
7472 else if (c ==
'\n') {
7476 else if (c ==
'\r') {
7480 else if (c ==
'\t') {
7484 else if (c ==
'\f') {
7488 else if (c ==
'\013') {
7492 else if (c ==
'\010') {
7496 else if (c ==
'\007') {
7500 else if (c ==
'\033') {
7510 int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1;
7512 int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc);
7515 snprintf(q, qend-q,
"u%04X", cc);
7517 snprintf(q, qend-q,
"u{%X}", cc);
7522 snprintf(q, qend-q,
"x%02X", c);
7528 if (!rb_enc_asciicompat(enc)) {
7529 snprintf(q, qend-q, nonascii_suffix, enc->name);
7530 encidx = rb_ascii8bit_encindex();
7533 rb_enc_associate_index(result, encidx);
7539unescape_ascii(
unsigned int c)
7563undump_after_backslash(
VALUE undumped,
const char **ss,
const char *s_end, rb_encoding **penc,
bool *utf8,
bool *binary)
7565 const char *s = *ss;
7569 unsigned char buf[6];
7570 static rb_encoding *enc_utf8 = NULL;
7587 *buf = unescape_ascii(*s);
7599 if (enc_utf8 == NULL) enc_utf8 = rb_utf8_encoding();
7600 if (*penc != enc_utf8) {
7602 rb_enc_associate(undumped, enc_utf8);
7619 if (hexlen == 0 || hexlen > 6) {
7625 if (0xd800 <= c && c <= 0xdfff) {
7628 codelen = rb_enc_mbcput(c, (
char *)buf, *penc);
7638 if (0xd800 <= c && c <= 0xdfff) {
7641 codelen = rb_enc_mbcput(c, (
char *)buf, *penc);
7654 if (!ISASCII(*buf)) {
7671static VALUE rb_str_is_ascii_only_p(
VALUE str);
7683str_undump(
VALUE str)
7685 const char *s = RSTRING_PTR(str);
7686 const char *s_end = RSTRING_END(str);
7687 rb_encoding *enc = rb_enc_get(str);
7688 VALUE undumped = rb_enc_str_new(s, 0L, enc);
7690 bool binary =
false;
7694 if (rb_str_is_ascii_only_p(str) ==
Qfalse) {
7697 if (!str_null_check(str, &w)) {
7700 if (RSTRING_LEN(str) < 2)
goto invalid_format;
7701 if (*s !=
'"')
goto invalid_format;
7719 static const char force_encoding_suffix[] =
".force_encoding(\"";
7720 static const char dup_suffix[] =
".dup";
7721 const char *encname;
7726 size =
sizeof(dup_suffix) - 1;
7727 if (s_end - s > size && memcmp(s, dup_suffix, size) == 0) s += size;
7729 size =
sizeof(force_encoding_suffix) - 1;
7730 if (s_end - s <= size)
goto invalid_format;
7731 if (memcmp(s, force_encoding_suffix, size) != 0)
goto invalid_format;
7735 rb_raise(
rb_eRuntimeError,
"dumped string contained Unicode escape but used force_encoding");
7739 s = memchr(s,
'"', s_end-s);
7741 if (!s)
goto invalid_format;
7742 if (s_end - s != 2)
goto invalid_format;
7743 if (s[0] !=
'"' || s[1] !=
')')
goto invalid_format;
7745 encidx = rb_enc_find_index2(encname, (
long)size);
7749 rb_enc_associate_index(undumped, encidx);
7759 undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary);
7770 rb_raise(
rb_eRuntimeError,
"invalid dumped string; not wrapped with '\"' nor '\"...\".force_encoding(\"...\")' form");
7774rb_str_check_dummy_enc(rb_encoding *enc)
7776 if (rb_enc_dummy_p(enc)) {
7783str_true_enc(
VALUE str)
7785 rb_encoding *enc = STR_ENC_GET(str);
7786 rb_str_check_dummy_enc(enc);
7790static OnigCaseFoldType
7791check_case_options(
int argc,
VALUE *argv, OnigCaseFoldType flags)
7796 rb_raise(rb_eArgError,
"too many options");
7797 if (argv[0]==sym_turkic) {
7798 flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
7800 if (argv[1]==sym_lithuanian)
7801 flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
7803 rb_raise(rb_eArgError,
"invalid second option");
7806 else if (argv[0]==sym_lithuanian) {
7807 flags |= ONIGENC_CASE_FOLD_LITHUANIAN;
7809 if (argv[1]==sym_turkic)
7810 flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI;
7812 rb_raise(rb_eArgError,
"invalid second option");
7816 rb_raise(rb_eArgError,
"too many options");
7817 else if (argv[0]==sym_ascii)
7818 flags |= ONIGENC_CASE_ASCII_ONLY;
7819 else if (argv[0]==sym_fold) {
7820 if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE)
7821 flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE;
7823 rb_raise(rb_eArgError,
"option :fold only allowed for downcasing");
7826 rb_raise(rb_eArgError,
"invalid option");
7831case_option_single_p(OnigCaseFoldType flags, rb_encoding *enc,
VALUE str)
7833 if ((flags & ONIGENC_CASE_ASCII_ONLY) && (enc==rb_utf8_encoding() || rb_enc_mbmaxlen(enc) == 1))
7839#define CASE_MAPPING_ADDITIONAL_LENGTH 20
7840#ifndef CASEMAP_DEBUG
7841# define CASEMAP_DEBUG 0
7849 OnigUChar space[FLEX_ARY_LEN];
7853mapping_buffer_free(
void *p)
7857 while (current_buffer) {
7858 previous_buffer = current_buffer;
7859 current_buffer = current_buffer->next;
7860 ruby_sized_xfree(previous_buffer, previous_buffer->capa);
7866 {0, mapping_buffer_free,},
7867 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
7871rb_str_casemap(
VALUE source, OnigCaseFoldType *flags, rb_encoding *enc)
7875 const OnigUChar *source_current, *source_end;
7876 long target_length = 0;
7877 VALUE buffer_anchor;
7880 size_t buffer_count = 0;
7881 int buffer_length_or_invalid;
7883 if (RSTRING_LEN(source) == 0)
return str_duplicate(
rb_cString, source);
7884 if (RSTRING_LEN(source) > INT_MAX - CASE_MAPPING_ADDITIONAL_LENGTH)
7885 rb_raise(rb_eArgError,
"string size too big");
7887 source_current = (OnigUChar*)RSTRING_PTR(source);
7888 source_end = (OnigUChar*)RSTRING_END(source);
7892 while (source_current < source_end) {
7894 size_t capa = (size_t)(source_end-source_current);
7895 if (
capa > (INT_MAX - CASE_MAPPING_ADDITIONAL_LENGTH) / ++buffer_count)
7898 capa =
capa * buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH;
7899 if (CASEMAP_DEBUG) {
7900 fprintf(stderr,
"Buffer allocation, capa is %"PRIuSIZE
"\n",
capa);
7903 *pre_buffer = current_buffer;
7904 pre_buffer = ¤t_buffer->next;
7905 current_buffer->next = NULL;
7906 current_buffer->capa =
capa;
7907 buffer_length_or_invalid = enc->case_map(flags,
7908 &source_current, source_end,
7909 current_buffer->space,
7910 current_buffer->space+current_buffer->capa,
7912 if (buffer_length_or_invalid < 0 || buffer_length_or_invalid > LONG_MAX - target_length) {
7913 current_buffer =
DATA_PTR(buffer_anchor);
7915 mapping_buffer_free(current_buffer);
7916 if (buffer_length_or_invalid < 0)
7917 rb_raise(rb_eArgError,
"input string invalid");
7918 rb_raise(rb_eArgError,
"string size too big");
7920 target_length += current_buffer->used = buffer_length_or_invalid;
7922 if (CASEMAP_DEBUG) {
7923 fprintf(stderr,
"Buffer count is %"PRIuSIZE
"\n", buffer_count);
7926 if (buffer_count==1) {
7927 target = str_enc_new(
rb_cString, (
const char*)current_buffer->space, target_length, enc);
7930 char *target_current;
7932 target = str_enc_new(
rb_cString, 0, target_length, enc);
7933 target_current = RSTRING_PTR(target);
7934 current_buffer =
DATA_PTR(buffer_anchor);
7935 while (current_buffer) {
7936 memcpy(target_current, current_buffer->space, current_buffer->used);
7937 target_current += current_buffer->used;
7938 current_buffer = current_buffer->next;
7941 current_buffer =
DATA_PTR(buffer_anchor);
7943 mapping_buffer_free(current_buffer);
7953rb_str_ascii_casemap(
VALUE source,
VALUE target, OnigCaseFoldType *flags, rb_encoding *enc)
7955 const OnigUChar *source_current, *source_end;
7956 OnigUChar *target_current, *target_end;
7957 long old_length = RSTRING_LEN(source);
7958 int length_or_invalid;
7960 if (old_length == 0)
return Qnil;
7962 source_current = (OnigUChar*)RSTRING_PTR(source);
7963 source_end = (OnigUChar*)RSTRING_END(source);
7964 if (source == target) {
7965 target_current = (OnigUChar*)source_current;
7966 target_end = (OnigUChar*)source_end;
7969 target_current = (OnigUChar*)RSTRING_PTR(target);
7970 target_end = (OnigUChar*)RSTRING_END(target);
7973 length_or_invalid = onigenc_ascii_only_case_map(flags,
7974 &source_current, source_end,
7975 target_current, target_end, enc);
7976 if (length_or_invalid < 0)
7977 rb_raise(rb_eArgError,
"input string invalid");
7978 if (CASEMAP_DEBUG && length_or_invalid != old_length) {
7979 fprintf(stderr,
"problem with rb_str_ascii_casemap"
7980 "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
7981 rb_raise(rb_eArgError,
"internal problem with rb_str_ascii_casemap"
7982 "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid);
7991upcase_single(
VALUE str)
7993 char *s = RSTRING_PTR(str), *send = RSTRING_END(str);
7994 bool modified =
false;
7997 unsigned int c = *(
unsigned char*)s;
7999 if (
'a' <= c && c <=
'z') {
8000 *s =
'A' + (c -
'a');
8021rb_str_upcase_bang(
int argc,
VALUE *argv,
VALUE str)
8024 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE;
8026 flags = check_case_options(argc, argv, flags);
8027 str_modify_keep_cr(str);
8028 enc = str_true_enc(str);
8029 if (case_option_single_p(flags, enc, str)) {
8030 if (upcase_single(str))
8031 flags |= ONIGENC_CASE_MODIFIED;
8033 else if (flags&ONIGENC_CASE_ASCII_ONLY)
8034 rb_str_ascii_casemap(str, str, &flags, enc);
8036 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
8038 if (ONIGENC_CASE_MODIFIED&flags)
return str;
8051rb_str_upcase(
int argc,
VALUE *argv,
VALUE str)
8054 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE;
8057 flags = check_case_options(argc, argv, flags);
8058 enc = str_true_enc(str);
8059 if (case_option_single_p(flags, enc, str)) {
8060 ret =
rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
8061 str_enc_copy_direct(ret, str);
8064 else if (flags&ONIGENC_CASE_ASCII_ONLY) {
8066 rb_str_ascii_casemap(str, ret, &flags, enc);
8069 ret = rb_str_casemap(str, &flags, enc);
8076downcase_single(
VALUE str)
8078 char *s = RSTRING_PTR(str), *send = RSTRING_END(str);
8079 bool modified =
false;
8082 unsigned int c = *(
unsigned char*)s;
8084 if (
'A' <= c && c <=
'Z') {
8085 *s =
'a' + (c -
'A');
8107rb_str_downcase_bang(
int argc,
VALUE *argv,
VALUE str)
8110 OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE;
8112 flags = check_case_options(argc, argv, flags);
8113 str_modify_keep_cr(str);
8114 enc = str_true_enc(str);
8115 if (case_option_single_p(flags, enc, str)) {
8116 if (downcase_single(str))
8117 flags |= ONIGENC_CASE_MODIFIED;
8119 else if (flags&ONIGENC_CASE_ASCII_ONLY)
8120 rb_str_ascii_casemap(str, str, &flags, enc);
8122 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
8124 if (ONIGENC_CASE_MODIFIED&flags)
return str;
8138rb_str_downcase(
int argc,
VALUE *argv,
VALUE str)
8141 OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE;
8144 flags = check_case_options(argc, argv, flags);
8145 enc = str_true_enc(str);
8146 if (case_option_single_p(flags, enc, str)) {
8147 ret =
rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
8148 str_enc_copy_direct(ret, str);
8149 downcase_single(ret);
8151 else if (flags&ONIGENC_CASE_ASCII_ONLY) {
8153 rb_str_ascii_casemap(str, ret, &flags, enc);
8156 ret = rb_str_casemap(str, &flags, enc);
8176rb_str_capitalize_bang(
int argc,
VALUE *argv,
VALUE str)
8179 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_TITLECASE;
8181 flags = check_case_options(argc, argv, flags);
8182 str_modify_keep_cr(str);
8183 enc = str_true_enc(str);
8184 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
8185 if (flags&ONIGENC_CASE_ASCII_ONLY)
8186 rb_str_ascii_casemap(str, str, &flags, enc);
8188 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
8190 if (ONIGENC_CASE_MODIFIED&flags)
return str;
8204rb_str_capitalize(
int argc,
VALUE *argv,
VALUE str)
8207 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_TITLECASE;
8210 flags = check_case_options(argc, argv, flags);
8211 enc = str_true_enc(str);
8212 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return str;
8213 if (flags&ONIGENC_CASE_ASCII_ONLY) {
8215 rb_str_ascii_casemap(str, ret, &flags, enc);
8218 ret = rb_str_casemap(str, &flags, enc);
8237rb_str_swapcase_bang(
int argc,
VALUE *argv,
VALUE str)
8240 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE;
8242 flags = check_case_options(argc, argv, flags);
8243 str_modify_keep_cr(str);
8244 enc = str_true_enc(str);
8245 if (flags&ONIGENC_CASE_ASCII_ONLY)
8246 rb_str_ascii_casemap(str, str, &flags, enc);
8248 str_shared_replace(str, rb_str_casemap(str, &flags, enc));
8250 if (ONIGENC_CASE_MODIFIED&flags)
return str;
8264rb_str_swapcase(
int argc,
VALUE *argv,
VALUE str)
8267 OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE;
8270 flags = check_case_options(argc, argv, flags);
8271 enc = str_true_enc(str);
8272 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return str_duplicate(
rb_cString, str);
8273 if (flags&ONIGENC_CASE_ASCII_ONLY) {
8275 rb_str_ascii_casemap(str, ret, &flags, enc);
8278 ret = rb_str_casemap(str, &flags, enc);
8283typedef unsigned char *USTR;
8287 unsigned int now, max;
8292trnext(
struct tr *t, rb_encoding *enc)
8299 if (t->p == t->pend)
return -1;
8300 if (rb_enc_ascget(t->p, t->pend, &n, enc) ==
'\\' && t->p + n < t->pend) {
8303 t->now = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
8305 if (rb_enc_ascget(t->p, t->pend, &n, enc) ==
'-' && t->p + n < t->pend) {
8307 if (t->p < t->pend) {
8308 unsigned int c = rb_enc_codepoint_len(t->p, t->pend, &n, enc);
8311 if (t->now < 0x80 && c < 0x80) {
8312 rb_raise(rb_eArgError,
8313 "invalid range \"%c-%c\" in string transliteration",
8317 rb_raise(rb_eArgError,
"invalid range in string transliteration");
8321 else if (t->now < c) {
8330 while (ONIGENC_CODE_TO_MBCLEN(enc, ++t->now) <= 0) {
8331 if (t->now == t->max) {
8336 if (t->now < t->max) {
8352 const unsigned int errc = -1;
8353 unsigned int trans[256];
8354 rb_encoding *enc, *e1, *e2;
8355 struct tr trsrc, trrepl;
8357 unsigned int c, c0, last = 0;
8358 int modify = 0, i, l;
8359 unsigned char *s, *send;
8361 int singlebyte = single_byte_optimizable(str);
8365#define CHECK_IF_ASCII(c) \
8366 (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \
8367 (cr = ENC_CODERANGE_VALID) : 0)
8371 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
8372 if (RSTRING_LEN(repl) == 0) {
8373 return rb_str_delete_bang(1, &src, str);
8377 e1 = rb_enc_check(str, src);
8378 e2 = rb_enc_check(str, repl);
8383 enc = rb_enc_check(src, repl);
8385 trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src);
8386 if (RSTRING_LEN(src) > 1 &&
8387 rb_enc_ascget(trsrc.p, trsrc.pend, &l, enc) ==
'^' &&
8388 trsrc.p + l < trsrc.pend) {
8392 trrepl.p = RSTRING_PTR(repl);
8393 trrepl.pend = trrepl.p + RSTRING_LEN(repl);
8394 trsrc.gen = trrepl.gen = 0;
8395 trsrc.now = trrepl.now = 0;
8396 trsrc.max = trrepl.max = 0;
8399 for (i=0; i<256; i++) {
8402 while ((c = trnext(&trsrc, enc)) != errc) {
8407 if (!hash) hash = rb_hash_new();
8411 while ((c = trnext(&trrepl, enc)) != errc)
8414 for (i=0; i<256; i++) {
8415 if (trans[i] != errc) {
8423 for (i=0; i<256; i++) {
8426 while ((c = trnext(&trsrc, enc)) != errc) {
8427 r = trnext(&trrepl, enc);
8428 if (r == errc) r = trrepl.now;
8431 if (rb_enc_codelen(r, enc) != 1) singlebyte = 0;
8434 if (!hash) hash = rb_hash_new();
8442 str_modify_keep_cr(str);
8443 s = (
unsigned char *)RSTRING_PTR(str); send = (
unsigned char *)RSTRING_END(str);
8444 termlen = rb_enc_mbminlen(enc);
8447 long offset, max = RSTRING_LEN(str);
8448 unsigned int save = -1;
8449 unsigned char *buf =
ALLOC_N(
unsigned char, max + termlen), *t = buf;
8454 int r = rb_enc_precise_mbclen((
char *)s, (
char *)send, e1);
8457 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(e1));
8460 c0 = c = rb_enc_mbc_to_codepoint((
char *)s, (
char *)send, e1);
8462 tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
8471 if (cflag) c = last;
8474 else if (cflag) c = errc;
8480 if (c != (
unsigned int)-1) {
8486 tlen = rb_enc_codelen(c, enc);
8492 if (enc != e1) may_modify = 1;
8494 if ((offset = t - buf) + tlen > max) {
8495 size_t MAYBE_UNUSED(old) = max + termlen;
8496 max = offset + tlen + (send - s);
8497 SIZED_REALLOC_N(buf,
unsigned char, max + termlen, old);
8500 rb_enc_mbcput(c, t, enc);
8501 if (may_modify && memcmp(s, t, tlen) != 0) {
8507 if (!STR_EMBED_P(str)) {
8508 ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
8510 TERM_FILL((
char *)t, termlen);
8511 RSTRING(str)->as.heap.ptr = (
char *)buf;
8512 STR_SET_LEN(str, t - buf);
8513 STR_SET_NOEMBED(str);
8514 RSTRING(str)->as.heap.aux.capa = max;
8516 else if (rb_enc_mbmaxlen(enc) == 1 || (singlebyte && !hash)) {
8518 c = (
unsigned char)*s;
8519 if (trans[c] != errc) {
8536 long offset, max = (long)((send - s) * 1.2);
8537 unsigned char *buf =
ALLOC_N(
unsigned char, max + termlen), *t = buf;
8542 int r = rb_enc_precise_mbclen((
char *)s, (
char *)send, e1);
8545 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(e1));
8548 c0 = c = rb_enc_mbc_to_codepoint((
char *)s, (
char *)send, e1);
8550 tlen = enc == e1 ? clen : rb_enc_codelen(c, enc);
8558 if (cflag) c = last;
8561 else if (cflag) c = errc;
8565 c = cflag ? last : errc;
8568 tlen = rb_enc_codelen(c, enc);
8573 if (enc != e1) may_modify = 1;
8575 if ((offset = t - buf) + tlen > max) {
8576 size_t MAYBE_UNUSED(old) = max + termlen;
8577 max = offset + tlen + (long)((send - s) * 1.2);
8578 SIZED_REALLOC_N(buf,
unsigned char, max + termlen, old);
8582 rb_enc_mbcput(c, t, enc);
8583 if (may_modify && memcmp(s, t, tlen) != 0) {
8591 if (!STR_EMBED_P(str)) {
8592 ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str));
8594 TERM_FILL((
char *)t, termlen);
8595 RSTRING(str)->as.heap.ptr = (
char *)buf;
8596 STR_SET_LEN(str, t - buf);
8597 STR_SET_NOEMBED(str);
8598 RSTRING(str)->as.heap.aux.capa = max;
8604 rb_enc_associate(str, enc);
8626 return tr_trans(str, src, repl, 0);
8671 tr_trans(str, src, repl, 0);
8675#define TR_TABLE_MAX (UCHAR_MAX+1)
8676#define TR_TABLE_SIZE (TR_TABLE_MAX+1)
8678tr_setup_table(
VALUE str,
char stable[TR_TABLE_SIZE],
int first,
8679 VALUE *tablep,
VALUE *ctablep, rb_encoding *enc)
8681 const unsigned int errc = -1;
8682 char buf[TR_TABLE_MAX];
8685 VALUE table = 0, ptable = 0;
8686 int i, l, cflag = 0;
8688 tr.p = RSTRING_PTR(str);
tr.pend =
tr.p + RSTRING_LEN(str);
8689 tr.gen =
tr.now =
tr.max = 0;
8691 if (RSTRING_LEN(str) > 1 && rb_enc_ascget(
tr.p,
tr.pend, &l, enc) ==
'^') {
8696 for (i=0; i<TR_TABLE_MAX; i++) {
8699 stable[TR_TABLE_MAX] = cflag;
8701 else if (stable[TR_TABLE_MAX] && !cflag) {
8702 stable[TR_TABLE_MAX] = 0;
8704 for (i=0; i<TR_TABLE_MAX; i++) {
8708 while ((c = trnext(&
tr, enc)) != errc) {
8709 if (c < TR_TABLE_MAX) {
8710 buf[(
unsigned char)c] = !cflag;
8715 if (!table && (first || *tablep || stable[TR_TABLE_MAX])) {
8718 table = ptable ? ptable : rb_hash_new();
8722 table = rb_hash_new();
8727 if (table && (!ptable || (cflag ^ !
NIL_P(rb_hash_aref(ptable, key))))) {
8728 rb_hash_aset(table, key,
Qtrue);
8732 for (i=0; i<TR_TABLE_MAX; i++) {
8733 stable[i] = stable[i] && buf[i];
8735 if (!table && !cflag) {
8742tr_find(
unsigned int c,
const char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
8744 if (c < TR_TABLE_MAX) {
8745 return table[c] != 0;
8751 if (!
NIL_P(rb_hash_lookup(del, v)) &&
8752 (!nodel ||
NIL_P(rb_hash_lookup(nodel, v)))) {
8756 else if (nodel && !
NIL_P(rb_hash_lookup(nodel, v))) {
8759 return table[TR_TABLE_MAX] ? TRUE : FALSE;
8774rb_str_delete_bang(
int argc,
VALUE *argv,
VALUE str)
8776 char squeez[TR_TABLE_SIZE];
8777 rb_encoding *enc = 0;
8779 VALUE del = 0, nodel = 0;
8781 int i, ascompat, cr;
8783 if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str))
return Qnil;
8785 for (i=0; i<argc; i++) {
8789 enc = rb_enc_check(str, s);
8790 tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
8793 str_modify_keep_cr(str);
8794 ascompat = rb_enc_asciicompat(enc);
8795 s = t = RSTRING_PTR(str);
8796 send = RSTRING_END(str);
8802 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
8813 c = rb_enc_codepoint_len(s, send, &clen, enc);
8815 if (tr_find(c, squeez, del, nodel)) {
8819 if (t != s) rb_enc_mbcput(c, t, enc);
8826 TERM_FILL(t, TERM_LEN(str));
8827 STR_SET_LEN(str, t - RSTRING_PTR(str));
8830 if (modify)
return str;
8844rb_str_delete(
int argc,
VALUE *argv,
VALUE str)
8847 rb_str_delete_bang(argc, argv, str);
8865rb_str_squeeze_bang(
int argc,
VALUE *argv,
VALUE str)
8867 char squeez[TR_TABLE_SIZE];
8868 rb_encoding *enc = 0;
8869 VALUE del = 0, nodel = 0;
8870 unsigned char *s, *send, *t;
8872 int ascompat, singlebyte = single_byte_optimizable(str);
8876 enc = STR_ENC_GET(str);
8879 for (i=0; i<argc; i++) {
8883 enc = rb_enc_check(str, s);
8884 if (singlebyte && !single_byte_optimizable(s))
8886 tr_setup_table(s, squeez, i==0, &del, &nodel, enc);
8890 str_modify_keep_cr(str);
8891 s = t = (
unsigned char *)RSTRING_PTR(str);
8892 if (!s || RSTRING_LEN(str) == 0)
return Qnil;
8893 send = (
unsigned char *)RSTRING_END(str);
8895 ascompat = rb_enc_asciicompat(enc);
8899 unsigned int c = *s++;
8900 if (c != save || (argc > 0 && !squeez[c])) {
8910 if (ascompat && (c = *s) < 0x80) {
8911 if (c != save || (argc > 0 && !squeez[c])) {
8917 c = rb_enc_codepoint_len((
char *)s, (
char *)send, &clen, enc);
8919 if (c != save || (argc > 0 && !tr_find(c, squeez, del, nodel))) {
8920 if (t != s) rb_enc_mbcput(c, t, enc);
8929 TERM_FILL((
char *)t, TERM_LEN(str));
8930 if ((
char *)t - RSTRING_PTR(str) != RSTRING_LEN(str)) {
8931 STR_SET_LEN(str, (
char *)t - RSTRING_PTR(str));
8935 if (modify)
return str;
8949rb_str_squeeze(
int argc,
VALUE *argv,
VALUE str)
8952 rb_str_squeeze_bang(argc, argv, str);
8972 return tr_trans(str, src, repl, 1);
9000 tr_trans(str, src, repl, 1);
9013rb_str_count(
int argc,
VALUE *argv,
VALUE str)
9015 char table[TR_TABLE_SIZE];
9016 rb_encoding *enc = 0;
9017 VALUE del = 0, nodel = 0, tstr;
9027 enc = rb_enc_check(str, tstr);
9030 if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) &&
9031 (ptstr = RSTRING_PTR(tstr),
9032 ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (
const unsigned char *)ptstr, (
const unsigned char *)ptstr+1)) &&
9033 !is_broken_string(str)) {
9035 unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc);
9037 s = RSTRING_PTR(str);
9038 if (!s || RSTRING_LEN(str) == 0)
return INT2FIX(0);
9039 send = RSTRING_END(str);
9041 if (*(
unsigned char*)s++ == c) n++;
9047 tr_setup_table(tstr, table, TRUE, &del, &nodel, enc);
9048 for (i=1; i<argc; i++) {
9051 enc = rb_enc_check(str, tstr);
9052 tr_setup_table(tstr, table, FALSE, &del, &nodel, enc);
9055 s = RSTRING_PTR(str);
9056 if (!s || RSTRING_LEN(str) == 0)
return INT2FIX(0);
9057 send = RSTRING_END(str);
9058 ascompat = rb_enc_asciicompat(enc);
9062 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
9070 c = rb_enc_codepoint_len(s, send, &clen, enc);
9071 if (tr_find(c, table, del, nodel)) {
9082rb_fs_check(
VALUE val)
9086 if (
NIL_P(val))
return 0;
9091static const char isspacetable[256] = {
9092 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
9093 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9094 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9095 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9096 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9097 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9098 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9099 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9100 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9106 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9107 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
9110#define ascii_isspace(c) isspacetable[(unsigned char)(c)]
9113split_string(
VALUE result,
VALUE str,
long beg,
long len,
long empty_count)
9115 if (empty_count >= 0 &&
len == 0) {
9116 return empty_count + 1;
9118 if (empty_count > 0) {
9123 }
while (--empty_count > 0);
9127 rb_yield(str_new_empty_String(str));
9128 }
while (--empty_count > 0);
9142 SPLIT_TYPE_AWK, SPLIT_TYPE_STRING, SPLIT_TYPE_REGEXP, SPLIT_TYPE_CHARS
9146literal_split_pattern(
VALUE spat, split_type_t default_type)
9148 rb_encoding *enc = STR_ENC_GET(spat);
9154 return SPLIT_TYPE_CHARS;
9156 else if (rb_enc_asciicompat(enc)) {
9157 if (
len == 1 &&
ptr[0] ==
' ') {
9158 return SPLIT_TYPE_AWK;
9163 if (rb_enc_ascget(
ptr,
ptr +
len, &l, enc) ==
' ' &&
len == l) {
9164 return SPLIT_TYPE_AWK;
9167 return default_type;
9180rb_str_split_m(
int argc,
VALUE *argv,
VALUE str)
9185 split_type_t split_type;
9186 long beg, end, i = 0, empty_count = -1;
9191 if (
rb_scan_args(argc, argv,
"02", &spat, &limit) == 2) {
9193 if (lim <= 0) limit =
Qnil;
9194 else if (lim == 1) {
9195 if (RSTRING_LEN(str) == 0)
9206 if (
NIL_P(limit) && !lim) empty_count = 0;
9208 enc = STR_ENC_GET(str);
9209 split_type = SPLIT_TYPE_REGEXP;
9211 spat = get_pat_quoted(spat, 0);
9214 split_type = SPLIT_TYPE_AWK;
9216 else if (!(spat = rb_fs_check(spat))) {
9217 rb_raise(
rb_eTypeError,
"value of $; must be String or Regexp");
9222 if (split_type != SPLIT_TYPE_AWK) {
9226 tmp = RREGEXP_SRC(spat);
9227 split_type = literal_split_pattern(tmp, SPLIT_TYPE_REGEXP);
9228 if (split_type == SPLIT_TYPE_AWK) {
9230 split_type = SPLIT_TYPE_STRING;
9235 mustnot_broken(spat);
9236 split_type = literal_split_pattern(spat, SPLIT_TYPE_STRING);
9244#define SPLIT_STR(beg, len) ( \
9245 empty_count = split_string(result, str, beg, len, empty_count), \
9246 str_mod_check(str, str_start, str_len))
9249 char *
ptr = RSTRING_PTR(str);
9250 char *
const str_start =
ptr;
9251 const long str_len = RSTRING_LEN(str);
9252 char *
const eptr = str_start + str_len;
9253 if (split_type == SPLIT_TYPE_AWK) {
9260 if (is_ascii_string(str)) {
9261 while (
ptr < eptr) {
9262 c = (
unsigned char)*
ptr++;
9264 if (ascii_isspace(c)) {
9270 if (!
NIL_P(limit) && lim <= i)
break;
9273 else if (ascii_isspace(c)) {
9274 SPLIT_STR(beg, end-beg);
9277 if (!
NIL_P(limit)) ++i;
9285 while (
ptr < eptr) {
9288 c = rb_enc_codepoint_len(
ptr, eptr, &n, enc);
9291 if (rb_isspace(c)) {
9297 if (!
NIL_P(limit) && lim <= i)
break;
9300 else if (rb_isspace(c)) {
9301 SPLIT_STR(beg, end-beg);
9304 if (!
NIL_P(limit)) ++i;
9312 else if (split_type == SPLIT_TYPE_STRING) {
9313 char *substr_start =
ptr;
9314 char *sptr = RSTRING_PTR(spat);
9315 long slen = RSTRING_LEN(spat);
9318 mustnot_broken(str);
9319 enc = rb_enc_check(str, spat);
9320 while (
ptr < eptr &&
9323 char *t = rb_enc_right_char_head(
ptr,
ptr + end, eptr, enc);
9324 if (t !=
ptr + end) {
9328 SPLIT_STR(substr_start - str_start, (
ptr+end) - substr_start);
9329 str_mod_check(spat, sptr, slen);
9332 if (!
NIL_P(limit) && lim <= ++i)
break;
9334 beg =
ptr - str_start;
9336 else if (split_type == SPLIT_TYPE_CHARS) {
9340 mustnot_broken(str);
9341 enc = rb_enc_get(str);
9342 while (
ptr < eptr &&
9343 (n = rb_enc_precise_mbclen(
ptr, eptr, enc)) > 0) {
9344 SPLIT_STR(
ptr - str_start, n);
9346 if (!
NIL_P(limit) && lim <= ++i)
break;
9348 beg =
ptr - str_start;
9352 long len = RSTRING_LEN(str);
9360 (match ? (rb_match_unbusy(match),
rb_backref_set(match)) : (void)0)) {
9363 regs = RMATCH_REGS(match);
9365 if (start == end && BEG(0) == END(0)) {
9370 else if (last_null == 1) {
9371 SPLIT_STR(beg, rb_enc_fast_mbclen(
ptr+beg, eptr, enc));
9378 start += rb_enc_fast_mbclen(
ptr+start,eptr,enc);
9384 SPLIT_STR(beg, end-beg);
9385 beg = start = END(0);
9389 for (idx=1; idx < regs->num_regs; idx++) {
9390 if (BEG(idx) == -1)
continue;
9391 SPLIT_STR(BEG(idx), END(idx)-BEG(idx));
9393 if (!
NIL_P(limit) && lim <= ++i)
break;
9395 if (match) rb_match_unbusy(match);
9397 if (RSTRING_LEN(str) > 0 && (!
NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
9398 SPLIT_STR(beg, RSTRING_LEN(str)-beg);
9401 return result ? result : str;
9411 return rb_str_split_m(1, &sep, str);
9414#define WANTARRAY(m, size) (!rb_block_given_p() ? rb_ary_new_capa(size) : 0)
9429#define ENUM_ELEM(ary, e) enumerator_element(ary, e)
9432chomp_newline(
const char *p,
const char *e, rb_encoding *enc)
9434 const char *prev = rb_enc_prev_char(p, e, e, enc);
9435 if (rb_enc_is_newline(prev, e, enc)) {
9437 prev = rb_enc_prev_char(p, e, e, enc);
9438 if (prev && rb_enc_ascget(prev, e, NULL, enc) ==
'\r')
9450 RSTRING_LEN(rs) != 1 ||
9451 RSTRING_PTR(rs)[0] !=
'\n')) {
9457#define rb_rs get_rs()
9464 const char *
ptr, *pend, *subptr, *subend, *rsptr, *hit, *adjusted;
9465 long pos,
len, rslen;
9471 static ID keywords[1];
9473 keywords[0] = rb_intern_const(
"chomp");
9476 chomp = (!UNDEF_P(chomp) &&
RTEST(chomp));
9480 if (!ENUM_ELEM(ary, str)) {
9488 if (!RSTRING_LEN(str))
goto end;
9490 ptr = subptr = RSTRING_PTR(str);
9491 pend = RSTRING_END(str);
9492 len = RSTRING_LEN(str);
9494 rslen = RSTRING_LEN(rs);
9497 enc = rb_enc_get(str);
9499 enc = rb_enc_check(str, rs);
9504 const char *eol = NULL;
9506 while (subend < pend) {
9507 long chomp_rslen = 0;
9509 if (rb_enc_ascget(subend, pend, &n, enc) !=
'\r')
9511 rslen = n + rb_enc_mbclen(subend + n, pend, enc);
9512 if (rb_enc_is_newline(subend + n, pend, enc)) {
9513 if (eol == subend)
break;
9517 chomp_rslen = -rslen;
9521 if (!subptr) subptr = subend;
9525 }
while (subend < pend);
9527 if (rslen == 0) chomp_rslen = 0;
9529 subend - subptr + (chomp ? chomp_rslen : rslen));
9530 if (ENUM_ELEM(ary, line)) {
9531 str_mod_check(str,
ptr,
len);
9533 subptr = eol = NULL;
9538 rsptr = RSTRING_PTR(rs);
9539 if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) &&
9540 rb_enc_is_newline(rsptr, rsptr + RSTRING_LEN(rs), enc)) {
9548 rsptr = RSTRING_PTR(rs);
9549 rslen = RSTRING_LEN(rs);
9552 while (subptr < pend) {
9553 pos =
rb_memsearch(rsptr, rslen, subptr, pend - subptr, enc);
9556 adjusted = rb_enc_right_char_head(subptr, hit, pend, enc);
9557 if (hit != adjusted) {
9561 subend = hit += rslen;
9564 subend = chomp_newline(subptr, subend, enc);
9571 if (ENUM_ELEM(ary, line)) {
9572 str_mod_check(str,
ptr,
len);
9573 str_mod_check(rs, rsptr, rslen);
9578 if (subptr < pend) {
9581 pend = chomp_newline(subptr, pend, enc);
9583 else if (pend - subptr >= rslen &&
9584 memcmp(pend - rslen, rsptr, rslen) == 0) {
9589 ENUM_ELEM(ary, line);
9610rb_str_each_line(
int argc,
VALUE *argv,
VALUE str)
9613 return rb_str_enumerate_lines(argc, argv, str, 0);
9668rb_str_lines(
int argc,
VALUE *argv,
VALUE str)
9670 VALUE ary = WANTARRAY(
"lines", 0);
9671 return rb_str_enumerate_lines(argc, argv, str, ary);
9685 for (i=0; i<RSTRING_LEN(str); i++) {
9686 ENUM_ELEM(ary,
INT2FIX((
unsigned char)RSTRING_PTR(str)[i]));
9704rb_str_each_byte(
VALUE str)
9707 return rb_str_enumerate_bytes(str, 0);
9719rb_str_bytes(
VALUE str)
9721 VALUE ary = WANTARRAY(
"bytes", RSTRING_LEN(str));
9722 return rb_str_enumerate_bytes(str, ary);
9740 ptr = RSTRING_PTR(str);
9741 len = RSTRING_LEN(str);
9742 enc = rb_enc_get(str);
9745 for (i = 0; i <
len; i += n) {
9746 n = rb_enc_fast_mbclen(
ptr + i,
ptr +
len, enc);
9751 for (i = 0; i <
len; i += n) {
9752 n = rb_enc_mbclen(
ptr + i,
ptr +
len, enc);
9773rb_str_each_char(
VALUE str)
9776 return rb_str_enumerate_chars(str, 0);
9788rb_str_chars(
VALUE str)
9791 return rb_str_enumerate_chars(str, ary);
9795rb_str_enumerate_codepoints(
VALUE str,
VALUE ary)
9800 const char *
ptr, *end;
9803 if (single_byte_optimizable(str))
9804 return rb_str_enumerate_bytes(str, ary);
9807 ptr = RSTRING_PTR(str);
9808 end = RSTRING_END(str);
9809 enc = STR_ENC_GET(str);
9812 c = rb_enc_codepoint_len(
ptr, end, &n, enc);
9833rb_str_each_codepoint(
VALUE str)
9836 return rb_str_enumerate_codepoints(str, 0);
9848rb_str_codepoints(
VALUE str)
9851 return rb_str_enumerate_codepoints(str, ary);
9855get_reg_grapheme_cluster(rb_encoding *enc)
9857 int encidx = rb_enc_to_index(enc);
9859 const OnigUChar source_ascii[] =
"\\X";
9860 const OnigUChar *source = source_ascii;
9861 size_t source_len =
sizeof(source_ascii) - 1;
9864#define CHARS_16BE(x) (OnigUChar)((x)>>8), (OnigUChar)(x)
9865#define CHARS_16LE(x) (OnigUChar)(x), (OnigUChar)((x)>>8)
9866#define CHARS_32BE(x) CHARS_16BE((x)>>16), CHARS_16BE(x)
9867#define CHARS_32LE(x) CHARS_16LE(x), CHARS_16LE((x)>>16)
9868#define CASE_UTF(e) \
9869 case ENCINDEX_UTF_##e: { \
9870 static const OnigUChar source_UTF_##e[] = {CHARS_##e('\\'), CHARS_##e('X')}; \
9871 source = source_UTF_##e; \
9872 source_len = sizeof(source_UTF_##e); \
9875 CASE_UTF(16BE); CASE_UTF(16LE); CASE_UTF(32BE); CASE_UTF(32LE);
9883 regex_t *reg_grapheme_cluster;
9885 int r = onig_new(®_grapheme_cluster, source, source + source_len,
9886 ONIG_OPTION_DEFAULT, enc, OnigDefaultSyntax, &einfo);
9888 UChar message[ONIG_MAX_ERROR_MESSAGE_LEN];
9889 onig_error_code_to_str(message, r, &einfo);
9890 rb_fatal(
"cannot compile grapheme cluster regexp: %s", (
char *)message);
9893 return reg_grapheme_cluster;
9897get_cached_reg_grapheme_cluster(rb_encoding *enc)
9899 int encidx = rb_enc_to_index(enc);
9900 static regex_t *reg_grapheme_cluster_utf8 = NULL;
9902 if (encidx == rb_utf8_encindex()) {
9903 if (!reg_grapheme_cluster_utf8) {
9904 reg_grapheme_cluster_utf8 = get_reg_grapheme_cluster(enc);
9907 return reg_grapheme_cluster_utf8;
9916 size_t grapheme_cluster_count = 0;
9917 rb_encoding *enc = get_encoding(str);
9918 const char *
ptr, *end;
9920 if (!rb_enc_unicode_p(enc)) {
9924 bool cached_reg_grapheme_cluster =
true;
9925 regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc);
9926 if (!reg_grapheme_cluster) {
9927 reg_grapheme_cluster = get_reg_grapheme_cluster(enc);
9928 cached_reg_grapheme_cluster =
false;
9931 ptr = RSTRING_PTR(str);
9932 end = RSTRING_END(str);
9935 OnigPosition
len = onig_match(reg_grapheme_cluster,
9936 (
const OnigUChar *)
ptr, (
const OnigUChar *)end,
9937 (
const OnigUChar *)
ptr, NULL, 0);
9938 if (
len <= 0)
break;
9939 grapheme_cluster_count++;
9943 if (!cached_reg_grapheme_cluster) {
9944 onig_free(reg_grapheme_cluster);
9947 return SIZET2NUM(grapheme_cluster_count);
9951rb_str_enumerate_grapheme_clusters(
VALUE str,
VALUE ary)
9954 rb_encoding *enc = get_encoding(str);
9955 const char *ptr0, *
ptr, *end;
9957 if (!rb_enc_unicode_p(enc)) {
9958 return rb_str_enumerate_chars(str, ary);
9963 bool cached_reg_grapheme_cluster =
true;
9964 regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc);
9965 if (!reg_grapheme_cluster) {
9966 reg_grapheme_cluster = get_reg_grapheme_cluster(enc);
9967 cached_reg_grapheme_cluster =
false;
9970 ptr0 =
ptr = RSTRING_PTR(str);
9971 end = RSTRING_END(str);
9974 OnigPosition
len = onig_match(reg_grapheme_cluster,
9975 (
const OnigUChar *)
ptr, (
const OnigUChar *)end,
9976 (
const OnigUChar *)
ptr, NULL, 0);
9977 if (
len <= 0)
break;
9982 if (!cached_reg_grapheme_cluster) {
9983 onig_free(reg_grapheme_cluster);
10003rb_str_each_grapheme_cluster(
VALUE str)
10006 return rb_str_enumerate_grapheme_clusters(str, 0);
10018rb_str_grapheme_clusters(
VALUE str)
10021 return rb_str_enumerate_grapheme_clusters(str, ary);
10025chopped_length(
VALUE str)
10027 rb_encoding *enc = STR_ENC_GET(str);
10028 const char *p, *p2, *beg, *end;
10030 beg = RSTRING_PTR(str);
10031 end = beg + RSTRING_LEN(str);
10032 if (beg >= end)
return 0;
10033 p = rb_enc_prev_char(beg, end, end, enc);
10035 if (p > beg && rb_enc_ascget(p, end, 0, enc) ==
'\n') {
10036 p2 = rb_enc_prev_char(beg, p, end, enc);
10037 if (p2 && rb_enc_ascget(p2, end, 0, enc) ==
'\r') p = p2;
10055rb_str_chop_bang(
VALUE str)
10057 str_modify_keep_cr(str);
10058 if (RSTRING_LEN(str) > 0) {
10060 len = chopped_length(str);
10061 STR_SET_LEN(str,
len);
10062 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
10081rb_str_chop(
VALUE str)
10087smart_chomp(
VALUE str,
const char *e,
const char *p)
10089 rb_encoding *enc = rb_enc_get(str);
10090 if (rb_enc_mbminlen(enc) > 1) {
10092 if (e - p < rb_enc_mbminlen(enc))
return e - p;
10093 const char *pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc);
10094 if (rb_enc_is_newline(pp, e, enc)) {
10097 pp = e - rb_enc_mbminlen(enc);
10099 pp = rb_enc_left_char_head(p, pp, e, enc);
10100 if (rb_enc_ascget(pp, e, 0, enc) ==
'\r') {
10108 if (--e > p && *(e-1) ==
'\r') {
10125 char *pp, *e, *rsptr;
10127 char *
const p = RSTRING_PTR(str);
10128 long len = RSTRING_LEN(str);
10130 if (
len == 0)
return 0;
10133 return smart_chomp(str, e, p);
10136 enc = rb_enc_get(str);
10139 if (rb_enc_mbminlen(enc) > 1) {
10140 while (e - p >= rb_enc_mbminlen(enc)) {
10141 pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc);
10142 if (!rb_enc_is_newline(pp, e, enc))
break;
10144 pp -= rb_enc_mbminlen(enc);
10146 pp = rb_enc_left_char_head(p, pp, e, enc);
10147 if (rb_enc_ascget(pp, e, 0, enc) ==
'\r') {
10154 while (e > p && *(e-1) ==
'\n') {
10156 if (e > p && *(e-1) ==
'\r')
10162 if (rslen >
len)
return len;
10164 enc = rb_enc_get(rs);
10165 newline = rsptr[rslen-1];
10166 if (rslen == rb_enc_mbminlen(enc)) {
10168 if (newline ==
'\n')
10169 return smart_chomp(str, e, p);
10172 if (rb_enc_is_newline(rsptr, rsptr+rslen, enc))
10173 return smart_chomp(str, e, p);
10177 enc = rb_enc_check(str, rs);
10178 if (is_broken_string(rs)) {
10182 if (p[
len-1] == newline &&
10184 memcmp(rsptr, pp, rslen) == 0)) {
10185 if (at_char_boundary(p, pp, e, enc))
10186 return len - rslen;
10198chomp_rs(
int argc,
const VALUE *argv)
10200 rb_check_arity(argc, 0, 1);
10202 VALUE rs = argv[0];
10214 long olen = RSTRING_LEN(str);
10215 long len = chompped_length(str, rs);
10216 if (
len >= olen)
return Qnil;
10217 str_modify_keep_cr(str);
10218 STR_SET_LEN(str,
len);
10219 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
10239rb_str_chomp_bang(
int argc,
VALUE *argv,
VALUE str)
10242 str_modifiable(str);
10243 if (RSTRING_LEN(str) == 0 && argc < 2)
return Qnil;
10244 rs = chomp_rs(argc, argv);
10246 return rb_str_chomp_string(str, rs);
10259rb_str_chomp(
int argc,
VALUE *argv,
VALUE str)
10261 VALUE rs = chomp_rs(argc, argv);
10267tr_setup_table_multi(
char table[TR_TABLE_SIZE],
VALUE *tablep,
VALUE *ctablep,
10268 VALUE str,
int num_selectors,
VALUE *selectors)
10272 for (i=0; i<num_selectors; i++) {
10273 VALUE selector = selectors[i];
10277 enc = rb_enc_check(str, selector);
10278 tr_setup_table(selector, table, i==0, tablep, ctablep, enc);
10283lstrip_offset(
VALUE str,
const char *s,
const char *e, rb_encoding *enc)
10285 const char *
const start = s;
10287 if (!s || s >= e)
return 0;
10290 if (single_byte_optimizable(str)) {
10291 while (s < e && (*s ==
'\0' || ascii_isspace(*s))) s++;
10296 unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
10298 if (cc && !rb_isspace(cc))
break;
10306lstrip_offset_table(
VALUE str,
const char *s,
const char *e, rb_encoding *enc,
10307 char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
10309 const char *
const start = s;
10311 if (!s || s >= e)
return 0;
10316 unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc);
10318 if (!tr_find(cc, table, del, nodel))
break;
10337rb_str_lstrip_bang(
int argc,
VALUE *argv,
VALUE str)
10341 long olen, loffset;
10343 str_modify_keep_cr(str);
10344 enc = STR_ENC_GET(str);
10347 char table[TR_TABLE_SIZE];
10348 VALUE del = 0, nodel = 0;
10350 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10353 str_modify_keep_cr(str);
10354 enc = STR_ENC_GET(str);
10357 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
10360 loffset = lstrip_offset(str, start, start+olen, enc);
10364 long len = olen-loffset;
10365 s = start + loffset;
10366 memmove(start, s,
len);
10367 STR_SET_LEN(str,
len);
10368 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
10403rb_str_lstrip(
int argc,
VALUE *argv,
VALUE str)
10410 char table[TR_TABLE_SIZE];
10411 VALUE del = 0, nodel = 0;
10413 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10418 loffset = lstrip_offset_table(str, start, start+
len, STR_ENC_GET(str), table, del, nodel);
10421 loffset = lstrip_offset(str, start, start+
len, STR_ENC_GET(str));
10423 if (loffset <= 0)
return str_duplicate(
rb_cString, str);
10428rstrip_offset(
VALUE str,
const char *s,
const char *e, rb_encoding *enc)
10432 rb_str_check_dummy_enc(enc);
10436 if (!s || s >= e)
return 0;
10440 if (single_byte_optimizable(str)) {
10442 while (s < t && ((c = *(t-1)) ==
'\0' || ascii_isspace(c))) t--;
10447 while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
10448 unsigned int c = rb_enc_codepoint(tp, e, enc);
10449 if (c && !rb_isspace(c))
break;
10457rstrip_offset_table(
VALUE str,
const char *s,
const char *e, rb_encoding *enc,
10458 char table[TR_TABLE_SIZE],
VALUE del,
VALUE nodel)
10463 rb_str_check_dummy_enc(enc);
10467 if (!s || s >= e)
return 0;
10471 while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) {
10472 unsigned int c = rb_enc_codepoint(tp, e, enc);
10473 if (!tr_find(c, table, del, nodel))
break;
10493rb_str_rstrip_bang(
int argc,
VALUE *argv,
VALUE str)
10497 long olen, roffset;
10499 str_modify_keep_cr(str);
10500 enc = STR_ENC_GET(str);
10503 char table[TR_TABLE_SIZE];
10504 VALUE del = 0, nodel = 0;
10506 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10509 str_modify_keep_cr(str);
10510 enc = STR_ENC_GET(str);
10513 roffset = rstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
10516 roffset = rstrip_offset(str, start, start+olen, enc);
10519 long len = olen - roffset;
10521 STR_SET_LEN(str,
len);
10522 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
10556rb_str_rstrip(
int argc,
VALUE *argv,
VALUE str)
10560 long olen, roffset;
10562 enc = STR_ENC_GET(str);
10565 char table[TR_TABLE_SIZE];
10566 VALUE del = 0, nodel = 0;
10568 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10571 enc = STR_ENC_GET(str);
10574 roffset = rstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
10577 roffset = rstrip_offset(str, start, start+olen, enc);
10579 if (roffset <= 0)
return str_duplicate(
rb_cString, str);
10597rb_str_strip_bang(
int argc,
VALUE *argv,
VALUE str)
10600 long olen, loffset, roffset;
10603 str_modify_keep_cr(str);
10604 enc = STR_ENC_GET(str);
10608 char table[TR_TABLE_SIZE];
10609 VALUE del = 0, nodel = 0;
10611 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10614 str_modify_keep_cr(str);
10615 enc = STR_ENC_GET(str);
10618 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
10619 roffset = rstrip_offset_table(str, start+loffset, start+olen, enc, table, del, nodel);
10622 loffset = lstrip_offset(str, start, start+olen, enc);
10623 roffset = rstrip_offset(str, start+loffset, start+olen, enc);
10626 if (loffset > 0 || roffset > 0) {
10627 long len = olen-roffset;
10630 memmove(start, start + loffset,
len);
10632 STR_SET_LEN(str,
len);
10633 TERM_FILL(start+
len, rb_enc_mbminlen(enc));
10668rb_str_strip(
int argc,
VALUE *argv,
VALUE str)
10671 long olen, loffset, roffset;
10672 rb_encoding *enc = STR_ENC_GET(str);
10677 char table[TR_TABLE_SIZE];
10678 VALUE del = 0, nodel = 0;
10680 tr_setup_table_multi(table, &del, &nodel, str, argc, argv);
10683 enc = STR_ENC_GET(str);
10686 loffset = lstrip_offset_table(str, start, start+olen, enc, table, del, nodel);
10687 roffset = rstrip_offset_table(str, start+loffset, start+olen, enc, table, del, nodel);
10690 loffset = lstrip_offset(str, start, start+olen, enc);
10691 roffset = rstrip_offset(str, start+loffset, start+olen, enc);
10694 if (loffset <= 0 && roffset <= 0)
return str_duplicate(
rb_cString, str);
10699scan_once(
VALUE str,
VALUE pat,
long *start,
int set_backref_str)
10702 long end, pos = rb_pat_search(pat, str, *start, set_backref_str);
10708 end = pos + RSTRING_LEN(pat);
10712 regs = RMATCH_REGS(match);
10718 rb_encoding *enc = STR_ENC_GET(str);
10722 if (RSTRING_LEN(str) > end)
10723 *start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end,
10724 RSTRING_END(str), enc);
10732 if (!regs || regs->num_regs == 1) {
10738 for (
int i = 1; i < regs->num_regs; i++) {
10769 long last = -1, prev = 0;
10770 char *p = RSTRING_PTR(str);
long len = RSTRING_LEN(str);
10772 pat = get_pat_quoted(pat, 1);
10773 mustnot_broken(str);
10777 while (!
NIL_P(result = scan_once(str, pat, &start, 0))) {
10782 if (last >= 0) rb_pat_search(pat, str, last, 1);
10787 while (!
NIL_P(result = scan_once(str, pat, &start, 1))) {
10791 str_mod_check(str, p,
len);
10793 if (last >= 0) rb_pat_search(pat, str, last, 1);
10845rb_str_hex(
VALUE str)
10847 return rb_str_to_inum(str, 16, FALSE);
10931rb_str_oct(
VALUE str)
10933 return rb_str_to_inum(str, -8, FALSE);
10936#ifndef HAVE_CRYPT_R
10941 rb_nativethread_lock_t lock;
10942} crypt_mutex = {PTHREAD_MUTEX_INITIALIZER};
11011# define CRYPT_END() ALLOCV_END(databuf)
11014 extern char *crypt(
const char *,
const char *);
11015# define CRYPT_END() rb_nativethread_lock_unlock(&crypt_mutex.lock)
11018 const char *s, *saltp;
11021 char salt_8bit_clean[3];
11025 mustnot_wchar(str);
11026 mustnot_wchar(salt);
11028 saltp = RSTRING_PTR(salt);
11029 if (RSTRING_LEN(salt) < 2 || !saltp[0] || !saltp[1]) {
11030 rb_raise(rb_eArgError,
"salt too short (need >=2 bytes)");
11034 if (!ISASCII((
unsigned char)saltp[0]) || !ISASCII((
unsigned char)saltp[1])) {
11035 salt_8bit_clean[0] = saltp[0] & 0x7f;
11036 salt_8bit_clean[1] = saltp[1] & 0x7f;
11037 salt_8bit_clean[2] =
'\0';
11038 saltp = salt_8bit_clean;
11043# ifdef HAVE_STRUCT_CRYPT_DATA_INITIALIZED
11044 data->initialized = 0;
11046 res = crypt_r(s, saltp, data);
11049 res = crypt(s, saltp);
11064 size_t res_size = strlen(res)+1;
11065 tmp_buf =
ALLOCA_N(
char, res_size);
11066 memcpy(tmp_buf, res, res_size);
11088 c = rb_enc_codepoint(RSTRING_PTR(s), RSTRING_END(s), STR_ENC_GET(s));
11103 char *
ptr, *p, *pend;
11106 unsigned long sum0 = 0;
11108 if (rb_check_arity(argc, 0, 1) && (bits =
NUM2INT(argv[0])) < 0) {
11111 ptr = p = RSTRING_PTR(str);
11112 len = RSTRING_LEN(str);
11118 str_mod_check(str,
ptr,
len);
11121 sum0 += (
unsigned char)*p;
11132 if (bits < (
int)
sizeof(
long)*CHAR_BIT) {
11133 sum0 &= (((
unsigned long)1)<<bits)-1;
11153rb_str_justify(
int argc,
VALUE *argv,
VALUE str,
char jflag)
11157 long width,
len, flen = 1, fclen = 1;
11160 const char *f =
" ";
11161 long n, size, llen, rlen, llen2 = 0, rlen2 = 0;
11163 int singlebyte = 1, cr;
11167 enc = STR_ENC_GET(str);
11171 enc = rb_enc_check(str, pad);
11172 f = RSTRING_PTR(pad);
11173 flen = RSTRING_LEN(pad);
11174 fclen = str_strlen(pad, enc);
11175 singlebyte = single_byte_optimizable(pad);
11176 if (flen == 0 || fclen == 0) {
11177 rb_raise(rb_eArgError,
"zero width padding");
11180 termlen = rb_enc_mbminlen(enc);
11181 len = str_strlen(str, enc);
11182 if (width < 0 || len >= width)
return str_duplicate(
rb_cString, str);
11184 llen = (jflag ==
'l') ? 0 : ((jflag ==
'r') ? n : n/2);
11188 llen2 = str_offset(f, f + flen, llen % fclen, enc, singlebyte);
11189 rlen2 = str_offset(f, f + flen, rlen % fclen, enc, singlebyte);
11191 size = RSTRING_LEN(str);
11192 if ((
len = llen / fclen + rlen / fclen) >= LONG_MAX / flen ||
11193 (
len *= flen) >= LONG_MAX - llen2 - rlen2 ||
11194 (
len += llen2 + rlen2) >= LONG_MAX - size) {
11195 rb_raise(rb_eArgError,
"argument too big");
11199 p = RSTRING_PTR(res);
11201 memset(p, *f, llen);
11205 while (llen >= fclen) {
11211 memcpy(p, f, llen2);
11215 memcpy(p, RSTRING_PTR(str), size);
11218 memset(p, *f, rlen);
11222 while (rlen >= fclen) {
11228 memcpy(p, f, rlen2);
11232 TERM_FILL(p, termlen);
11233 STR_SET_LEN(res, p-RSTRING_PTR(res));
11254rb_str_ljust(
int argc,
VALUE *argv,
VALUE str)
11256 return rb_str_justify(argc, argv, str,
'l');
11268rb_str_rjust(
int argc,
VALUE *argv,
VALUE str)
11270 return rb_str_justify(argc, argv, str,
'r');
11283rb_str_center(
int argc,
VALUE *argv,
VALUE str)
11285 return rb_str_justify(argc, argv, str,
'c');
11301 sep = get_pat_quoted(sep, 0);
11313 pos = rb_str_index(str, sep, 0);
11314 if (pos < 0)
goto failed;
11317 long rpos = pos + RSTRING_LEN(sep);
11318 if (rpos > RSTRING_LEN(str))
goto failed;
11324 return rb_ary_new3(3, str_duplicate(
rb_cString, str), str_new_empty_String(str), str_new_empty_String(str));
11340 sep = get_pat_quoted(sep, 0);
11342 pos = RSTRING_LEN(str);
11355 pos = rb_str_rindex(str, sep, pos);
11361 long rpos = pos + RSTRING_LEN(sep);
11362 if (rpos > RSTRING_LEN(str))
goto failed;
11367 return rb_ary_new3(3, str_new_empty_String(str), str_new_empty_String(str), str_duplicate(
rb_cString, str));
11379rb_str_start_with(
int argc,
VALUE *argv,
VALUE str)
11383 for (i=0; i<argc; i++) {
11384 VALUE tmp = argv[i];
11386 if (rb_reg_start_with_p(tmp, str))
11390 const char *p, *s, *e;
11395 enc = rb_enc_check(str, tmp);
11396 if ((tlen = RSTRING_LEN(tmp)) == 0)
return Qtrue;
11397 if ((slen = RSTRING_LEN(str)) < tlen)
continue;
11398 p = RSTRING_PTR(str);
11401 if (!at_char_right_boundary(p, s, e, enc))
11403 if (memcmp(p, RSTRING_PTR(tmp), tlen) == 0)
11419rb_str_end_with(
int argc,
VALUE *argv,
VALUE str)
11423 for (i=0; i<argc; i++) {
11424 VALUE tmp = argv[i];
11425 const char *p, *s, *e;
11430 enc = rb_enc_check(str, tmp);
11431 if ((tlen = RSTRING_LEN(tmp)) == 0)
return Qtrue;
11432 if ((slen = RSTRING_LEN(str)) < tlen)
continue;
11433 p = RSTRING_PTR(str);
11436 if (!at_char_boundary(p, s, e, enc))
11438 if (memcmp(s, RSTRING_PTR(tmp), tlen) == 0)
11454deleted_prefix_length(
VALUE str,
VALUE prefix)
11456 const char *strptr, *prefixptr;
11457 long olen, prefixlen;
11458 rb_encoding *enc = rb_enc_get(str);
11462 if (!is_broken_string(prefix) ||
11463 !rb_enc_asciicompat(enc) ||
11464 !rb_enc_asciicompat(rb_enc_get(prefix))) {
11465 enc = rb_enc_check(str, prefix);
11469 prefixlen = RSTRING_LEN(prefix);
11470 if (prefixlen <= 0)
return 0;
11471 olen = RSTRING_LEN(str);
11472 if (olen < prefixlen)
return 0;
11473 strptr = RSTRING_PTR(str);
11474 prefixptr = RSTRING_PTR(prefix);
11475 if (memcmp(strptr, prefixptr, prefixlen) != 0)
return 0;
11476 if (is_broken_string(prefix)) {
11477 if (!is_broken_string(str)) {
11481 const char *strend = strptr + olen;
11482 const char *after_prefix = strptr + prefixlen;
11483 if (!at_char_right_boundary(strptr, after_prefix, strend, enc)) {
11504rb_str_delete_prefix_bang(
VALUE str,
VALUE prefix)
11507 str_modify_keep_cr(str);
11509 prefixlen = deleted_prefix_length(str, prefix);
11510 if (prefixlen <= 0)
return Qnil;
11524rb_str_delete_prefix(
VALUE str,
VALUE prefix)
11528 prefixlen = deleted_prefix_length(str, prefix);
11529 if (prefixlen <= 0)
return str_duplicate(
rb_cString, str);
11531 return rb_str_subseq(str, prefixlen, RSTRING_LEN(str) - prefixlen);
11544deleted_suffix_length(
VALUE str,
VALUE suffix)
11546 const char *strptr, *suffixptr;
11547 long olen, suffixlen;
11551 if (is_broken_string(suffix))
return 0;
11552 enc = rb_enc_check(str, suffix);
11555 suffixlen = RSTRING_LEN(suffix);
11556 if (suffixlen <= 0)
return 0;
11557 olen = RSTRING_LEN(str);
11558 if (olen < suffixlen)
return 0;
11559 strptr = RSTRING_PTR(str);
11560 suffixptr = RSTRING_PTR(suffix);
11561 const char *strend = strptr + olen;
11562 const char *before_suffix = strend - suffixlen;
11563 if (memcmp(before_suffix, suffixptr, suffixlen) != 0)
return 0;
11564 if (!at_char_boundary(strptr, before_suffix, strend, enc))
return 0;
11580rb_str_delete_suffix_bang(
VALUE str,
VALUE suffix)
11582 long olen, suffixlen,
len;
11583 str_modifiable(str);
11585 suffixlen = deleted_suffix_length(str, suffix);
11586 if (suffixlen <= 0)
return Qnil;
11588 olen = RSTRING_LEN(str);
11589 str_modify_keep_cr(str);
11590 len = olen - suffixlen;
11591 STR_SET_LEN(str,
len);
11592 TERM_FILL(&RSTRING_PTR(str)[
len], TERM_LEN(str));
11608rb_str_delete_suffix(
VALUE str,
VALUE suffix)
11612 suffixlen = deleted_suffix_length(str, suffix);
11613 if (suffixlen <= 0)
return str_duplicate(
rb_cString, str);
11615 return rb_str_subseq(str, 0, RSTRING_LEN(str) - suffixlen);
11622 rb_raise(
rb_eTypeError,
"value of %"PRIsVALUE
" must be String", rb_id2str(
id));
11628nil_setter_warning(
ID id)
11630 rb_warn_deprecated(
"non-nil '%"PRIsVALUE
"'", NULL, rb_id2str(
id));
11637 if (!
NIL_P(*var)) {
11638 nil_setter_warning(
id);
11645 val = rb_fs_check(val);
11648 "value of %"PRIsVALUE
" must be String or Regexp",
11652 nil_setter_warning(
id);
11669 str_modifiable(str);
11671 rb_encoding *encoding = rb_to_encoding(enc);
11672 int idx = rb_enc_to_index(encoding);
11679 rb_enc_associate_index(str, idx);
11703 if (STR_EMBED_P(str)) {
11704 str2 = str_alloc_embed(
rb_cString, RSTRING_LEN(str) + TERM_LEN(str));
11709 str_replace_shared_without_enc(str2, str);
11711 if (rb_enc_asciicompat(STR_ENC_GET(str))) {
11741rb_str_valid_encoding_p(
VALUE str)
11761rb_str_is_ascii_only_p(
VALUE str)
11771 static const char ellipsis[] =
"...";
11772 const long ellipsislen =
sizeof(ellipsis) - 1;
11773 rb_encoding *
const enc = rb_enc_get(str);
11774 const long blen = RSTRING_LEN(str);
11775 const char *
const p = RSTRING_PTR(str), *e = p + blen;
11776 VALUE estr, ret = 0;
11779 if (
len * rb_enc_mbminlen(enc) >= blen ||
11783 else if (
len <= ellipsislen ||
11784 !(e = rb_enc_step_back(p, e, e,
len = ellipsislen, enc))) {
11785 if (rb_enc_asciicompat(enc)) {
11787 rb_enc_associate(ret, enc);
11794 else if (ret =
rb_str_subseq(str, 0, e - p), rb_enc_asciicompat(enc)) {
11799 rb_enc_from_encoding(enc), 0,
Qnil);
11806str_compat_and_valid(
VALUE str, rb_encoding *enc)
11812 rb_raise(rb_eArgError,
"replacement must be valid byte sequence '%+"PRIsVALUE
"'", str);
11815 rb_encoding *e = STR_ENC_GET(str);
11818 rb_enc_inspect_name(enc), rb_enc_inspect_name(e));
11824static VALUE enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl,
int cr);
11829 rb_encoding *enc = STR_ENC_GET(str);
11834rb_enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl)
11837 if (enc == STR_ENC_GET(str)) {
11842 return enc_str_scrub(enc, str, repl, cr);
11846enc_str_scrub(rb_encoding *enc,
VALUE str,
VALUE repl,
int cr)
11850 const char *rep, *p, *e, *p1, *sp;
11856 rb_raise(rb_eArgError,
"both of block and replacement given");
11863 if (!
NIL_P(repl)) {
11864 repl = str_compat_and_valid(repl, enc);
11867 if (rb_enc_dummy_p(enc)) {
11870 encidx = rb_enc_to_index(enc);
11872#define DEFAULT_REPLACE_CHAR(str) do { \
11873 RBIMPL_ATTR_NONSTRING() static const char replace[sizeof(str)-1] = str; \
11874 rep = replace; replen = (int)sizeof(replace); \
11877 slen = RSTRING_LEN(str);
11878 p = RSTRING_PTR(str);
11879 e = RSTRING_END(str);
11883 if (rb_enc_asciicompat(enc)) {
11889 else if (!
NIL_P(repl)) {
11890 rep = RSTRING_PTR(repl);
11891 replen = RSTRING_LEN(repl);
11894 else if (encidx == rb_utf8_encindex()) {
11895 DEFAULT_REPLACE_CHAR(
"\xEF\xBF\xBD");
11899 DEFAULT_REPLACE_CHAR(
"?");
11904 p = search_nonascii(p, e);
11909 int ret = rb_enc_precise_mbclen(p, e, enc);
11922 long clen = rb_enc_mbmaxlen(enc);
11928 if (e - p < clen) clen = e - p;
11935 for (; clen > 1; clen--) {
11936 ret = rb_enc_precise_mbclen(q, q + clen, enc);
11947 repl =
rb_yield(rb_enc_str_new(p, clen, enc));
11948 str_mod_check(str, sp, slen);
11949 repl = str_compat_and_valid(repl, enc);
11956 p = search_nonascii(p, e);
11982 repl =
rb_yield(rb_enc_str_new(p, e-p, enc));
11983 str_mod_check(str, sp, slen);
11984 repl = str_compat_and_valid(repl, enc);
11993 long mbminlen = rb_enc_mbminlen(enc);
11997 else if (!
NIL_P(repl)) {
11998 rep = RSTRING_PTR(repl);
11999 replen = RSTRING_LEN(repl);
12001 else if (encidx == ENCINDEX_UTF_16BE) {
12002 DEFAULT_REPLACE_CHAR(
"\xFF\xFD");
12004 else if (encidx == ENCINDEX_UTF_16LE) {
12005 DEFAULT_REPLACE_CHAR(
"\xFD\xFF");
12007 else if (encidx == ENCINDEX_UTF_32BE) {
12008 DEFAULT_REPLACE_CHAR(
"\x00\x00\xFF\xFD");
12010 else if (encidx == ENCINDEX_UTF_32LE) {
12011 DEFAULT_REPLACE_CHAR(
"\xFD\xFF\x00\x00");
12014 DEFAULT_REPLACE_CHAR(
"?");
12018 int ret = rb_enc_precise_mbclen(p, e, enc);
12027 long clen = rb_enc_mbmaxlen(enc);
12031 if (e - p < clen) clen = e - p;
12032 if (clen <= mbminlen * 2) {
12037 for (; clen > mbminlen; clen-=mbminlen) {
12038 ret = rb_enc_precise_mbclen(q, q + clen, enc);
12048 repl =
rb_yield(rb_enc_str_new(p, clen, enc));
12049 str_mod_check(str, sp, slen);
12050 repl = str_compat_and_valid(repl, enc);
12075 repl =
rb_yield(rb_enc_str_new(p, e-p, enc));
12076 str_mod_check(str, sp, slen);
12077 repl = str_compat_and_valid(repl, enc);
12083 rb_enc_associate(buf, enc);
12099 VALUE repl = argc ? (rb_check_arity(argc, 0, 1), argv[0]) :
Qnil;
12118str_scrub_bang(
int argc,
VALUE *argv,
VALUE str)
12120 VALUE repl = argc ? (rb_check_arity(argc, 0, 1), argv[0]) :
Qnil;
12126static ID id_normalize;
12127static ID id_normalized_p;
12128static VALUE mUnicodeNormalize;
12131unicode_normalize_common(
int argc,
VALUE *argv,
VALUE str,
ID id)
12133 static int UnicodeNormalizeRequired = 0;
12136 if (!UnicodeNormalizeRequired) {
12137 rb_require(
"unicode_normalize/normalize.rb");
12138 UnicodeNormalizeRequired = 1;
12141 if (rb_check_arity(argc, 0, 1)) argv2[1] = argv[0];
12142 return rb_funcallv(mUnicodeNormalize,
id, argc+1, argv2);
12153rb_str_unicode_normalize(
int argc,
VALUE *argv,
VALUE str)
12155 return unicode_normalize_common(argc, argv, str, id_normalize);
12169rb_str_unicode_normalize_bang(
int argc,
VALUE *argv,
VALUE str)
12171 return rb_str_replace(str, unicode_normalize_common(argc, argv, str, id_normalize));
12198rb_str_unicode_normalized_p(
int argc,
VALUE *argv,
VALUE str)
12200 return unicode_normalize_common(argc, argv, str, id_normalized_p);
12332#define sym_equal rb_obj_equal
12335sym_printable(
const char *s,
const char *send, rb_encoding *enc)
12339 int c = rb_enc_precise_mbclen(s, send, enc);
12343 c = rb_enc_mbc_to_codepoint(s, send, enc);
12344 if (!rb_enc_isprint(c, enc))
return FALSE;
12351rb_str_symname_p(
VALUE sym)
12356 rb_encoding *resenc = rb_default_internal_encoding();
12358 if (resenc == NULL) resenc = rb_default_external_encoding();
12359 enc = STR_ENC_GET(sym);
12360 ptr = RSTRING_PTR(sym);
12361 len = RSTRING_LEN(sym);
12362 if ((resenc != enc && !rb_str_is_ascii_only_p(sym)) ||
len != (
long)strlen(
ptr) ||
12370rb_str_quote_unprintable(
VALUE str)
12375 rb_encoding *resenc;
12378 resenc = rb_default_internal_encoding();
12379 if (resenc == NULL) resenc = rb_default_external_encoding();
12380 enc = STR_ENC_GET(str);
12381 ptr = RSTRING_PTR(str);
12382 len = RSTRING_LEN(str);
12383 if ((resenc != enc && !rb_str_is_ascii_only_p(str)) ||
12385 return rb_str_escape(str);
12391rb_id_quote_unprintable(
ID id)
12393 VALUE str = rb_id2str(
id);
12394 if (!rb_str_symname_p(str)) {
12395 return rb_str_escape(str);
12413sym_inspect(
VALUE sym)
12420 if (!rb_str_symname_p(str)) {
12422 len = RSTRING_LEN(str);
12423 rb_str_resize(str,
len + 1);
12424 dest = RSTRING_PTR(str);
12425 memmove(dest + 1, dest,
len);
12428 rb_encoding *enc = STR_ENC_GET(str);
12429 VALUE orig_str = str;
12431 len = RSTRING_LEN(orig_str);
12432 str = rb_enc_str_new(0,
len + 1, enc);
12435 ptr = RSTRING_PTR(orig_str);
12436 dest = RSTRING_PTR(str);
12437 memcpy(dest + 1,
ptr,
len);
12457rb_sym_proc_call(
ID mid,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_proc)
12462 rb_raise(rb_eArgError,
"no receiver given");
12565 return rb_str_match(
rb_sym2str(sym), other);
12580sym_match_m(
int argc,
VALUE *argv,
VALUE sym)
12582 return rb_str_match_m(argc, argv,
rb_sym2str(sym));
12595sym_match_m_p(
int argc,
VALUE *argv,
VALUE sym)
12597 return rb_str_match_m_p(argc, argv, sym);
12615 return rb_str_aref_m(argc, argv,
rb_sym2str(sym));
12626sym_length(
VALUE sym)
12640sym_empty(
VALUE sym)
12674sym_downcase(
int argc,
VALUE *argv,
VALUE sym)
12690sym_capitalize(
int argc,
VALUE *argv,
VALUE sym)
12706sym_swapcase(
int argc,
VALUE *argv,
VALUE sym)
12720sym_start_with(
int argc,
VALUE *argv,
VALUE sym)
12722 return rb_str_start_with(argc, argv,
rb_sym2str(sym));
12735sym_end_with(
int argc,
VALUE *argv,
VALUE sym)
12737 return rb_str_end_with(argc, argv,
rb_sym2str(sym));
12749sym_encoding(
VALUE sym)
12755string_for_symbol(
VALUE name)
12760 rb_raise(
rb_eTypeError,
"%+"PRIsVALUE
" is not a symbol nor a string",
12774 name = string_for_symbol(name);
12775 return rb_intern_str(name);
12784 name = string_for_symbol(name);
12808 return rb_fstring(str);
12814 struct RString fake_str = {RBASIC_INIT};
12815 int encidx = ENCINDEX_US_ASCII;
12818 encidx = ENCINDEX_ASCII_8BIT;
12821 VALUE str = setup_fake_str(&fake_str,
ptr,
len, encidx);
12823 return register_fstring(str,
true,
false);
12835 if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) {
12836 rb_enc_autoload(enc);
12839 struct RString fake_str = {RBASIC_INIT};
12840 return register_fstring(rb_setup_fake_str(&fake_str,
ptr,
len, enc),
true,
false);
12844rb_enc_literal_str(
const char *
ptr,
long len, rb_encoding *enc)
12846 if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) {
12847 rb_enc_autoload(enc);
12850 struct RString fake_str = {RBASIC_INIT};
12851 VALUE str = register_fstring(rb_setup_fake_str(&fake_str,
ptr,
len, enc),
true,
true);
12862#if USE_YJIT || USE_ZJIT
12864rb_jit_str_concat_codepoint(
VALUE str,
VALUE codepoint)
12869 if (RB_LIKELY(code >= 0 && code < 0xff)) {
12870 rb_str_buf_cat_byte(str, (
char) code);
12880fstring_set_class_i(
VALUE *str,
void *data)
12884 return ST_CONTINUE;
12892 rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);
12952 sym_ascii =
ID2SYM(rb_intern_const(
"ascii"));
12953 sym_turkic =
ID2SYM(rb_intern_const(
"turkic"));
12954 sym_lithuanian =
ID2SYM(rb_intern_const(
"lithuanian"));
12955 sym_fold =
ID2SYM(rb_intern_const(
"fold"));
13049 id_normalize = rb_intern_const(
"normalize");
13050 id_normalized_p = rb_intern_const(
"normalized?");
13059 rb_gc_register_address(&
rb_fs);
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with 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.
@ RUBY_ENC_CODERANGE_7BIT
The object holds 0 to 127 inclusive and nothing else.
#define ISSPACE
@old{rb_isspace}
#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.
VALUE rb_enc_sprintf(rb_encoding *enc, const char *fmt,...)
Identical to rb_sprintf(), except it additionally takes an encoding.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_define_module(const char *name)
Defines a top-level module.
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 xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#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 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 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 FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#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 NUM2LONG
Old name of RB_NUM2LONG.
#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 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 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_eIndexError
IndexError exception.
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
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_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)
Just calls RB_OBJ_FROZEN() inside.
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_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
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 RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
Encoding conversion main routine.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
VALUE rb_enc_str_new_static(const char *ptr, long len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it takes a C string literal.
char * rb_enc_nth(const char *head, const char *tail, long nth, rb_encoding *enc)
Queries the n-th character.
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_interned_str(const char *ptr, long len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it returns a "f"string.
long rb_memsearch(const void *x, long m, const void *y, long n, rb_encoding *enc)
Looks for the passed string in the passed buffer.
long 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_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Identical to rb_str_cat(), except it additionally takes an encoding.
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_external_str_new_with_enc(const char *ptr, long len, rb_encoding *enc)
Identical to rb_external_str_new(), 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_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new_cstr(), except it returns a "f"string.
int rb_enc_symname2_p(const char *name, long 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_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...
#define RGENGC_WB_PROTECTED_STRING
This is a compile-time flag to enable/disable write barrier for struct RString.
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_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
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().
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 $~.
VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long 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.
void rb_str_free(VALUE str)
Destroys the given string for no reason.
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_filesystem_str_new(const char *ptr, long len)
Identical to rb_str_new(), except it generates a string of "filesystem" encoding.
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_external_str_new(const char *ptr, long len)
Identical to rb_str_new(), except it generates a string of "defaultexternal" encoding.
VALUE rb_str_tmp_new(long len)
Allocates a "temporary" string.
long rb_str_offset(VALUE str, long pos)
"Inverse" of rb_str_sublen().
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_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
VALUE rb_str_ellipsize(VALUE str, long len)
Shortens str and adds three dots, an ellipsis, if it is longer than len characters.
st_index_t rb_memhash(const void *ptr, long len)
This is a universal hash function.
#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.
VALUE rb_str_new_static(const char *ptr, long len)
Identical to rb_str_new(), except it takes a C string literal.
#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.
VALUE rb_str_new_frozen(VALUE str)
Creates a frozen copy of the string, if necessary.
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_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
VALUE rb_str_locktmp(VALUE str)
Obtains a "temporary lock" of the string.
long rb_str_strlen(VALUE str)
Counts the number of characters (not bytes) that are stored inside of the given 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.
#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_replace(VALUE dst, VALUE src)
Replaces the contents of the former object with the stringised contents of the latter.
char * rb_str_subpos(VALUE str, long beg, long *len)
Identical to rb_str_substr(), except it returns a C's string instead of Ruby's.
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...
#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.
long rb_str_sublen(VALUE str, long pos)
Byte offset to character offset conversion.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the 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_interned_str(const char *ptr, long len)
Identical to rb_str_new(), except it returns an infamous "f"string.
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.
#define rb_strlen_lit(str)
Length of a string literal.
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.
void rb_str_update(VALUE dst, long beg, long len, VALUE src)
Replaces some (or all) of the contents of the given string.
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_new_with_class(VALUE obj, const char *ptr, long len)
Identical to rb_str_new(), except it takes the class of the allocating object.
#define rb_str_dup_frozen
Just another name of rb_str_new_frozen.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_substr(VALUE str, long beg, long len)
This is the implementation of two-argumented String#slice.
#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().
VALUE rb_utf8_str_new_static(const char *ptr, long len)
Identical to rb_str_new_static(), except it generates a string of "UTF-8" encoding instead of "binary...
#define rb_utf8_str_new(str, len)
Identical to rb_str_new, except it generates a string of "UTF-8" encoding.
void rb_str_modify_expand(VALUE str, long capa)
Identical to rb_str_modify(), except it additionally expands the capacity of the receiver.
VALUE rb_str_dump(VALUE str)
"Inverse" of rb_eval_string().
VALUE rb_locale_str_new(const char *ptr, long len)
Identical to rb_str_new(), except it generates a string of "locale" encoding.
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
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_drop_bytes(VALUE str, long len)
Shrinks the given string for the given number of bytes.
VALUE rb_str_split(VALUE str, const char *delim)
Divides the given string based on the given delimiter.
VALUE rb_usascii_str_new_static(const char *ptr, long len)
Identical to rb_str_new_static(), except it generates a string of "US ASCII" encoding instead of "bin...
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.
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.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int off
Offset inside of ptr.
int len
Length of the buffer.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
long rb_reg_search(VALUE re, VALUE str, long 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.
VALUE rb_reg_regsub(VALUE repl, VALUE src, struct re_registers *regs, VALUE rexp)
Substitution.
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.
Defines RBIMPL_ATTR_NONSTRING.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RBASIC(obj)
Convenient casting macro.
#define DATA_PTR(obj)
Convenient getter macro.
#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...
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
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.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#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.
struct RBasic basic
Basic part, including flags and class.
long len
Length of the string, not including terminating NUL character.
void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock)
Blocks until the current thread obtains a lock.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
ruby_value_type
C-level type of an object.