From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/string.c | 9169 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 9169 insertions(+) create mode 100644 jni/ruby/string.c (limited to 'jni/ruby/string.c') diff --git a/jni/ruby/string.c b/jni/ruby/string.c new file mode 100644 index 0000000..112df10 --- /dev/null +++ b/jni/ruby/string.c @@ -0,0 +1,9169 @@ +/********************************************************************** + + string.c - + + $Author: nagachika $ + created at: Mon Aug 9 17:12:58 JST 1993 + + Copyright (C) 1993-2007 Yukihiro Matsumoto + Copyright (C) 2000 Network Applied Communication Laboratory, Inc. + Copyright (C) 2000 Information-technology Promotion Agency, Japan + +**********************************************************************/ + +#include "internal.h" +#include "ruby/re.h" +#include "probes.h" +#include "gc.h" +#include + +#define BEG(no) (regs->beg[(no)]) +#define END(no) (regs->end[(no)]) + +#include +#include + +#ifdef HAVE_UNISTD_H +#include +#endif + +#define STRING_ENUMERATORS_WANTARRAY 0 /* next major */ + +#undef rb_str_new +#undef rb_usascii_str_new +#undef rb_utf8_str_new +#undef rb_enc_str_new +#undef rb_str_new_cstr +#undef rb_tainted_str_new_cstr +#undef rb_usascii_str_new_cstr +#undef rb_utf8_str_new_cstr +#undef rb_enc_str_new_cstr +#undef rb_external_str_new_cstr +#undef rb_locale_str_new_cstr +#undef rb_str_dup_frozen +#undef rb_str_buf_new_cstr +#undef rb_str_buf_cat +#undef rb_str_buf_cat2 +#undef rb_str_cat2 +#undef rb_str_cat_cstr + +static VALUE rb_str_clear(VALUE str); + +VALUE rb_cString; +VALUE rb_cSymbol; + +#define RUBY_MAX_CHAR_LEN 16 +#define STR_TMPLOCK FL_USER7 +#define STR_NOFREE FL_USER18 + +#define STR_SET_NOEMBED(str) do {\ + FL_SET((str), STR_NOEMBED);\ + STR_SET_EMBED_LEN((str), 0);\ +} while (0) +#define STR_SET_EMBED(str) FL_UNSET((str), (STR_NOEMBED|STR_NOFREE)) +#define STR_SET_EMBED_LEN(str, n) do { \ + long tmp_n = (n);\ + RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\ + RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\ +} while (0) + +#define STR_SET_LEN(str, n) do { \ + if (STR_EMBED_P(str)) {\ + STR_SET_EMBED_LEN((str), (n));\ + }\ + else {\ + RSTRING(str)->as.heap.len = (n);\ + }\ +} while (0) + +#define STR_DEC_LEN(str) do {\ + if (STR_EMBED_P(str)) {\ + long n = RSTRING_LEN(str);\ + n--;\ + STR_SET_EMBED_LEN((str), n);\ + }\ + else {\ + RSTRING(str)->as.heap.len--;\ + }\ +} while (0) + +#define TERM_LEN(str) rb_enc_mbminlen(rb_enc_get(str)) +#define TERM_FILL(ptr, termlen) do {\ + char *const term_fill_ptr = (ptr);\ + const int term_fill_len = (termlen);\ + *term_fill_ptr = '\0';\ + if (UNLIKELY(term_fill_len > 1))\ + memset(term_fill_ptr, 0, term_fill_len);\ +} while (0) + +#define RESIZE_CAPA(str,capacity) do {\ + const int termlen = TERM_LEN(str);\ + RESIZE_CAPA_TERM(str,capacity,termlen);\ +} while (0) +#define RESIZE_CAPA_TERM(str,capacity,termlen) do {\ + if (STR_EMBED_P(str)) {\ + if ((capacity) > RSTRING_EMBED_LEN_MAX) {\ + char *const tmp = ALLOC_N(char, (capacity)+termlen);\ + const long tlen = RSTRING_LEN(str);\ + memcpy(tmp, RSTRING_PTR(str), tlen);\ + RSTRING(str)->as.heap.ptr = tmp;\ + RSTRING(str)->as.heap.len = tlen;\ + STR_SET_NOEMBED(str);\ + RSTRING(str)->as.heap.aux.capa = (capacity);\ + }\ + }\ + else {\ + assert(!FL_TEST((str), STR_SHARED)); \ + REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+termlen);\ + RSTRING(str)->as.heap.aux.capa = (capacity);\ + }\ +} while (0) + +#define STR_SET_SHARED(str, shared_str) do { \ + RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \ + FL_SET((str), STR_SHARED); \ +} while (0) + +#define STR_HEAP_PTR(str) (RSTRING(str)->as.heap.ptr) +#define STR_HEAP_SIZE(str) (RSTRING(str)->as.heap.aux.capa + TERM_LEN(str)) + +#define STR_ENC_GET(str) get_encoding(str) + +#if !defined SHARABLE_MIDDLE_SUBSTRING +# define SHARABLE_MIDDLE_SUBSTRING 0 +#endif +#if !SHARABLE_MIDDLE_SUBSTRING +#define SHARABLE_SUBSTRING_P(beg, len, end) ((beg) + (len) == (end)) +#else +#define SHARABLE_SUBSTRING_P(beg, len, end) 1 +#endif + +static rb_encoding * +get_actual_encoding(const int encidx, VALUE str) +{ + const unsigned char *q; + + switch (encidx) { + case ENCINDEX_UTF_16: + if (RSTRING_LEN(str) < 2) break; + q = (const unsigned char *)RSTRING_PTR(str); + if (q[0] == 0xFE && q[1] == 0xFF) { + return rb_enc_get_from_index(ENCINDEX_UTF_16BE); + } + if (q[0] == 0xFF && q[1] == 0xFE) { + return rb_enc_get_from_index(ENCINDEX_UTF_16LE); + } + return rb_ascii8bit_encoding(); + case ENCINDEX_UTF_32: + if (RSTRING_LEN(str) < 4) break; + q = (const unsigned char *)RSTRING_PTR(str); + if (q[0] == 0 && q[1] == 0 && q[2] == 0xFE && q[3] == 0xFF) { + return rb_enc_get_from_index(ENCINDEX_UTF_32BE); + } + if (q[3] == 0 && q[2] == 0 && q[1] == 0xFE && q[0] == 0xFF) { + return rb_enc_get_from_index(ENCINDEX_UTF_32LE); + } + return rb_ascii8bit_encoding(); + } + return rb_enc_from_index(encidx); +} + +static rb_encoding * +get_encoding(VALUE str) +{ + return get_actual_encoding(ENCODING_GET(str), str); +} + +static void +mustnot_broken(VALUE str) +{ + if (is_broken_string(str)) { + rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str))); + } +} + +static void +mustnot_wchar(VALUE str) +{ + rb_encoding *enc = STR_ENC_GET(str); + if (rb_enc_mbminlen(enc) > 1) { + rb_raise(rb_eArgError, "wide char encoding: %s", rb_enc_name(enc)); + } +} + +static int fstring_cmp(VALUE a, VALUE b); + +/* in case we restart MVM development, this needs to be per-VM */ +static st_table* frozen_strings; + +static inline st_table* +rb_vm_fstring_table(void) +{ + return frozen_strings; +} + +static const struct st_hash_type fstring_hash_type = { + fstring_cmp, + rb_str_hash, +}; + +static int +fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t arg, int existing) +{ + VALUE *fstr = (VALUE *)arg; + VALUE str = (VALUE)*key; + + if (existing) { + /* because of lazy sweep, str may be unmarked already and swept + * at next time */ + + if (rb_objspace_garbage_object_p(str)) { + *fstr = Qundef; + return ST_DELETE; + } + + *fstr = str; + return ST_STOP; + } + else { + if (STR_SHARED_P(str)) { /* str should not be shared */ + str = rb_enc_str_new(RSTRING_PTR(str), RSTRING_LEN(str), STR_ENC_GET(str)); + OBJ_FREEZE(str); + } + else { + str = rb_str_new_frozen(str); + } + RBASIC(str)->flags |= RSTRING_FSTR; + + *key = *value = *fstr = str; + return ST_CONTINUE; + } +} + +VALUE +rb_fstring(VALUE str) +{ + VALUE ret; + + Check_Type(str, T_STRING); + + if (FL_TEST(str, RSTRING_FSTR)) + return str; + + do { + ret = str; + st_update(rb_vm_fstring_table(), (st_data_t)str, + fstr_update_callback, (st_data_t)&ret); + } while (ret == Qundef); + + return ret; +} + +static VALUE +setup_fake_str(struct RString *fake_str, const char *name, long len, int encidx) +{ + fake_str->basic.flags = T_STRING|RSTRING_NOEMBED|STR_NOFREE; + /* SHARED to be allocated by the callback */ + + ENCODING_SET_INLINED((VALUE)fake_str, encidx); + + RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString); + fake_str->as.heap.len = len; + fake_str->as.heap.ptr = (char *)name; + fake_str->as.heap.aux.capa = len; + return (VALUE)fake_str; +} + +VALUE +rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc) +{ + return setup_fake_str(fake_str, name, len, rb_enc_to_index(enc)); +} + +VALUE +rb_fstring_new(const char *ptr, long len) +{ + struct RString fake_str; + return rb_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII)); +} + +static int +fstring_set_class_i(st_data_t key, st_data_t val, st_data_t arg) +{ + RBASIC_SET_CLASS((VALUE)key, (VALUE)arg); + return ST_CONTINUE; +} + +static int +fstring_cmp(VALUE a, VALUE b) +{ + int cmp = rb_str_hash_cmp(a, b); + if (cmp != 0) { + return cmp; + } + return ENCODING_GET(b) - ENCODING_GET(a); +} + +static inline int +single_byte_optimizable(VALUE str) +{ + rb_encoding *enc; + + /* Conservative. It may be ENC_CODERANGE_UNKNOWN. */ + if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT) + return 1; + + enc = STR_ENC_GET(str); + if (rb_enc_mbmaxlen(enc) == 1) + return 1; + + /* Conservative. Possibly single byte. + * "\xa1" in Shift_JIS for example. */ + return 0; +} + +VALUE rb_fs; + +static inline const char * +search_nonascii(const char *p, const char *e) +{ +#if SIZEOF_VOIDP == 8 +# define NONASCII_MASK 0x8080808080808080ULL +#elif SIZEOF_VOIDP == 4 +# define NONASCII_MASK 0x80808080UL +#endif +#ifdef NONASCII_MASK + if ((int)SIZEOF_VOIDP * 2 < e - p) { + const uintptr_t *s, *t; + const uintptr_t lowbits = SIZEOF_VOIDP - 1; + s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits)); + while (p < (const char *)s) { + if (!ISASCII(*p)) + return p; + p++; + } + t = (const uintptr_t*)(~lowbits & (uintptr_t)e); + while (s < t) { + if (*s & NONASCII_MASK) { + t = s; + break; + } + s++; + } + p = (const char *)t; + } +#endif + while (p < e) { + if (!ISASCII(*p)) + return p; + p++; + } + return NULL; +} + +static int +coderange_scan(const char *p, long len, rb_encoding *enc) +{ + const char *e = p + len; + + if (rb_enc_to_index(enc) == rb_ascii8bit_encindex()) { + /* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */ + p = search_nonascii(p, e); + return p ? ENC_CODERANGE_VALID : ENC_CODERANGE_7BIT; + } + + if (rb_enc_asciicompat(enc)) { + p = search_nonascii(p, e); + if (!p) return ENC_CODERANGE_7BIT; + for (;;) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (!MBCLEN_CHARFOUND_P(ret)) return ENC_CODERANGE_BROKEN; + p += MBCLEN_CHARFOUND_LEN(ret); + if (p == e) break; + p = search_nonascii(p, e); + if (!p) break; + } + } + else { + while (p < e) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (!MBCLEN_CHARFOUND_P(ret)) return ENC_CODERANGE_BROKEN; + p += MBCLEN_CHARFOUND_LEN(ret); + } + } + return ENC_CODERANGE_VALID; +} + +long +rb_str_coderange_scan_restartable(const char *s, const char *e, rb_encoding *enc, int *cr) +{ + const char *p = s; + + if (*cr == ENC_CODERANGE_BROKEN) + return e - s; + + if (rb_enc_to_index(enc) == rb_ascii8bit_encindex()) { + /* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */ + if (*cr == ENC_CODERANGE_VALID) return e - s; + p = search_nonascii(p, e); + *cr = p ? ENC_CODERANGE_VALID : ENC_CODERANGE_7BIT; + return e - s; + } + else if (rb_enc_asciicompat(enc)) { + p = search_nonascii(p, e); + if (!p) { + if (*cr != ENC_CODERANGE_VALID) *cr = ENC_CODERANGE_7BIT; + return e - s; + } + for (;;) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (!MBCLEN_CHARFOUND_P(ret)) { + *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN; + return p - s; + } + p += MBCLEN_CHARFOUND_LEN(ret); + if (p == e) break; + p = search_nonascii(p, e); + if (!p) break; + } + } + else { + while (p < e) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (!MBCLEN_CHARFOUND_P(ret)) { + *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN; + return p - s; + } + p += MBCLEN_CHARFOUND_LEN(ret); + } + } + *cr = ENC_CODERANGE_VALID; + return e - s; +} + +static inline void +str_enc_copy(VALUE str1, VALUE str2) +{ + rb_enc_set_index(str1, ENCODING_GET(str2)); +} + +static void +rb_enc_cr_str_copy_for_substr(VALUE dest, VALUE src) +{ + /* this function is designed for copying encoding and coderange + * from src to new string "dest" which is made from the part of src. + */ + str_enc_copy(dest, src); + if (RSTRING_LEN(dest) == 0) { + if (!rb_enc_asciicompat(STR_ENC_GET(src))) + ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID); + else + ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); + return; + } + switch (ENC_CODERANGE(src)) { + case ENC_CODERANGE_7BIT: + ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); + break; + case ENC_CODERANGE_VALID: + if (!rb_enc_asciicompat(STR_ENC_GET(src)) || + search_nonascii(RSTRING_PTR(dest), RSTRING_END(dest))) + ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID); + else + ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); + break; + default: + break; + } +} + +static void +rb_enc_cr_str_exact_copy(VALUE dest, VALUE src) +{ + str_enc_copy(dest, src); + ENC_CODERANGE_SET(dest, ENC_CODERANGE(src)); +} + +int +rb_enc_str_coderange(VALUE str) +{ + int cr = ENC_CODERANGE(str); + + if (cr == ENC_CODERANGE_UNKNOWN) { + int encidx = ENCODING_GET(str); + rb_encoding *enc = rb_enc_from_index(encidx); + if (rb_enc_mbminlen(enc) > 1 && rb_enc_dummy_p(enc)) { + cr = ENC_CODERANGE_BROKEN; + } + else { + cr = coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), + get_actual_encoding(encidx, str)); + } + ENC_CODERANGE_SET(str, cr); + } + return cr; +} + +int +rb_enc_str_asciionly_p(VALUE str) +{ + rb_encoding *enc = STR_ENC_GET(str); + + if (!rb_enc_asciicompat(enc)) + return FALSE; + else if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) + return TRUE; + return FALSE; +} + +static inline void +str_mod_check(VALUE s, const char *p, long len) +{ + if (RSTRING_PTR(s) != p || RSTRING_LEN(s) != len){ + rb_raise(rb_eRuntimeError, "string modified"); + } +} + +size_t +rb_str_capacity(VALUE str) +{ + if (STR_EMBED_P(str)) { + return RSTRING_EMBED_LEN_MAX; + } + else if (FL_TEST(str, STR_SHARED|STR_NOFREE)) { + return RSTRING(str)->as.heap.len; + } + else { + return RSTRING(str)->as.heap.aux.capa; + } +} + +static inline void +must_not_null(const char *ptr) +{ + if (!ptr) { + rb_raise(rb_eArgError, "NULL pointer given"); + } +} + +static inline VALUE +str_alloc(VALUE klass) +{ + NEWOBJ_OF(str, struct RString, klass, T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0)); + return (VALUE)str; +} + +static inline VALUE +empty_str_alloc(VALUE klass) +{ + if (RUBY_DTRACE_STRING_CREATE_ENABLED()) { + RUBY_DTRACE_STRING_CREATE(0, rb_sourcefile(), rb_sourceline()); + } + return str_alloc(klass); +} + +static VALUE +str_new0(VALUE klass, const char *ptr, long len, int termlen) +{ + VALUE str; + + if (len < 0) { + rb_raise(rb_eArgError, "negative string size (or size too big)"); + } + + if (RUBY_DTRACE_STRING_CREATE_ENABLED()) { + RUBY_DTRACE_STRING_CREATE(len, rb_sourcefile(), rb_sourceline()); + } + + str = str_alloc(klass); + if (len > RSTRING_EMBED_LEN_MAX) { + RSTRING(str)->as.heap.aux.capa = len; + RSTRING(str)->as.heap.ptr = ALLOC_N(char, len + termlen); + STR_SET_NOEMBED(str); + } + else if (len == 0) { + ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); + } + if (ptr) { + memcpy(RSTRING_PTR(str), ptr, len); + } + STR_SET_LEN(str, len); + TERM_FILL(RSTRING_PTR(str) + len, termlen); + return str; +} + +static VALUE +str_new(VALUE klass, const char *ptr, long len) +{ + return str_new0(klass, ptr, len, 1); +} + +VALUE +rb_str_new(const char *ptr, long len) +{ + return str_new(rb_cString, ptr, len); +} + +VALUE +rb_usascii_str_new(const char *ptr, long len) +{ + VALUE str = rb_str_new(ptr, len); + ENCODING_CODERANGE_SET(str, rb_usascii_encindex(), ENC_CODERANGE_7BIT); + return str; +} + +VALUE +rb_utf8_str_new(const char *ptr, long len) +{ + VALUE str = str_new(rb_cString, ptr, len); + rb_enc_associate_index(str, rb_utf8_encindex()); + return str; +} + +VALUE +rb_enc_str_new(const char *ptr, long len, rb_encoding *enc) +{ + VALUE str; + + if (!enc) return rb_str_new(ptr, len); + + str = str_new0(rb_cString, ptr, len, rb_enc_mbminlen(enc)); + rb_enc_associate(str, enc); + return str; +} + +VALUE +rb_str_new_cstr(const char *ptr) +{ + must_not_null(ptr); + return rb_str_new(ptr, strlen(ptr)); +} + +VALUE +rb_usascii_str_new_cstr(const char *ptr) +{ + VALUE str = rb_str_new_cstr(ptr); + ENCODING_CODERANGE_SET(str, rb_usascii_encindex(), ENC_CODERANGE_7BIT); + return str; +} + +VALUE +rb_utf8_str_new_cstr(const char *ptr) +{ + VALUE str = rb_str_new_cstr(ptr); + rb_enc_associate_index(str, rb_utf8_encindex()); + return str; +} + +VALUE +rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc) +{ + must_not_null(ptr); + if (rb_enc_mbminlen(enc) != 1) { + rb_raise(rb_eArgError, "wchar encoding given"); + } + return rb_enc_str_new(ptr, strlen(ptr), enc); +} + +static VALUE +str_new_static(VALUE klass, const char *ptr, long len, int encindex) +{ + VALUE str; + + if (len < 0) { + rb_raise(rb_eArgError, "negative string size (or size too big)"); + } + + if (!ptr) { + str = str_new(klass, ptr, len); + } + else { + if (RUBY_DTRACE_STRING_CREATE_ENABLED()) { + RUBY_DTRACE_STRING_CREATE(len, rb_sourcefile(), rb_sourceline()); + } + str = str_alloc(klass); + RSTRING(str)->as.heap.len = len; + RSTRING(str)->as.heap.ptr = (char *)ptr; + RSTRING(str)->as.heap.aux.capa = len; + STR_SET_NOEMBED(str); + RBASIC(str)->flags |= STR_NOFREE; + } + rb_enc_associate_index(str, encindex); + return str; +} + +VALUE +rb_str_new_static(const char *ptr, long len) +{ + return str_new_static(rb_cString, ptr, len, 0); +} + +VALUE +rb_usascii_str_new_static(const char *ptr, long len) +{ + return str_new_static(rb_cString, ptr, len, ENCINDEX_US_ASCII); +} + +VALUE +rb_utf8_str_new_static(const char *ptr, long len) +{ + return str_new_static(rb_cString, ptr, len, ENCINDEX_UTF_8); +} + +VALUE +rb_enc_str_new_static(const char *ptr, long len, rb_encoding *enc) +{ + return str_new_static(rb_cString, ptr, len, rb_enc_to_index(enc)); +} + +VALUE +rb_tainted_str_new(const char *ptr, long len) +{ + VALUE str = rb_str_new(ptr, len); + + OBJ_TAINT(str); + return str; +} + +VALUE +rb_tainted_str_new_cstr(const char *ptr) +{ + VALUE str = rb_str_new_cstr(ptr); + + OBJ_TAINT(str); + return str; +} + +VALUE +rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts) +{ + rb_econv_t *ec; + rb_econv_result_t ret; + long len, olen; + VALUE econv_wrapper; + VALUE newstr; + const unsigned char *start, *sp; + unsigned char *dest, *dp; + size_t converted_output = 0; + + if (!to) return str; + if (!from) from = rb_enc_get(str); + if (from == to) return str; + if ((rb_enc_asciicompat(to) && is_ascii_string(str)) || + to == rb_ascii8bit_encoding()) { + if (STR_ENC_GET(str) != to) { + str = rb_str_dup(str); + rb_enc_associate(str, to); + } + return str; + } + + len = RSTRING_LEN(str); + newstr = rb_str_new(0, len); + OBJ_INFECT(newstr, str); + olen = len; + + econv_wrapper = rb_obj_alloc(rb_cEncodingConverter); + RBASIC_CLEAR_CLASS(econv_wrapper); + ec = rb_econv_open_opts(from->name, to->name, ecflags, ecopts); + if (!ec) return str; + DATA_PTR(econv_wrapper) = ec; + + sp = (unsigned char*)RSTRING_PTR(str); + start = sp; + while ((dest = (unsigned char*)RSTRING_PTR(newstr)), + (dp = dest + converted_output), + (ret = rb_econv_convert(ec, &sp, start + len, &dp, dest + olen, 0)), + ret == econv_destination_buffer_full) { + /* destination buffer short */ + size_t converted_input = sp - start; + size_t rest = len - converted_input; + converted_output = dp - dest; + rb_str_set_len(newstr, converted_output); + if (converted_input && converted_output && + rest < (LONG_MAX / converted_output)) { + rest = (rest * converted_output) / converted_input; + } + else { + rest = olen; + } + olen += rest < 2 ? 2 : rest; + rb_str_resize(newstr, olen); + } + DATA_PTR(econv_wrapper) = 0; + rb_econv_close(ec); + rb_gc_force_recycle(econv_wrapper); + switch (ret) { + case econv_finished: + len = dp - (unsigned char*)RSTRING_PTR(newstr); + rb_str_set_len(newstr, len); + rb_enc_associate(newstr, to); + return newstr; + + default: + /* some error, return original */ + return str; + } +} + +VALUE +rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to) +{ + return rb_str_conv_enc_opts(str, from, to, 0, Qnil); +} + +VALUE +rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc) +{ + VALUE str; + + str = rb_tainted_str_new(ptr, len); + return rb_external_str_with_enc(str, eenc); +} + +VALUE +rb_external_str_with_enc(VALUE str, rb_encoding *eenc) +{ + if (eenc == rb_usascii_encoding() && + rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { + rb_enc_associate(str, rb_ascii8bit_encoding()); + return str; + } + rb_enc_associate(str, eenc); + return rb_str_conv_enc(str, eenc, rb_default_internal_encoding()); +} + +VALUE +rb_external_str_new(const char *ptr, long len) +{ + return rb_external_str_new_with_enc(ptr, len, rb_default_external_encoding()); +} + +VALUE +rb_external_str_new_cstr(const char *ptr) +{ + return rb_external_str_new_with_enc(ptr, strlen(ptr), rb_default_external_encoding()); +} + +VALUE +rb_locale_str_new(const char *ptr, long len) +{ + return rb_external_str_new_with_enc(ptr, len, rb_locale_encoding()); +} + +VALUE +rb_locale_str_new_cstr(const char *ptr) +{ + return rb_external_str_new_with_enc(ptr, strlen(ptr), rb_locale_encoding()); +} + +VALUE +rb_filesystem_str_new(const char *ptr, long len) +{ + return rb_external_str_new_with_enc(ptr, len, rb_filesystem_encoding()); +} + +VALUE +rb_filesystem_str_new_cstr(const char *ptr) +{ + return rb_external_str_new_with_enc(ptr, strlen(ptr), rb_filesystem_encoding()); +} + +VALUE +rb_str_export(VALUE str) +{ + return rb_str_conv_enc(str, STR_ENC_GET(str), rb_default_external_encoding()); +} + +VALUE +rb_str_export_locale(VALUE str) +{ + return rb_str_conv_enc(str, STR_ENC_GET(str), rb_locale_encoding()); +} + +VALUE +rb_str_export_to_enc(VALUE str, rb_encoding *enc) +{ + return rb_str_conv_enc(str, STR_ENC_GET(str), enc); +} + +static VALUE +str_replace_shared_without_enc(VALUE str2, VALUE str) +{ + if (RSTRING_LEN(str) <= RSTRING_EMBED_LEN_MAX) { + STR_SET_EMBED(str2); + memcpy(RSTRING_PTR(str2), RSTRING_PTR(str), RSTRING_LEN(str)+1); + STR_SET_EMBED_LEN(str2, RSTRING_LEN(str)); + } + else { + str = rb_str_new_frozen(str); + FL_SET(str2, STR_NOEMBED); + RSTRING(str2)->as.heap.len = RSTRING_LEN(str); + RSTRING(str2)->as.heap.ptr = RSTRING_PTR(str); + STR_SET_SHARED(str2, str); + } + return str2; +} + +static VALUE +str_replace_shared(VALUE str2, VALUE str) +{ + str_replace_shared_without_enc(str2, str); + rb_enc_cr_str_exact_copy(str2, str); + return str2; +} + +static VALUE +str_new_shared(VALUE klass, VALUE str) +{ + return str_replace_shared(str_alloc(klass), str); +} + +VALUE +rb_str_new_shared(VALUE str) +{ + VALUE str2 = str_new_shared(rb_obj_class(str), str); + + OBJ_INFECT(str2, str); + return str2; +} + +VALUE +rb_str_new_frozen(VALUE orig) +{ + VALUE klass, str; + + if (OBJ_FROZEN(orig)) return orig; + + klass = rb_obj_class(orig); + + if (STR_EMBED_P(orig)) { + str = str_new(klass, RSTRING_PTR(orig), RSTRING_LEN(orig)); + } + else { + if (FL_TEST(orig, STR_SHARED)) { + VALUE shared = RSTRING(orig)->as.heap.aux.shared; + long ofs = RSTRING_PTR(orig) - RSTRING_PTR(shared); + long rest = RSTRING_LEN(shared) - ofs - RSTRING_LEN(orig); + assert(OBJ_FROZEN(shared)); + + if ((ofs > 0) || (rest > 0) || + (klass != RBASIC(shared)->klass) || + ((RBASIC(shared)->flags ^ RBASIC(orig)->flags) & FL_TAINT) || + ENCODING_GET(shared) != ENCODING_GET(orig)) { + str = str_new_shared(klass, shared); + RSTRING(str)->as.heap.ptr += ofs; + RSTRING(str)->as.heap.len -= ofs + rest; + } + else { + return shared; + } + } + else { + str = str_alloc(klass); + STR_SET_NOEMBED(str); + RSTRING(str)->as.heap.len = RSTRING_LEN(orig); + RSTRING(str)->as.heap.ptr = RSTRING_PTR(orig); + RSTRING(str)->as.heap.aux.capa = RSTRING(orig)->as.heap.aux.capa; + RBASIC(str)->flags |= RBASIC(orig)->flags & STR_NOFREE; + RBASIC(orig)->flags &= ~STR_NOFREE; + STR_SET_SHARED(orig, str); + } + } + + rb_enc_cr_str_exact_copy(str, orig); + OBJ_INFECT(str, orig); + OBJ_FREEZE(str); + return str; +} + +VALUE +rb_str_new_with_class(VALUE obj, const char *ptr, long len) +{ + return str_new(rb_obj_class(obj), ptr, len); +} + +static VALUE +str_new_empty(VALUE str) +{ + VALUE v = rb_str_new_with_class(str, 0, 0); + rb_enc_copy(v, str); + OBJ_INFECT(v, str); + return v; +} + +#define STR_BUF_MIN_SIZE 128 + +VALUE +rb_str_buf_new(long capa) +{ + VALUE str = str_alloc(rb_cString); + + if (capa < STR_BUF_MIN_SIZE) { + capa = STR_BUF_MIN_SIZE; + } + FL_SET(str, STR_NOEMBED); + RSTRING(str)->as.heap.aux.capa = capa; + RSTRING(str)->as.heap.ptr = ALLOC_N(char, capa+1); + RSTRING(str)->as.heap.ptr[0] = '\0'; + + return str; +} + +VALUE +rb_str_buf_new_cstr(const char *ptr) +{ + VALUE str; + long len = strlen(ptr); + + str = rb_str_buf_new(len); + rb_str_buf_cat(str, ptr, len); + + return str; +} + +VALUE +rb_str_tmp_new(long len) +{ + return str_new(0, 0, len); +} + +void * +rb_alloc_tmp_buffer(volatile VALUE *store, long len) +{ + VALUE s = rb_str_tmp_new(len); + *store = s; + return RSTRING_PTR(s); +} + +void +rb_free_tmp_buffer(volatile VALUE *store) +{ + VALUE s = *store; + *store = 0; + if (s) rb_str_clear(s); +} + +void +rb_str_free(VALUE str) +{ + if (FL_TEST(str, RSTRING_FSTR)) { + st_data_t fstr = (st_data_t)str; + st_delete(rb_vm_fstring_table(), &fstr, NULL); + } + + if (!STR_EMBED_P(str) && !FL_TEST(str, STR_SHARED|STR_NOFREE)) { + ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); + } +} + +RUBY_FUNC_EXPORTED size_t +rb_str_memsize(VALUE str) +{ + if (FL_TEST(str, STR_NOEMBED|STR_SHARED|STR_NOFREE) == STR_NOEMBED) { + return STR_HEAP_SIZE(str); + } + else { + return 0; + } +} + +VALUE +rb_str_to_str(VALUE str) +{ + return rb_convert_type(str, T_STRING, "String", "to_str"); +} + +static inline void str_discard(VALUE str); + +void +rb_str_shared_replace(VALUE str, VALUE str2) +{ + rb_encoding *enc; + int cr; + if (str == str2) return; + enc = STR_ENC_GET(str2); + cr = ENC_CODERANGE(str2); + str_discard(str); + OBJ_INFECT(str, str2); + + if (RSTRING_LEN(str2) <= RSTRING_EMBED_LEN_MAX) { + STR_SET_EMBED(str); + memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1); + STR_SET_EMBED_LEN(str, RSTRING_LEN(str2)); + rb_enc_associate(str, enc); + ENC_CODERANGE_SET(str, cr); + } + else { + STR_SET_NOEMBED(str); + FL_UNSET(str, STR_SHARED); + RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); + RSTRING(str)->as.heap.len = RSTRING_LEN(str2); + + if (FL_TEST(str2, STR_SHARED)) { + VALUE shared = RSTRING(str2)->as.heap.aux.shared; + STR_SET_SHARED(str, shared); + } + else { + RSTRING(str)->as.heap.aux.capa = RSTRING(str2)->as.heap.aux.capa; + } + + /* abandon str2 */ + STR_SET_EMBED(str2); + RSTRING_PTR(str2)[0] = 0; + STR_SET_EMBED_LEN(str2, 0); + rb_enc_associate(str, enc); + ENC_CODERANGE_SET(str, cr); + } +} + +static ID id_to_s; + +VALUE +rb_obj_as_string(VALUE obj) +{ + VALUE str; + + if (RB_TYPE_P(obj, T_STRING)) { + return obj; + } + str = rb_funcall(obj, id_to_s, 0); + if (!RB_TYPE_P(str, T_STRING)) + return rb_any_to_s(obj); + if (OBJ_TAINTED(obj)) OBJ_TAINT(str); + return str; +} + +static VALUE +str_replace(VALUE str, VALUE str2) +{ + long len; + + len = RSTRING_LEN(str2); + if (STR_SHARED_P(str2)) { + VALUE shared = RSTRING(str2)->as.heap.aux.shared; + assert(OBJ_FROZEN(shared)); + STR_SET_NOEMBED(str); + RSTRING(str)->as.heap.len = len; + RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); + STR_SET_SHARED(str, shared); + } + else { + str_replace_shared(str, str2); + } + + OBJ_INFECT(str, str2); + rb_enc_cr_str_exact_copy(str, str2); + return str; +} + +static VALUE +str_duplicate(VALUE klass, VALUE str) +{ + VALUE dup = str_alloc(klass); + str_replace(dup, str); + return dup; +} + +VALUE +rb_str_dup(VALUE str) +{ + return str_duplicate(rb_obj_class(str), str); +} + +VALUE +rb_str_resurrect(VALUE str) +{ + if (RUBY_DTRACE_STRING_CREATE_ENABLED()) { + RUBY_DTRACE_STRING_CREATE(RSTRING_LEN(str), + rb_sourcefile(), rb_sourceline()); + } + return str_duplicate(rb_cString, str); +} + +/* + * call-seq: + * String.new(str="") -> new_str + * + * Returns a new string object containing a copy of str. + */ + +static VALUE +rb_str_init(int argc, VALUE *argv, VALUE str) +{ + VALUE orig; + + if (argc > 0 && rb_scan_args(argc, argv, "01", &orig) == 1) + rb_str_replace(str, orig); + return str; +} + +#ifdef NONASCII_MASK +#define is_utf8_lead_byte(c) (((c)&0xC0) != 0x80) + +/* + * UTF-8 leading bytes have either 0xxxxxxx or 11xxxxxx + * bit representation. (see http://en.wikipedia.org/wiki/UTF-8) + * Therefore, the following pseudocode can detect UTF-8 leading bytes. + * + * if (!(byte & 0x80)) + * byte |= 0x40; // turn on bit6 + * return ((byte>>6) & 1); // bit6 represent whether this byte is leading or not. + * + * This function calculates whether a byte is leading or not for all bytes + * in the argument word by concurrently using the above logic, and then + * adds up the number of leading bytes in the word. + */ +static inline uintptr_t +count_utf8_lead_bytes_with_word(const uintptr_t *s) +{ + uintptr_t d = *s; + + /* Transform so that bit0 indicates whether we have a UTF-8 leading byte or not. */ + d |= ~(d>>1); + d >>= 6; + d &= NONASCII_MASK >> 7; + + /* Gather all bytes. */ + d += (d>>8); + d += (d>>16); +#if SIZEOF_VOIDP == 8 + d += (d>>32); +#endif + return (d&0xF); +} +#endif + +static inline long +enc_strlen(const char *p, const char *e, rb_encoding *enc, int cr) +{ + long c; + const char *q; + + if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { + return (e - p + rb_enc_mbminlen(enc) - 1) / rb_enc_mbminlen(enc); + } +#ifdef NONASCII_MASK + else if (cr == ENC_CODERANGE_VALID && enc == rb_utf8_encoding()) { + uintptr_t len = 0; + if ((int)sizeof(uintptr_t) * 2 < e - p) { + const uintptr_t *s, *t; + const uintptr_t lowbits = sizeof(uintptr_t) - 1; + s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits)); + t = (const uintptr_t*)(~lowbits & (uintptr_t)e); + while (p < (const char *)s) { + if (is_utf8_lead_byte(*p)) len++; + p++; + } + while (s < t) { + len += count_utf8_lead_bytes_with_word(s); + s++; + } + p = (const char *)s; + } + while (p < e) { + if (is_utf8_lead_byte(*p)) len++; + p++; + } + return (long)len; + } +#endif + else if (rb_enc_asciicompat(enc)) { + c = 0; + if (cr == ENC_CODERANGE_7BIT || cr == ENC_CODERANGE_VALID) { + while (p < e) { + if (ISASCII(*p)) { + q = search_nonascii(p, e); + if (!q) + return c + (e - p); + c += q - p; + p = q; + } + p += rb_enc_fast_mbclen(p, e, enc); + c++; + } + } + else { + while (p < e) { + if (ISASCII(*p)) { + q = search_nonascii(p, e); + if (!q) + return c + (e - p); + c += q - p; + p = q; + } + p += rb_enc_mbclen(p, e, enc); + c++; + } + } + return c; + } + + for (c=0; p integer + * str.size -> integer + * + * Returns the character length of str. + */ + +VALUE +rb_str_length(VALUE str) +{ + return LONG2NUM(str_strlen(str, NULL)); +} + +/* + * call-seq: + * str.bytesize -> integer + * + * Returns the length of +str+ in bytes. + * + * "\x80\u3042".bytesize #=> 4 + * "hello".bytesize #=> 5 + */ + +static VALUE +rb_str_bytesize(VALUE str) +{ + return LONG2NUM(RSTRING_LEN(str)); +} + +/* + * call-seq: + * str.empty? -> true or false + * + * Returns true if str has a length of zero. + * + * "hello".empty? #=> false + * " ".empty? #=> false + * "".empty? #=> true + */ + +static VALUE +rb_str_empty(VALUE str) +{ + if (RSTRING_LEN(str) == 0) + return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * str + other_str -> new_str + * + * Concatenation---Returns a new String containing + * other_str concatenated to str. + * + * "Hello from " + self.to_s #=> "Hello from main" + */ + +VALUE +rb_str_plus(VALUE str1, VALUE str2) +{ + VALUE str3; + rb_encoding *enc; + char *ptr1, *ptr2, *ptr3; + long len1, len2; + + StringValue(str2); + enc = rb_enc_check(str1, str2); + RSTRING_GETMEM(str1, ptr1, len1); + RSTRING_GETMEM(str2, ptr2, len2); + str3 = rb_str_new(0, len1+len2); + ptr3 = RSTRING_PTR(str3); + memcpy(ptr3, ptr1, len1); + memcpy(ptr3+len1, ptr2, len2); + TERM_FILL(&ptr3[len1+len2], rb_enc_mbminlen(enc)); + + if (OBJ_TAINTED(str1) || OBJ_TAINTED(str2)) + OBJ_TAINT(str3); + ENCODING_CODERANGE_SET(str3, rb_enc_to_index(enc), + ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2))); + RB_GC_GUARD(str1); + RB_GC_GUARD(str2); + return str3; +} + +/* + * call-seq: + * str * integer -> new_str + * + * Copy --- Returns a new String containing +integer+ copies of the receiver. + * +integer+ must be greater than or equal to 0. + * + * "Ho! " * 3 #=> "Ho! Ho! Ho! " + * "Ho! " * 0 #=> "" + */ + +VALUE +rb_str_times(VALUE str, VALUE times) +{ + VALUE str2; + long n, len; + char *ptr2; + int termlen; + + len = NUM2LONG(times); + if (len < 0) { + rb_raise(rb_eArgError, "negative argument"); + } + if (len && LONG_MAX/len < RSTRING_LEN(str)) { + rb_raise(rb_eArgError, "argument too big"); + } + + len *= RSTRING_LEN(str); + termlen = TERM_LEN(str); + str2 = rb_str_new_with_class(str, 0, (len + termlen - 1)); + ptr2 = RSTRING_PTR(str2); + if (len) { + n = RSTRING_LEN(str); + memcpy(ptr2, RSTRING_PTR(str), n); + while (n <= len/2) { + memcpy(ptr2 + n, ptr2, n); + n *= 2; + } + memcpy(ptr2 + n, ptr2, len-n); + } + STR_SET_LEN(str2, len); + TERM_FILL(&ptr2[len], termlen); + OBJ_INFECT(str2, str); + rb_enc_cr_str_copy_for_substr(str2, str); + + return str2; +} + +/* + * call-seq: + * str % arg -> new_str + * + * Format---Uses str as a format specification, and returns the result + * of applying it to arg. If the format specification contains more than + * one substitution, then arg must be an Array or Hash + * containing the values to be substituted. See Kernel::sprintf for + * details of the format string. + * + * "%05d" % 123 #=> "00123" + * "%-5s: %08x" % [ "ID", self.object_id ] #=> "ID : 200e14d6" + * "foo = %{foo}" % { :foo => 'bar' } #=> "foo = bar" + */ + +static VALUE +rb_str_format_m(VALUE str, VALUE arg) +{ + VALUE tmp = rb_check_array_type(arg); + + if (!NIL_P(tmp)) { + VALUE rv = rb_str_format(RARRAY_LENINT(tmp), RARRAY_CONST_PTR(tmp), str); + RB_GC_GUARD(tmp); + return rv; + } + return rb_str_format(1, &arg, str); +} + +static inline void +str_modifiable(VALUE str) +{ + if (FL_TEST(str, STR_TMPLOCK)) { + rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked"); + } + rb_check_frozen(str); +} + +static inline int +str_independent(VALUE str) +{ + str_modifiable(str); + if (STR_EMBED_P(str) || !FL_TEST(str, STR_SHARED|STR_NOFREE)) { + return 1; + } + else { + return 0; + } +} + +static void +str_make_independent_expand(VALUE str, long expand) +{ + char *ptr; + long len = RSTRING_LEN(str); + const int termlen = TERM_LEN(str); + long capa = len + expand; + + if (len > capa) len = capa; + + if (capa + termlen - 1 <= RSTRING_EMBED_LEN_MAX && !STR_EMBED_P(str)) { + ptr = RSTRING(str)->as.heap.ptr; + STR_SET_EMBED(str); + memcpy(RSTRING(str)->as.ary, ptr, len); + TERM_FILL(RSTRING(str)->as.ary + len, termlen); + STR_SET_EMBED_LEN(str, len); + return; + } + + ptr = ALLOC_N(char, capa + termlen); + if (RSTRING_PTR(str)) { + memcpy(ptr, RSTRING_PTR(str), len); + } + STR_SET_NOEMBED(str); + FL_UNSET(str, STR_SHARED|STR_NOFREE); + TERM_FILL(ptr + len, termlen); + RSTRING(str)->as.heap.ptr = ptr; + RSTRING(str)->as.heap.len = len; + RSTRING(str)->as.heap.aux.capa = capa; +} + +#define str_make_independent(str) str_make_independent_expand((str), 0L) + +void +rb_str_modify(VALUE str) +{ + if (!str_independent(str)) + str_make_independent(str); + ENC_CODERANGE_CLEAR(str); +} + +void +rb_str_modify_expand(VALUE str, long expand) +{ + if (expand < 0) { + rb_raise(rb_eArgError, "negative expanding string size"); + } + if (!str_independent(str)) { + str_make_independent_expand(str, expand); + } + else if (expand > 0) { + long len = RSTRING_LEN(str); + long capa = len + expand; + int termlen = TERM_LEN(str); + if (!STR_EMBED_P(str)) { + REALLOC_N(RSTRING(str)->as.heap.ptr, char, capa + termlen); + RSTRING(str)->as.heap.aux.capa = capa; + } + else if (capa + termlen > RSTRING_EMBED_LEN_MAX + 1) { + str_make_independent_expand(str, expand); + } + } + ENC_CODERANGE_CLEAR(str); +} + +/* As rb_str_modify(), but don't clear coderange */ +static void +str_modify_keep_cr(VALUE str) +{ + if (!str_independent(str)) + str_make_independent(str); + if (ENC_CODERANGE(str) == ENC_CODERANGE_BROKEN) + /* Force re-scan later */ + ENC_CODERANGE_CLEAR(str); +} + +static inline void +str_discard(VALUE str) +{ + str_modifiable(str); + if (!STR_EMBED_P(str) && !FL_TEST(str, STR_SHARED|STR_NOFREE)) { + ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); + RSTRING(str)->as.heap.ptr = 0; + RSTRING(str)->as.heap.len = 0; + } +} + +void +rb_must_asciicompat(VALUE str) +{ + rb_encoding *enc = rb_enc_get(str); + if (!rb_enc_asciicompat(enc)) { + rb_raise(rb_eEncCompatError, "ASCII incompatible encoding: %s", rb_enc_name(enc)); + } +} + +VALUE +rb_string_value(volatile VALUE *ptr) +{ + VALUE s = *ptr; + if (!RB_TYPE_P(s, T_STRING)) { + s = rb_str_to_str(s); + *ptr = s; + } + return s; +} + +char * +rb_string_value_ptr(volatile VALUE *ptr) +{ + VALUE str = rb_string_value(ptr); + return RSTRING_PTR(str); +} + +static int +zero_filled(const char *s, int n) +{ + for (; n > 0; --n) { + if (*s++) return 0; + } + return 1; +} + +static const char * +str_null_char(const char *s, long len, const int minlen, rb_encoding *enc) +{ + const char *e = s + len; + + for (; s + minlen <= e; s += rb_enc_mbclen(s, e, enc)) { + if (zero_filled(s, minlen)) return s; + } + return 0; +} + +static char * +str_fill_term(VALUE str, char *s, long len, int oldtermlen, int termlen) +{ + long capa = rb_str_capacity(str) + 1; + + if (capa < len + termlen) { + rb_str_modify_expand(str, termlen); + } + else if (!str_independent(str)) { + if (zero_filled(s + len, termlen)) return s; + str_make_independent(str); + } + s = RSTRING_PTR(str); + TERM_FILL(s + len, termlen); + return s; +} + +char * +rb_string_value_cstr(volatile VALUE *ptr) +{ + VALUE str = rb_string_value(ptr); + char *s = RSTRING_PTR(str); + long len = RSTRING_LEN(str); + rb_encoding *enc = rb_enc_get(str); + const int minlen = rb_enc_mbminlen(enc); + + if (minlen > 1) { + if (str_null_char(s, len, minlen, enc)) { + rb_raise(rb_eArgError, "string contains null char"); + } + return str_fill_term(str, s, len, minlen, minlen); + } + if (!s || memchr(s, 0, len)) { + rb_raise(rb_eArgError, "string contains null byte"); + } + if (s[len]) { + rb_str_modify(str); + s = RSTRING_PTR(str); + s[RSTRING_LEN(str)] = 0; + } + return s; +} + +void +rb_str_fill_terminator(VALUE str, const int newminlen) +{ + char *s = RSTRING_PTR(str); + long len = RSTRING_LEN(str); + rb_encoding *enc = rb_enc_get(str); + str_fill_term(str, s, len, rb_enc_mbminlen(enc), newminlen); +} + +VALUE +rb_check_string_type(VALUE str) +{ + str = rb_check_convert_type(str, T_STRING, "String", "to_str"); + return str; +} + +/* + * call-seq: + * String.try_convert(obj) -> string or nil + * + * Try to convert obj into a String, using to_str method. + * Returns converted string or nil if obj cannot be converted + * for any reason. + * + * String.try_convert("str") #=> "str" + * String.try_convert(/re/) #=> nil + */ +static VALUE +rb_str_s_try_convert(VALUE dummy, VALUE str) +{ + return rb_check_string_type(str); +} + +static char* +str_nth_len(const char *p, const char *e, long *nthp, rb_encoding *enc) +{ + long nth = *nthp; + if (rb_enc_mbmaxlen(enc) == 1) { + p += nth; + } + else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { + p += nth * rb_enc_mbmaxlen(enc); + } + else if (rb_enc_asciicompat(enc)) { + const char *p2, *e2; + int n; + + while (p < e && 0 < nth) { + e2 = p + nth; + if (e < e2) { + *nthp = nth; + return (char *)e; + } + if (ISASCII(*p)) { + p2 = search_nonascii(p, e2); + if (!p2) { + nth -= e2 - p; + *nthp = nth; + return (char *)e2; + } + nth -= p2 - p; + p = p2; + } + n = rb_enc_mbclen(p, e, enc); + p += n; + nth--; + } + *nthp = nth; + if (nth != 0) { + return (char *)e; + } + return (char *)p; + } + else { + while (p < e && nth--) { + p += rb_enc_mbclen(p, e, enc); + } + } + if (p > e) p = e; + *nthp = nth; + return (char*)p; +} + +char* +rb_enc_nth(const char *p, const char *e, long nth, rb_encoding *enc) +{ + return str_nth_len(p, e, &nth, enc); +} + +static char* +str_nth(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte) +{ + if (singlebyte) + p += nth; + else { + p = str_nth_len(p, e, &nth, enc); + } + if (!p) return 0; + if (p > e) p = e; + return (char *)p; +} + +/* char offset to byte offset */ +static long +str_offset(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte) +{ + const char *pp = str_nth(p, e, nth, enc, singlebyte); + if (!pp) return e - p; + return pp - p; +} + +long +rb_str_offset(VALUE str, long pos) +{ + return str_offset(RSTRING_PTR(str), RSTRING_END(str), pos, + STR_ENC_GET(str), single_byte_optimizable(str)); +} + +#ifdef NONASCII_MASK +static char * +str_utf8_nth(const char *p, const char *e, long *nthp) +{ + long nth = *nthp; + if ((int)SIZEOF_VOIDP * 2 < e - p && (int)SIZEOF_VOIDP * 2 < nth) { + const uintptr_t *s, *t; + const uintptr_t lowbits = SIZEOF_VOIDP - 1; + s = (const uintptr_t*)(~lowbits & ((uintptr_t)p + lowbits)); + t = (const uintptr_t*)(~lowbits & (uintptr_t)e); + while (p < (const char *)s) { + if (is_utf8_lead_byte(*p)) nth--; + p++; + } + do { + nth -= count_utf8_lead_bytes_with_word(s); + s++; + } while (s < t && (int)SIZEOF_VOIDP <= nth); + p = (char *)s; + } + while (p < e) { + if (is_utf8_lead_byte(*p)) { + if (nth == 0) break; + nth--; + } + p++; + } + *nthp = nth; + return (char *)p; +} + +static long +str_utf8_offset(const char *p, const char *e, long nth) +{ + const char *pp = str_utf8_nth(p, e, &nth); + return pp - p; +} +#endif + +/* byte offset to char offset */ +long +rb_str_sublen(VALUE str, long pos) +{ + if (single_byte_optimizable(str) || pos < 0) + return pos; + else { + char *p = RSTRING_PTR(str); + return enc_strlen(p, p + pos, STR_ENC_GET(str), ENC_CODERANGE(str)); + } +} + +VALUE +rb_str_subseq(VALUE str, long beg, long len) +{ + VALUE str2; + + if (RSTRING_EMBED_LEN_MAX < len && SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) { + long olen; + str2 = rb_str_new_shared(rb_str_new_frozen(str)); + RSTRING(str2)->as.heap.ptr += beg; + olen = RSTRING(str2)->as.heap.len; + if (olen > len) RSTRING(str2)->as.heap.len = len; + } + else { + str2 = rb_str_new_with_class(str, RSTRING_PTR(str)+beg, len); + RB_GC_GUARD(str); + } + + rb_enc_cr_str_copy_for_substr(str2, str); + OBJ_INFECT(str2, str); + + return str2; +} + +char * +rb_str_subpos(VALUE str, long beg, long *lenp) +{ + long len = *lenp; + long slen = -1L; + long blen = RSTRING_LEN(str); + rb_encoding *enc = STR_ENC_GET(str); + char *p, *s = RSTRING_PTR(str), *e = s + blen; + + if (len < 0) return 0; + if (!blen) { + len = 0; + } + if (single_byte_optimizable(str)) { + if (beg > blen) return 0; + if (beg < 0) { + beg += blen; + if (beg < 0) return 0; + } + if (beg + len > blen) + len = blen - beg; + if (len < 0) return 0; + p = s + beg; + goto end; + } + if (beg < 0) { + if (len > -beg) len = -beg; + if (-beg * rb_enc_mbmaxlen(enc) < RSTRING_LEN(str) / 8) { + beg = -beg; + while (beg-- > len && (e = rb_enc_prev_char(s, e, e, enc)) != 0); + p = e; + if (!p) return 0; + while (len-- > 0 && (p = rb_enc_prev_char(s, p, e, enc)) != 0); + if (!p) return 0; + len = e - p; + goto end; + } + else { + slen = str_strlen(str, enc); + beg += slen; + if (beg < 0) return 0; + p = s + beg; + if (len == 0) goto end; + } + } + else if (beg > 0 && beg > RSTRING_LEN(str)) { + return 0; + } + if (len == 0) { + if (beg > str_strlen(str, enc)) return 0; /* str's enc */ + p = s + beg; + } +#ifdef NONASCII_MASK + else if (ENC_CODERANGE(str) == ENC_CODERANGE_VALID && + enc == rb_utf8_encoding()) { + p = str_utf8_nth(s, e, &beg); + if (beg > 0) return 0; + len = str_utf8_offset(p, e, len); + } +#endif + else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { + int char_sz = rb_enc_mbmaxlen(enc); + + p = s + beg * char_sz; + if (p > e) { + return 0; + } + else if (len * char_sz > e - p) + len = e - p; + else + len *= char_sz; + } + else if ((p = str_nth_len(s, e, &beg, enc)) == e) { + if (beg > 0) return 0; + len = 0; + } + else { + len = str_offset(p, e, len, enc, 0); + } + end: + *lenp = len; + RB_GC_GUARD(str); + return p; +} + +VALUE +rb_str_substr(VALUE str, long beg, long len) +{ + VALUE str2; + char *p = rb_str_subpos(str, beg, &len); + + if (!p) return Qnil; + if (len > RSTRING_EMBED_LEN_MAX && SHARABLE_SUBSTRING_P(p, len, RSTRING_END(str))) { + long ofs = p - RSTRING_PTR(str); + str2 = rb_str_new_frozen(str); + str2 = str_new_shared(rb_obj_class(str2), str2); + RSTRING(str2)->as.heap.ptr += ofs; + RSTRING(str2)->as.heap.len = len; + } + else { + str2 = rb_str_new_with_class(str, p, len); + OBJ_INFECT(str2, str); + RB_GC_GUARD(str); + } + rb_enc_cr_str_copy_for_substr(str2, str); + + return str2; +} + +VALUE +rb_str_freeze(VALUE str) +{ + if (OBJ_FROZEN(str)) return str; + rb_str_resize(str, RSTRING_LEN(str)); + return rb_obj_freeze(str); +} + +RUBY_ALIAS_FUNCTION(rb_str_dup_frozen(VALUE str), rb_str_new_frozen, (str)) +#define rb_str_dup_frozen rb_str_new_frozen + +VALUE +rb_str_locktmp(VALUE str) +{ + if (FL_TEST(str, STR_TMPLOCK)) { + rb_raise(rb_eRuntimeError, "temporal locking already locked string"); + } + FL_SET(str, STR_TMPLOCK); + return str; +} + +VALUE +rb_str_unlocktmp(VALUE str) +{ + if (!FL_TEST(str, STR_TMPLOCK)) { + rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string"); + } + FL_UNSET(str, STR_TMPLOCK); + return str; +} + +VALUE +rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg) +{ + rb_str_locktmp(str); + return rb_ensure(func, arg, rb_str_unlocktmp, str); +} + +void +rb_str_set_len(VALUE str, long len) +{ + long capa; + const int termlen = TERM_LEN(str); + + str_modifiable(str); + if (STR_SHARED_P(str)) { + rb_raise(rb_eRuntimeError, "can't set length of shared string"); + } + if (len + termlen - 1 > (capa = (long)rb_str_capacity(str))) { + rb_bug("probable buffer overflow: %ld for %ld", len, capa); + } + STR_SET_LEN(str, len); + TERM_FILL(&RSTRING_PTR(str)[len], termlen); +} + +VALUE +rb_str_resize(VALUE str, long len) +{ + long slen; + int independent; + + if (len < 0) { + rb_raise(rb_eArgError, "negative string size (or size too big)"); + } + + independent = str_independent(str); + ENC_CODERANGE_CLEAR(str); + slen = RSTRING_LEN(str); + + { + long capa; + const int termlen = TERM_LEN(str); + if (STR_EMBED_P(str)) { + if (len == slen) return str; + if (len + termlen <= RSTRING_EMBED_LEN_MAX + 1) { + STR_SET_EMBED_LEN(str, len); + TERM_FILL(RSTRING(str)->as.ary + len, termlen); + return str; + } + str_make_independent_expand(str, len - slen); + } + else if (len + termlen <= RSTRING_EMBED_LEN_MAX + 1) { + char *ptr = STR_HEAP_PTR(str); + STR_SET_EMBED(str); + if (slen > len) slen = len; + if (slen > 0) MEMCPY(RSTRING(str)->as.ary, ptr, char, slen); + TERM_FILL(RSTRING(str)->as.ary + len, termlen); + STR_SET_EMBED_LEN(str, len); + if (independent) ruby_xfree(ptr); + return str; + } + else if (!independent) { + if (len == slen) return str; + str_make_independent_expand(str, len - slen); + } + else if ((capa = RSTRING(str)->as.heap.aux.capa) < len || + (capa - len) > (len < 1024 ? len : 1024)) { + REALLOC_N(RSTRING(str)->as.heap.ptr, char, len + termlen); + RSTRING(str)->as.heap.aux.capa = len; + } + else if (len == slen) return str; + RSTRING(str)->as.heap.len = len; + TERM_FILL(RSTRING(str)->as.heap.ptr + len, termlen); /* sentinel */ + } + return str; +} + +static VALUE +str_buf_cat(VALUE str, const char *ptr, long len) +{ + long capa, total, olen, off = -1; + char *sptr; + const int termlen = TERM_LEN(str); + + RSTRING_GETMEM(str, sptr, olen); + if (ptr >= sptr && ptr <= sptr + olen) { + off = ptr - sptr; + } + rb_str_modify(str); + if (len == 0) return 0; + if (STR_EMBED_P(str)) { + capa = RSTRING_EMBED_LEN_MAX; + sptr = RSTRING(str)->as.ary; + olen = RSTRING_EMBED_LEN(str); + } + else { + capa = RSTRING(str)->as.heap.aux.capa; + sptr = RSTRING(str)->as.heap.ptr; + olen = RSTRING(str)->as.heap.len; + } + if (olen >= LONG_MAX - len) { + rb_raise(rb_eArgError, "string sizes too big"); + } + total = olen + len; + if (capa <= total) { + while (total > capa) { + if (capa > LONG_MAX / 2) { + capa = (total + 4095) / 4096 * 4096; + break; + } + capa = 2 * capa; + } + RESIZE_CAPA_TERM(str, capa, termlen); + sptr = RSTRING_PTR(str); + } + if (off != -1) { + ptr = sptr + off; + } + memcpy(sptr + olen, ptr, len); + STR_SET_LEN(str, total); + TERM_FILL(sptr + total, termlen); /* sentinel */ + + return str; +} + +#define str_buf_cat2(str, ptr) str_buf_cat((str), (ptr), strlen(ptr)) + +VALUE +rb_str_cat(VALUE str, const char *ptr, long len) +{ + if (len == 0) return str; + if (len < 0) { + rb_raise(rb_eArgError, "negative string size (or size too big)"); + } + return str_buf_cat(str, ptr, len); +} + +VALUE +rb_str_cat_cstr(VALUE str, const char *ptr) +{ + must_not_null(ptr); + return rb_str_buf_cat(str, ptr, strlen(ptr)); +} + +RUBY_ALIAS_FUNCTION(rb_str_buf_cat(VALUE str, const char *ptr, long len), rb_str_cat, (str, ptr, len)) +RUBY_ALIAS_FUNCTION(rb_str_buf_cat2(VALUE str, const char *ptr), rb_str_cat_cstr, (str, ptr)) +RUBY_ALIAS_FUNCTION(rb_str_cat2(VALUE str, const char *ptr), rb_str_cat_cstr, (str, ptr)) + +static VALUE +rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, + int ptr_encindex, int ptr_cr, int *ptr_cr_ret) +{ + int str_encindex = ENCODING_GET(str); + int res_encindex; + int str_cr, res_cr; + rb_encoding *str_enc, *ptr_enc; + + str_cr = RSTRING_LEN(str) ? ENC_CODERANGE(str) : ENC_CODERANGE_7BIT; + + if (str_encindex == ptr_encindex) { + if (str_cr != ENC_CODERANGE_UNKNOWN && ptr_cr == ENC_CODERANGE_UNKNOWN) { + ptr_cr = coderange_scan(ptr, len, rb_enc_from_index(ptr_encindex)); + } + } + else { + str_enc = rb_enc_from_index(str_encindex); + ptr_enc = rb_enc_from_index(ptr_encindex); + if (!rb_enc_asciicompat(str_enc) || !rb_enc_asciicompat(ptr_enc)) { + if (len == 0) + return str; + if (RSTRING_LEN(str) == 0) { + rb_str_buf_cat(str, ptr, len); + ENCODING_CODERANGE_SET(str, ptr_encindex, ptr_cr); + return str; + } + goto incompatible; + } + if (ptr_cr == ENC_CODERANGE_UNKNOWN) { + ptr_cr = coderange_scan(ptr, len, ptr_enc); + } + if (str_cr == ENC_CODERANGE_UNKNOWN) { + if (ENCODING_IS_ASCII8BIT(str) || ptr_cr != ENC_CODERANGE_7BIT) { + str_cr = rb_enc_str_coderange(str); + } + } + } + if (ptr_cr_ret) + *ptr_cr_ret = ptr_cr; + + if (str_encindex != ptr_encindex && + str_cr != ENC_CODERANGE_7BIT && + ptr_cr != ENC_CODERANGE_7BIT) { + str_enc = rb_enc_from_index(str_encindex); + ptr_enc = rb_enc_from_index(ptr_encindex); + incompatible: + rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", + rb_enc_name(str_enc), rb_enc_name(ptr_enc)); + } + + if (str_cr == ENC_CODERANGE_UNKNOWN) { + res_encindex = str_encindex; + res_cr = ENC_CODERANGE_UNKNOWN; + } + else if (str_cr == ENC_CODERANGE_7BIT) { + if (ptr_cr == ENC_CODERANGE_7BIT) { + res_encindex = str_encindex; + res_cr = ENC_CODERANGE_7BIT; + } + else { + res_encindex = ptr_encindex; + res_cr = ptr_cr; + } + } + else if (str_cr == ENC_CODERANGE_VALID) { + res_encindex = str_encindex; + if (ptr_cr == ENC_CODERANGE_7BIT || ptr_cr == ENC_CODERANGE_VALID) + res_cr = str_cr; + else + res_cr = ptr_cr; + } + else { /* str_cr == ENC_CODERANGE_BROKEN */ + res_encindex = str_encindex; + res_cr = str_cr; + if (0 < len) res_cr = ENC_CODERANGE_UNKNOWN; + } + + if (len < 0) { + rb_raise(rb_eArgError, "negative string size (or size too big)"); + } + str_buf_cat(str, ptr, len); + ENCODING_CODERANGE_SET(str, res_encindex, res_cr); + return str; +} + +VALUE +rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *ptr_enc) +{ + return rb_enc_cr_str_buf_cat(str, ptr, len, + rb_enc_to_index(ptr_enc), ENC_CODERANGE_UNKNOWN, NULL); +} + +VALUE +rb_str_buf_cat_ascii(VALUE str, const char *ptr) +{ + /* ptr must reference NUL terminated ASCII string. */ + int encindex = ENCODING_GET(str); + rb_encoding *enc = rb_enc_from_index(encindex); + if (rb_enc_asciicompat(enc)) { + return rb_enc_cr_str_buf_cat(str, ptr, strlen(ptr), + encindex, ENC_CODERANGE_7BIT, 0); + } + else { + char *buf = ALLOCA_N(char, rb_enc_mbmaxlen(enc)); + while (*ptr) { + unsigned int c = (unsigned char)*ptr; + int len = rb_enc_codelen(c, enc); + rb_enc_mbcput(c, buf, enc); + rb_enc_cr_str_buf_cat(str, buf, len, + encindex, ENC_CODERANGE_VALID, 0); + ptr++; + } + return str; + } +} + +VALUE +rb_str_buf_append(VALUE str, VALUE str2) +{ + int str2_cr; + + str2_cr = ENC_CODERANGE(str2); + + rb_enc_cr_str_buf_cat(str, RSTRING_PTR(str2), RSTRING_LEN(str2), + ENCODING_GET(str2), str2_cr, &str2_cr); + + OBJ_INFECT(str, str2); + ENC_CODERANGE_SET(str2, str2_cr); + + return str; +} + +VALUE +rb_str_append(VALUE str, VALUE str2) +{ + StringValue(str2); + return rb_str_buf_append(str, str2); +} + +/* + * call-seq: + * str << integer -> str + * str.concat(integer) -> str + * str << obj -> str + * str.concat(obj) -> str + * + * Append---Concatenates the given object to str. If the object is a + * Integer, it is considered as a codepoint, and is converted + * to a character before concatenation. + * + * a = "hello " + * a << "world" #=> "hello world" + * a.concat(33) #=> "hello world!" + */ + +VALUE +rb_str_concat(VALUE str1, VALUE str2) +{ + unsigned int code; + rb_encoding *enc = STR_ENC_GET(str1); + + if (FIXNUM_P(str2) || RB_TYPE_P(str2, T_BIGNUM)) { + if (rb_num_to_uint(str2, &code) == 0) { + } + else if (FIXNUM_P(str2)) { + rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(str2)); + } + else { + rb_raise(rb_eRangeError, "bignum out of char range"); + } + } + else { + return rb_str_append(str1, str2); + } + + if (enc == rb_usascii_encoding()) { + /* US-ASCII automatically extended to ASCII-8BIT */ + char buf[1]; + buf[0] = (char)code; + if (code > 0xFF) { + rb_raise(rb_eRangeError, "%u out of char range", code); + } + rb_str_cat(str1, buf, 1); + if (code > 127) { + rb_enc_associate(str1, rb_ascii8bit_encoding()); + ENC_CODERANGE_SET(str1, ENC_CODERANGE_VALID); + } + } + else { + long pos = RSTRING_LEN(str1); + int cr = ENC_CODERANGE(str1); + int len; + char *buf; + + switch (len = rb_enc_codelen(code, enc)) { + case ONIGERR_INVALID_CODE_POINT_VALUE: + rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc)); + break; + case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE: + case 0: + rb_raise(rb_eRangeError, "%u out of char range", code); + break; + } + buf = ALLOCA_N(char, len + 1); + rb_enc_mbcput(code, buf, enc); + if (rb_enc_precise_mbclen(buf, buf + len + 1, enc) != len) { + rb_raise(rb_eRangeError, "invalid codepoint 0x%X in %s", code, rb_enc_name(enc)); + } + rb_str_resize(str1, pos+len); + memcpy(RSTRING_PTR(str1) + pos, buf, len); + if (cr == ENC_CODERANGE_7BIT && code > 127) + cr = ENC_CODERANGE_VALID; + ENC_CODERANGE_SET(str1, cr); + } + return str1; +} + +/* + * call-seq: + * str.prepend(other_str) -> str + * + * Prepend---Prepend the given string to str. + * + * a = "world" + * a.prepend("hello ") #=> "hello world" + * a #=> "hello world" + */ + +static VALUE +rb_str_prepend(VALUE str, VALUE str2) +{ + StringValue(str2); + StringValue(str); + rb_str_update(str, 0L, 0L, str2); + return str; +} + +st_index_t +rb_str_hash(VALUE str) +{ + int e = ENCODING_GET(str); + if (e && rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) { + e = 0; + } + return rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str)) ^ e; +} + +int +rb_str_hash_cmp(VALUE str1, VALUE str2) +{ + long len; + + if (!rb_str_comparable(str1, str2)) return 1; + if (RSTRING_LEN(str1) == (len = RSTRING_LEN(str2)) && + memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len) == 0) { + return 0; + } + return 1; +} + +/* + * call-seq: + * str.hash -> fixnum + * + * Return a hash based on the string's length, content and encoding. + * + * See also Object#hash. + */ + +static VALUE +rb_str_hash_m(VALUE str) +{ + st_index_t hval = rb_str_hash(str); + return INT2FIX(hval); +} + +#define lesser(a,b) (((a)>(b))?(b):(a)) + +int +rb_str_comparable(VALUE str1, VALUE str2) +{ + int idx1, idx2; + int rc1, rc2; + + if (RSTRING_LEN(str1) == 0) return TRUE; + if (RSTRING_LEN(str2) == 0) return TRUE; + idx1 = ENCODING_GET(str1); + idx2 = ENCODING_GET(str2); + if (idx1 == idx2) return TRUE; + rc1 = rb_enc_str_coderange(str1); + rc2 = rb_enc_str_coderange(str2); + if (rc1 == ENC_CODERANGE_7BIT) { + if (rc2 == ENC_CODERANGE_7BIT) return TRUE; + if (rb_enc_asciicompat(rb_enc_from_index(idx2))) + return TRUE; + } + if (rc2 == ENC_CODERANGE_7BIT) { + if (rb_enc_asciicompat(rb_enc_from_index(idx1))) + return TRUE; + } + return FALSE; +} + +int +rb_str_cmp(VALUE str1, VALUE str2) +{ + long len1, len2; + const char *ptr1, *ptr2; + int retval; + + if (str1 == str2) return 0; + RSTRING_GETMEM(str1, ptr1, len1); + RSTRING_GETMEM(str2, ptr2, len2); + if (ptr1 == ptr2 || (retval = memcmp(ptr1, ptr2, lesser(len1, len2))) == 0) { + if (len1 == len2) { + if (!rb_str_comparable(str1, str2)) { + if (ENCODING_GET(str1) > ENCODING_GET(str2)) + return 1; + return -1; + } + return 0; + } + if (len1 > len2) return 1; + return -1; + } + if (retval > 0) return 1; + return -1; +} + +/* expect tail call optimization */ +static VALUE +str_eql(const VALUE str1, const VALUE str2) +{ + const long len = RSTRING_LEN(str1); + const char *ptr1, *ptr2; + + if (len != RSTRING_LEN(str2)) return Qfalse; + if (!rb_str_comparable(str1, str2)) return Qfalse; + if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2))) + return Qtrue; + if (memcmp(ptr1, ptr2, len) == 0) + return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * str == obj -> true or false + * str === obj -> true or false + * + * === Equality + * + * Returns whether +str+ == +obj+, similar to Object#==. + * + * If +obj+ is not an instance of String but responds to +to_str+, then the + * two strings are compared using case equality Object#===. + * + * Otherwise, returns similarly to String#eql?, comparing length and content. + */ + +VALUE +rb_str_equal(VALUE str1, VALUE str2) +{ + if (str1 == str2) return Qtrue; + if (!RB_TYPE_P(str2, T_STRING)) { + if (!rb_respond_to(str2, rb_intern("to_str"))) { + return Qfalse; + } + return rb_equal(str2, str1); + } + return str_eql(str1, str2); +} + +/* + * call-seq: + * str.eql?(other) -> true or false + * + * Two strings are equal if they have the same length and content. + */ + +static VALUE +rb_str_eql(VALUE str1, VALUE str2) +{ + if (str1 == str2) return Qtrue; + if (!RB_TYPE_P(str2, T_STRING)) return Qfalse; + return str_eql(str1, str2); +} + +/* + * call-seq: + * string <=> other_string -> -1, 0, +1 or nil + * + * + * Comparison---Returns -1, 0, +1 or nil depending on whether +string+ is less + * than, equal to, or greater than +other_string+. + * + * +nil+ is returned if the two values are incomparable. + * + * If the strings are of different lengths, and the strings are equal when + * compared up to the shortest length, then the longer string is considered + * greater than the shorter one. + * + * <=> is the basis for the methods <, + * <=, >, >=, and + * between?, included from module Comparable. The method + * String#== does not use Comparable#==. + * + * "abcdef" <=> "abcde" #=> 1 + * "abcdef" <=> "abcdef" #=> 0 + * "abcdef" <=> "abcdefg" #=> -1 + * "abcdef" <=> "ABCDEF" #=> 1 + */ + +static VALUE +rb_str_cmp_m(VALUE str1, VALUE str2) +{ + int result; + + if (!RB_TYPE_P(str2, T_STRING)) { + VALUE tmp = rb_check_funcall(str2, rb_intern("to_str"), 0, 0); + if (RB_TYPE_P(tmp, T_STRING)) { + result = rb_str_cmp(str1, tmp); + } + else { + return rb_invcmp(str1, str2); + } + } + else { + result = rb_str_cmp(str1, str2); + } + return INT2FIX(result); +} + +/* + * call-seq: + * str.casecmp(other_str) -> -1, 0, +1 or nil + * + * Case-insensitive version of String#<=>. + * + * "abcdef".casecmp("abcde") #=> 1 + * "aBcDeF".casecmp("abcdef") #=> 0 + * "abcdef".casecmp("abcdefg") #=> -1 + * "abcdef".casecmp("ABCDEF") #=> 0 + */ + +static VALUE +rb_str_casecmp(VALUE str1, VALUE str2) +{ + long len; + rb_encoding *enc; + char *p1, *p1end, *p2, *p2end; + + StringValue(str2); + enc = rb_enc_compatible(str1, str2); + if (!enc) { + return Qnil; + } + + p1 = RSTRING_PTR(str1); p1end = RSTRING_END(str1); + p2 = RSTRING_PTR(str2); p2end = RSTRING_END(str2); + if (single_byte_optimizable(str1) && single_byte_optimizable(str2)) { + while (p1 < p1end && p2 < p2end) { + if (*p1 != *p2) { + unsigned int c1 = TOUPPER(*p1 & 0xff); + unsigned int c2 = TOUPPER(*p2 & 0xff); + if (c1 != c2) + return INT2FIX(c1 < c2 ? -1 : 1); + } + p1++; + p2++; + } + } + else { + while (p1 < p1end && p2 < p2end) { + int l1, c1 = rb_enc_ascget(p1, p1end, &l1, enc); + int l2, c2 = rb_enc_ascget(p2, p2end, &l2, enc); + + if (0 <= c1 && 0 <= c2) { + c1 = TOUPPER(c1); + c2 = TOUPPER(c2); + if (c1 != c2) + return INT2FIX(c1 < c2 ? -1 : 1); + } + else { + int r; + l1 = rb_enc_mbclen(p1, p1end, enc); + l2 = rb_enc_mbclen(p2, p2end, enc); + len = l1 < l2 ? l1 : l2; + r = memcmp(p1, p2, len); + if (r != 0) + return INT2FIX(r < 0 ? -1 : 1); + if (l1 != l2) + return INT2FIX(l1 < l2 ? -1 : 1); + } + p1 += l1; + p2 += l2; + } + } + if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0); + if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1); + return INT2FIX(-1); +} + +#define rb_str_index(str, sub, offset) rb_strseq_index(str, sub, offset, 0) + +static long +rb_strseq_index(VALUE str, VALUE sub, long offset, int in_byte) +{ + const char *s, *sptr, *e; + long pos, len, slen; + int single_byte = single_byte_optimizable(str); + rb_encoding *enc; + + enc = rb_enc_check(str, sub); + if (is_broken_string(sub)) return -1; + + len = (in_byte || single_byte) ? RSTRING_LEN(str) : str_strlen(str, enc); /* rb_enc_check */ + slen = in_byte ? RSTRING_LEN(sub) : str_strlen(sub, enc); /* rb_enc_check */ + if (offset < 0) { + offset += len; + if (offset < 0) return -1; + } + if (len - offset < slen) return -1; + + s = RSTRING_PTR(str); + e = RSTRING_END(str); + if (offset) { + if (!in_byte) offset = str_offset(s, e, offset, enc, single_byte); + s += offset; + } + if (slen == 0) return offset; + /* need proceed one character at a time */ + sptr = RSTRING_PTR(sub); + slen = RSTRING_LEN(sub); + len = RSTRING_LEN(str) - offset; + for (;;) { + const char *t; + pos = rb_memsearch(sptr, slen, s, len, enc); + if (pos < 0) return pos; + t = rb_enc_right_char_head(s, s+pos, e, enc); + if (t == s + pos) break; + len -= t - s; + if (len <= 0) return -1; + offset += t - s; + s = t; + } + return pos + offset; +} + + +/* + * call-seq: + * str.index(substring [, offset]) -> fixnum or nil + * str.index(regexp [, offset]) -> fixnum or nil + * + * Returns the index of the first occurrence of the given substring or + * pattern (regexp) in str. Returns nil if not + * found. If the second parameter is present, it specifies the position in the + * string to begin the search. + * + * "hello".index('e') #=> 1 + * "hello".index('lo') #=> 3 + * "hello".index('a') #=> nil + * "hello".index(?e) #=> 1 + * "hello".index(/[aeiou]/, -3) #=> 4 + */ + +static VALUE +rb_str_index_m(int argc, VALUE *argv, VALUE str) +{ + VALUE sub; + VALUE initpos; + long pos; + + if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) { + pos = NUM2LONG(initpos); + } + else { + pos = 0; + } + if (pos < 0) { + pos += str_strlen(str, NULL); + if (pos < 0) { + if (RB_TYPE_P(sub, T_REGEXP)) { + rb_backref_set(Qnil); + } + return Qnil; + } + } + + if (SPECIAL_CONST_P(sub)) goto generic; + switch (BUILTIN_TYPE(sub)) { + case T_REGEXP: + if (pos > str_strlen(str, NULL)) + return Qnil; + pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos, + rb_enc_check(str, sub), single_byte_optimizable(str)); + + pos = rb_reg_search(sub, str, pos, 0); + pos = rb_str_sublen(str, pos); + break; + + generic: + default: { + VALUE tmp; + + tmp = rb_check_string_type(sub); + if (NIL_P(tmp)) { + rb_raise(rb_eTypeError, "type mismatch: %s given", + rb_obj_classname(sub)); + } + sub = tmp; + } + /* fall through */ + case T_STRING: + pos = rb_str_index(str, sub, pos); + pos = rb_str_sublen(str, pos); + break; + } + + if (pos == -1) return Qnil; + return LONG2NUM(pos); +} + +#ifdef HAVE_MEMRCHR +static long +str_rindex(VALUE str, VALUE sub, const char *s, long pos, rb_encoding *enc) +{ + char *hit, *adjusted; + int c; + long slen, searchlen; + char *sbeg, *e, *t; + + slen = RSTRING_LEN(sub); + if (slen == 0) return pos; + sbeg = RSTRING_PTR(str); + e = RSTRING_END(str); + t = RSTRING_PTR(sub); + c = *t & 0xff; + searchlen = s - sbeg + 1; + + do { + hit = memrchr(sbeg, c, searchlen); + if (!hit) break; + adjusted = rb_enc_left_char_head(sbeg, hit, e, enc); + if (hit != adjusted) { + searchlen = adjusted - sbeg; + continue; + } + if (memcmp(hit, t, slen) == 0) + return rb_str_sublen(str, hit - sbeg); + searchlen = adjusted - sbeg; + } while (searchlen > 0); + + return -1; +} +#else +static long +str_rindex(VALUE str, VALUE sub, const char *s, long pos, rb_encoding *enc) +{ + long slen; + char *sbeg, *e, *t; + + sbeg = RSTRING_PTR(str); + e = RSTRING_END(str); + t = RSTRING_PTR(sub); + slen = RSTRING_LEN(sub); + + while (s) { + if (memcmp(s, t, slen) == 0) { + return pos; + } + if (pos == 0) break; + pos--; + s = rb_enc_prev_char(sbeg, s, e, enc); + } + + return -1; +} +#endif + +static long +rb_str_rindex(VALUE str, VALUE sub, long pos) +{ + long len, slen; + char *sbeg, *s; + rb_encoding *enc; + int singlebyte; + + enc = rb_enc_check(str, sub); + if (is_broken_string(sub)) return -1; + singlebyte = single_byte_optimizable(str); + len = singlebyte ? RSTRING_LEN(str) : str_strlen(str, enc); /* rb_enc_check */ + slen = str_strlen(sub, enc); /* rb_enc_check */ + + /* substring longer than string */ + if (len < slen) return -1; + if (len - pos < slen) pos = len - slen; + if (len == 0) return pos; + + sbeg = RSTRING_PTR(str); + + if (pos == 0) { + if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0) + return 0; + else + return -1; + } + + s = str_nth(sbeg, RSTRING_END(str), pos, enc, singlebyte); + return str_rindex(str, sub, s, pos, enc); +} + + +/* + * call-seq: + * str.rindex(substring [, fixnum]) -> fixnum or nil + * str.rindex(regexp [, fixnum]) -> fixnum or nil + * + * Returns the index of the last occurrence of the given substring or + * pattern (regexp) in str. Returns nil if not + * found. If the second parameter is present, it specifies the position in the + * string to end the search---characters beyond this point will not be + * considered. + * + * "hello".rindex('e') #=> 1 + * "hello".rindex('l') #=> 3 + * "hello".rindex('a') #=> nil + * "hello".rindex(?e) #=> 1 + * "hello".rindex(/[aeiou]/, -2) #=> 1 + */ + +static VALUE +rb_str_rindex_m(int argc, VALUE *argv, VALUE str) +{ + VALUE sub; + VALUE vpos; + rb_encoding *enc = STR_ENC_GET(str); + long pos, len = str_strlen(str, enc); /* str's enc */ + + if (rb_scan_args(argc, argv, "11", &sub, &vpos) == 2) { + pos = NUM2LONG(vpos); + if (pos < 0) { + pos += len; + if (pos < 0) { + if (RB_TYPE_P(sub, T_REGEXP)) { + rb_backref_set(Qnil); + } + return Qnil; + } + } + if (pos > len) pos = len; + } + else { + pos = len; + } + + if (SPECIAL_CONST_P(sub)) goto generic; + switch (BUILTIN_TYPE(sub)) { + case T_REGEXP: + /* enc = rb_get_check(str, sub); */ + pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos, + enc, single_byte_optimizable(str)); + + if (!RREGEXP(sub)->ptr || RREGEXP_SRC_LEN(sub)) { + pos = rb_reg_search(sub, str, pos, 1); + pos = rb_str_sublen(str, pos); + } + if (pos >= 0) return LONG2NUM(pos); + break; + + generic: + default: { + VALUE tmp; + + tmp = rb_check_string_type(sub); + if (NIL_P(tmp)) { + rb_raise(rb_eTypeError, "type mismatch: %s given", + rb_obj_classname(sub)); + } + sub = tmp; + } + /* fall through */ + case T_STRING: + pos = rb_str_rindex(str, sub, pos); + if (pos >= 0) return LONG2NUM(pos); + break; + } + return Qnil; +} + +/* + * call-seq: + * str =~ obj -> fixnum or nil + * + * Match---If obj is a Regexp, use it as a pattern to match + * against str,and returns the position the match starts, or + * nil if there is no match. Otherwise, invokes + * obj.=~, passing str as an argument. The default + * =~ in Object returns nil. + * + * Note: str =~ regexp is not the same as + * regexp =~ str. Strings captured from named capture groups + * are assigned to local variables only in the second case. + * + * "cat o' 9 tails" =~ /\d/ #=> 7 + * "cat o' 9 tails" =~ 9 #=> nil + */ + +static VALUE +rb_str_match(VALUE x, VALUE y) +{ + if (SPECIAL_CONST_P(y)) goto generic; + switch (BUILTIN_TYPE(y)) { + case T_STRING: + rb_raise(rb_eTypeError, "type mismatch: String given"); + + case T_REGEXP: + return rb_reg_match(y, x); + + generic: + default: + return rb_funcall(y, rb_intern("=~"), 1, x); + } +} + + +static VALUE get_pat(VALUE); + + +/* + * call-seq: + * str.match(pattern) -> matchdata or nil + * str.match(pattern, pos) -> matchdata or nil + * + * Converts pattern to a Regexp (if it isn't already one), + * then invokes its match method on str. If the second + * parameter is present, it specifies the position in the string to begin the + * search. + * + * 'hello'.match('(.)\1') #=> # + * 'hello'.match('(.)\1')[0] #=> "ll" + * 'hello'.match(/(.)\1/)[0] #=> "ll" + * 'hello'.match('xx') #=> nil + * + * If a block is given, invoke the block with MatchData if match succeed, so + * that you can write + * + * str.match(pat) {|m| ...} + * + * instead of + * + * if m = str.match(pat) + * ... + * end + * + * The return value is a value from block execution in this case. + */ + +static VALUE +rb_str_match_m(int argc, VALUE *argv, VALUE str) +{ + VALUE re, result; + if (argc < 1) + rb_check_arity(argc, 1, 2); + re = argv[0]; + argv[0] = str; + result = rb_funcall2(get_pat(re), rb_intern("match"), argc, argv); + if (!NIL_P(result) && rb_block_given_p()) { + return rb_yield(result); + } + return result; +} + +enum neighbor_char { + NEIGHBOR_NOT_CHAR, + NEIGHBOR_FOUND, + NEIGHBOR_WRAPPED +}; + +static enum neighbor_char +enc_succ_char(char *p, long len, rb_encoding *enc) +{ + long i; + int l; + + if (rb_enc_mbminlen(enc) > 1) { + /* wchar, trivial case */ + int r = rb_enc_precise_mbclen(p, p + len, enc), c; + if (!MBCLEN_CHARFOUND_P(r)) { + return NEIGHBOR_NOT_CHAR; + } + c = rb_enc_mbc_to_codepoint(p, p + len, enc) + 1; + l = rb_enc_code_to_mbclen(c, enc); + if (!l) return NEIGHBOR_NOT_CHAR; + if (l != len) return NEIGHBOR_WRAPPED; + rb_enc_mbcput(c, p, enc); + r = rb_enc_precise_mbclen(p, p + len, enc); + if (!MBCLEN_CHARFOUND_P(r)) { + return NEIGHBOR_NOT_CHAR; + } + return NEIGHBOR_FOUND; + } + while (1) { + for (i = len-1; 0 <= i && (unsigned char)p[i] == 0xff; i--) + p[i] = '\0'; + if (i < 0) + return NEIGHBOR_WRAPPED; + ++((unsigned char*)p)[i]; + l = rb_enc_precise_mbclen(p, p+len, enc); + if (MBCLEN_CHARFOUND_P(l)) { + l = MBCLEN_CHARFOUND_LEN(l); + if (l == len) { + return NEIGHBOR_FOUND; + } + else { + memset(p+l, 0xff, len-l); + } + } + if (MBCLEN_INVALID_P(l) && i < len-1) { + long len2; + int l2; + for (len2 = len-1; 0 < len2; len2--) { + l2 = rb_enc_precise_mbclen(p, p+len2, enc); + if (!MBCLEN_INVALID_P(l2)) + break; + } + memset(p+len2+1, 0xff, len-(len2+1)); + } + } +} + +static enum neighbor_char +enc_pred_char(char *p, long len, rb_encoding *enc) +{ + long i; + int l; + if (rb_enc_mbminlen(enc) > 1) { + /* wchar, trivial case */ + int r = rb_enc_precise_mbclen(p, p + len, enc), c; + if (!MBCLEN_CHARFOUND_P(r)) { + return NEIGHBOR_NOT_CHAR; + } + c = rb_enc_mbc_to_codepoint(p, p + len, enc); + if (!c) return NEIGHBOR_NOT_CHAR; + --c; + l = rb_enc_code_to_mbclen(c, enc); + if (!l) return NEIGHBOR_NOT_CHAR; + if (l != len) return NEIGHBOR_WRAPPED; + rb_enc_mbcput(c, p, enc); + r = rb_enc_precise_mbclen(p, p + len, enc); + if (!MBCLEN_CHARFOUND_P(r)) { + return NEIGHBOR_NOT_CHAR; + } + return NEIGHBOR_FOUND; + } + while (1) { + for (i = len-1; 0 <= i && (unsigned char)p[i] == 0; i--) + p[i] = '\xff'; + if (i < 0) + return NEIGHBOR_WRAPPED; + --((unsigned char*)p)[i]; + l = rb_enc_precise_mbclen(p, p+len, enc); + if (MBCLEN_CHARFOUND_P(l)) { + l = MBCLEN_CHARFOUND_LEN(l); + if (l == len) { + return NEIGHBOR_FOUND; + } + else { + memset(p+l, 0, len-l); + } + } + if (MBCLEN_INVALID_P(l) && i < len-1) { + long len2; + int l2; + for (len2 = len-1; 0 < len2; len2--) { + l2 = rb_enc_precise_mbclen(p, p+len2, enc); + if (!MBCLEN_INVALID_P(l2)) + break; + } + memset(p+len2+1, 0, len-(len2+1)); + } + } +} + +/* + overwrite +p+ by succeeding letter in +enc+ and returns + NEIGHBOR_FOUND or NEIGHBOR_WRAPPED. + When NEIGHBOR_WRAPPED, carried-out letter is stored into carry. + assuming each ranges are successive, and mbclen + never change in each ranges. + NEIGHBOR_NOT_CHAR is returned if invalid character or the range has only one + character. + */ +static enum neighbor_char +enc_succ_alnum_char(char *p, long len, rb_encoding *enc, char *carry) +{ + enum neighbor_char ret; + unsigned int c; + int ctype; + int range; + char save[ONIGENC_CODE_TO_MBC_MAXLEN]; + + c = rb_enc_mbc_to_codepoint(p, p+len, enc); + if (rb_enc_isctype(c, ONIGENC_CTYPE_DIGIT, enc)) + ctype = ONIGENC_CTYPE_DIGIT; + else if (rb_enc_isctype(c, ONIGENC_CTYPE_ALPHA, enc)) + ctype = ONIGENC_CTYPE_ALPHA; + else + return NEIGHBOR_NOT_CHAR; + + MEMCPY(save, p, char, len); + ret = enc_succ_char(p, len, enc); + if (ret == NEIGHBOR_FOUND) { + c = rb_enc_mbc_to_codepoint(p, p+len, enc); + if (rb_enc_isctype(c, ctype, enc)) + return NEIGHBOR_FOUND; + } + MEMCPY(p, save, char, len); + range = 1; + while (1) { + MEMCPY(save, p, char, len); + ret = enc_pred_char(p, len, enc); + if (ret == NEIGHBOR_FOUND) { + c = rb_enc_mbc_to_codepoint(p, p+len, enc); + if (!rb_enc_isctype(c, ctype, enc)) { + MEMCPY(p, save, char, len); + break; + } + } + else { + MEMCPY(p, save, char, len); + break; + } + range++; + } + if (range == 1) { + return NEIGHBOR_NOT_CHAR; + } + + if (ctype != ONIGENC_CTYPE_DIGIT) { + MEMCPY(carry, p, char, len); + return NEIGHBOR_WRAPPED; + } + + MEMCPY(carry, p, char, len); + enc_succ_char(carry, len, enc); + return NEIGHBOR_WRAPPED; +} + + +static VALUE str_succ(VALUE str); + +/* + * call-seq: + * str.succ -> new_str + * str.next -> new_str + * + * Returns the successor to str. The successor is calculated by + * incrementing characters starting from the rightmost alphanumeric (or + * the rightmost character if there are no alphanumerics) in the + * string. Incrementing a digit always results in another digit, and + * incrementing a letter results in another letter of the same case. + * Incrementing nonalphanumerics uses the underlying character set's + * collating sequence. + * + * If the increment generates a ``carry,'' the character to the left of + * it is incremented. This process repeats until there is no carry, + * adding an additional character if necessary. + * + * "abcd".succ #=> "abce" + * "THX1138".succ #=> "THX1139" + * "<>".succ #=> "<>" + * "1999zzz".succ #=> "2000aaa" + * "ZZZ9999".succ #=> "AAAA0000" + * "***".succ #=> "**+" + */ + +VALUE +rb_str_succ(VALUE orig) +{ + VALUE str; + str = rb_str_new_with_class(orig, RSTRING_PTR(orig), RSTRING_LEN(orig)); + rb_enc_cr_str_copy_for_substr(str, orig); + OBJ_INFECT(str, orig); + return str_succ(str); +} + +static VALUE +str_succ(VALUE str) +{ + rb_encoding *enc; + char *sbeg, *s, *e, *last_alnum = 0; + int c = -1; + long l, slen; + char carry[ONIGENC_CODE_TO_MBC_MAXLEN] = "\1"; + long carry_pos = 0, carry_len = 1; + enum neighbor_char neighbor = NEIGHBOR_FOUND; + + slen = RSTRING_LEN(str); + if (slen == 0) return str; + + enc = STR_ENC_GET(str); + sbeg = RSTRING_PTR(str); + s = e = sbeg + slen; + + while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) { + if (neighbor == NEIGHBOR_NOT_CHAR && last_alnum) { + if (ISALPHA(*last_alnum) ? ISDIGIT(*s) : + ISDIGIT(*last_alnum) ? ISALPHA(*s) : 0) { + s = last_alnum; + break; + } + } + l = rb_enc_precise_mbclen(s, e, enc); + if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue; + l = ONIGENC_MBCLEN_CHARFOUND_LEN(l); + neighbor = enc_succ_alnum_char(s, l, enc, carry); + switch (neighbor) { + case NEIGHBOR_NOT_CHAR: + continue; + case NEIGHBOR_FOUND: + return str; + case NEIGHBOR_WRAPPED: + last_alnum = s; + break; + } + c = 1; + carry_pos = s - sbeg; + carry_len = l; + } + if (c == -1) { /* str contains no alnum */ + s = e; + while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) { + enum neighbor_char neighbor; + char tmp[ONIGENC_CODE_TO_MBC_MAXLEN]; + l = rb_enc_precise_mbclen(s, e, enc); + if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue; + l = ONIGENC_MBCLEN_CHARFOUND_LEN(l); + MEMCPY(tmp, s, char, l); + neighbor = enc_succ_char(tmp, l, enc); + switch (neighbor) { + case NEIGHBOR_FOUND: + MEMCPY(s, tmp, char, l); + return str; + break; + case NEIGHBOR_WRAPPED: + MEMCPY(s, tmp, char, l); + break; + case NEIGHBOR_NOT_CHAR: + break; + } + if (rb_enc_precise_mbclen(s, s+l, enc) != l) { + /* wrapped to \0...\0. search next valid char. */ + enc_succ_char(s, l, enc); + } + if (!rb_enc_asciicompat(enc)) { + MEMCPY(carry, s, char, l); + carry_len = l; + } + carry_pos = s - sbeg; + } + } + RESIZE_CAPA(str, slen + carry_len); + sbeg = RSTRING_PTR(str); + s = sbeg + carry_pos; + memmove(s + carry_len, s, slen - carry_pos); + memmove(s, carry, carry_len); + slen += carry_len; + STR_SET_LEN(str, slen); + TERM_FILL(&sbeg[slen], rb_enc_mbminlen(enc)); + rb_enc_str_coderange(str); + return str; +} + + +/* + * call-seq: + * str.succ! -> str + * str.next! -> str + * + * Equivalent to String#succ, but modifies the receiver in + * place. + */ + +static VALUE +rb_str_succ_bang(VALUE str) +{ + rb_str_modify(str); + str_succ(str); + return str; +} + + +/* + * call-seq: + * str.upto(other_str, exclusive=false) {|s| block } -> str + * str.upto(other_str, exclusive=false) -> an_enumerator + * + * Iterates through successive values, starting at str and + * ending at other_str inclusive, passing each value in turn to + * the block. The String#succ method is used to generate + * each value. If optional second argument exclusive is omitted or is false, + * the last value will be included; otherwise it will be excluded. + * + * If no block is given, an enumerator is returned instead. + * + * "a8".upto("b6") {|s| print s, ' ' } + * for s in "a8".."b6" + * print s, ' ' + * end + * + * produces: + * + * a8 a9 b0 b1 b2 b3 b4 b5 b6 + * a8 a9 b0 b1 b2 b3 b4 b5 b6 + * + * If str and other_str contains only ascii numeric characters, + * both are recognized as decimal numbers. In addition, the width of + * string (e.g. leading zeros) is handled appropriately. + * + * "9".upto("11").to_a #=> ["9", "10", "11"] + * "25".upto("5").to_a #=> [] + * "07".upto("11").to_a #=> ["07", "08", "09", "10", "11"] + */ + +static VALUE +rb_str_upto(int argc, VALUE *argv, VALUE beg) +{ + VALUE end, exclusive; + VALUE current, after_end; + ID succ; + int n, excl, ascii; + rb_encoding *enc; + + rb_scan_args(argc, argv, "11", &end, &exclusive); + RETURN_ENUMERATOR(beg, argc, argv); + excl = RTEST(exclusive); + CONST_ID(succ, "succ"); + StringValue(end); + enc = rb_enc_check(beg, end); + ascii = (is_ascii_string(beg) && is_ascii_string(end)); + /* single character */ + if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1 && ascii) { + char c = RSTRING_PTR(beg)[0]; + char e = RSTRING_PTR(end)[0]; + + if (c > e || (excl && c == e)) return beg; + for (;;) { + rb_yield(rb_enc_str_new(&c, 1, enc)); + if (!excl && c == e) break; + c++; + if (excl && c == e) break; + } + return beg; + } + /* both edges are all digits */ + if (ascii && ISDIGIT(RSTRING_PTR(beg)[0]) && ISDIGIT(RSTRING_PTR(end)[0])) { + char *s, *send; + VALUE b, e; + int width; + + s = RSTRING_PTR(beg); send = RSTRING_END(beg); + width = rb_long2int(send - s); + while (s < send) { + if (!ISDIGIT(*s)) goto no_digits; + s++; + } + s = RSTRING_PTR(end); send = RSTRING_END(end); + while (s < send) { + if (!ISDIGIT(*s)) goto no_digits; + s++; + } + b = rb_str_to_inum(beg, 10, FALSE); + e = rb_str_to_inum(end, 10, FALSE); + if (FIXNUM_P(b) && FIXNUM_P(e)) { + long bi = FIX2LONG(b); + long ei = FIX2LONG(e); + rb_encoding *usascii = rb_usascii_encoding(); + + while (bi <= ei) { + if (excl && bi == ei) break; + rb_yield(rb_enc_sprintf(usascii, "%.*ld", width, bi)); + bi++; + } + } + else { + ID op = excl ? '<' : rb_intern("<="); + VALUE args[2], fmt = rb_obj_freeze(rb_usascii_str_new_cstr("%.*d")); + + args[0] = INT2FIX(width); + while (rb_funcall(b, op, 1, e)) { + args[1] = b; + rb_yield(rb_str_format(numberof(args), args, fmt)); + b = rb_funcall(b, succ, 0, 0); + } + } + return beg; + } + /* normal case */ + no_digits: + n = rb_str_cmp(beg, end); + if (n > 0 || (excl && n == 0)) return beg; + + after_end = rb_funcall(end, succ, 0, 0); + current = rb_str_dup(beg); + while (!rb_str_equal(current, after_end)) { + VALUE next = Qnil; + if (excl || !rb_str_equal(current, end)) + next = rb_funcall(current, succ, 0, 0); + rb_yield(current); + if (NIL_P(next)) break; + current = next; + StringValue(current); + if (excl && rb_str_equal(current, end)) break; + if (RSTRING_LEN(current) > RSTRING_LEN(end) || RSTRING_LEN(current) == 0) + break; + } + + return beg; +} + +static VALUE +rb_str_subpat(VALUE str, VALUE re, VALUE backref) +{ + if (rb_reg_search(re, str, 0, 0) >= 0) { + VALUE match = rb_backref_get(); + int nth = rb_reg_backref_number(match, backref); + return rb_reg_nth_match(nth, match); + } + return Qnil; +} + +static VALUE +rb_str_aref(VALUE str, VALUE indx) +{ + long idx; + + if (FIXNUM_P(indx)) { + idx = FIX2LONG(indx); + + num_index: + str = rb_str_substr(str, idx, 1); + if (!NIL_P(str) && RSTRING_LEN(str) == 0) return Qnil; + return str; + } + + if (SPECIAL_CONST_P(indx)) goto generic; + switch (BUILTIN_TYPE(indx)) { + case T_REGEXP: + return rb_str_subpat(str, indx, INT2FIX(0)); + + case T_STRING: + if (rb_str_index(str, indx, 0) != -1) + return rb_str_dup(indx); + return Qnil; + + generic: + default: + /* check if indx is Range */ + { + long beg, len; + VALUE tmp; + + len = str_strlen(str, NULL); + switch (rb_range_beg_len(indx, &beg, &len, len, 0)) { + case Qfalse: + break; + case Qnil: + return Qnil; + default: + tmp = rb_str_substr(str, beg, len); + return tmp; + } + } + idx = NUM2LONG(indx); + goto num_index; + } + + UNREACHABLE; +} + + +/* + * call-seq: + * str[index] -> new_str or nil + * str[start, length] -> new_str or nil + * str[range] -> new_str or nil + * str[regexp] -> new_str or nil + * str[regexp, capture] -> new_str or nil + * str[match_str] -> new_str or nil + * str.slice(index) -> new_str or nil + * str.slice(start, length) -> new_str or nil + * str.slice(range) -> new_str or nil + * str.slice(regexp) -> new_str or nil + * str.slice(regexp, capture) -> new_str or nil + * str.slice(match_str) -> new_str or nil + * + * Element Reference --- If passed a single +index+, returns a substring of + * one character at that index. If passed a +start+ index and a +length+, + * returns a substring containing +length+ characters starting at the + * +index+. If passed a +range+, its beginning and end are interpreted as + * offsets delimiting the substring to be returned. + * + * In these three cases, if an index is negative, it is counted from the end + * of the string. For the +start+ and +range+ cases the starting index + * is just before a character and an index matching the string's size. + * Additionally, an empty string is returned when the starting index for a + * character range is at the end of the string. + * + * Returns +nil+ if the initial index falls outside the string or the length + * is negative. + * + * If a +Regexp+ is supplied, the matching portion of the string is + * returned. If a +capture+ follows the regular expression, which may be a + * capture group index or name, follows the regular expression that component + * of the MatchData is returned instead. + * + * If a +match_str+ is given, that string is returned if it occurs in + * the string. + * + * Returns +nil+ if the regular expression does not match or the match string + * cannot be found. + * + * a = "hello there" + * + * a[1] #=> "e" + * a[2, 3] #=> "llo" + * a[2..3] #=> "ll" + * + * a[-3, 2] #=> "er" + * a[7..-2] #=> "her" + * a[-4..-2] #=> "her" + * a[-2..-4] #=> "" + * + * a[11, 0] #=> "" + * a[11] #=> nil + * a[12, 0] #=> nil + * a[12..-1] #=> nil + * + * a[/[aeiou](.)\1/] #=> "ell" + * a[/[aeiou](.)\1/, 0] #=> "ell" + * a[/[aeiou](.)\1/, 1] #=> "l" + * a[/[aeiou](.)\1/, 2] #=> nil + * + * a[/(?[aeiou])(?[^aeiou])/, "non_vowel"] #=> "l" + * a[/(?[aeiou])(?[^aeiou])/, "vowel"] #=> "e" + * + * a["lo"] #=> "lo" + * a["bye"] #=> nil + */ + +static VALUE +rb_str_aref_m(int argc, VALUE *argv, VALUE str) +{ + if (argc == 2) { + if (RB_TYPE_P(argv[0], T_REGEXP)) { + return rb_str_subpat(str, argv[0], argv[1]); + } + return rb_str_substr(str, NUM2LONG(argv[0]), NUM2LONG(argv[1])); + } + rb_check_arity(argc, 1, 2); + return rb_str_aref(str, argv[0]); +} + +VALUE +rb_str_drop_bytes(VALUE str, long len) +{ + char *ptr = RSTRING_PTR(str); + long olen = RSTRING_LEN(str), nlen; + + str_modifiable(str); + if (len > olen) len = olen; + nlen = olen - len; + if (nlen <= RSTRING_EMBED_LEN_MAX) { + char *oldptr = ptr; + int fl = (int)(RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE)); + STR_SET_EMBED(str); + STR_SET_EMBED_LEN(str, nlen); + ptr = RSTRING(str)->as.ary; + memmove(ptr, oldptr + len, nlen); + if (fl == STR_NOEMBED) xfree(oldptr); + } + else { + if (!STR_SHARED_P(str)) rb_str_new_frozen(str); + ptr = RSTRING(str)->as.heap.ptr += len; + RSTRING(str)->as.heap.len = nlen; + } + ptr[nlen] = 0; + ENC_CODERANGE_CLEAR(str); + return str; +} + +static void +rb_str_splice_0(VALUE str, long beg, long len, VALUE val) +{ + char *sptr; + long slen, vlen = RSTRING_LEN(val); + + if (beg == 0 && vlen == 0) { + rb_str_drop_bytes(str, len); + OBJ_INFECT(str, val); + return; + } + + rb_str_modify(str); + RSTRING_GETMEM(str, sptr, slen); + if (len < vlen) { + /* expand string */ + RESIZE_CAPA(str, slen + vlen - len); + sptr = RSTRING_PTR(str); + } + + if (vlen != len) { + memmove(sptr + beg + vlen, + sptr + beg + len, + slen - (beg + len)); + } + if (vlen < beg && len < 0) { + MEMZERO(sptr + slen, char, -len); + } + if (vlen > 0) { + memmove(sptr + beg, RSTRING_PTR(val), vlen); + } + slen += vlen - len; + STR_SET_LEN(str, slen); + TERM_FILL(&sptr[slen], TERM_LEN(str)); + OBJ_INFECT(str, val); +} + +void +rb_str_update(VALUE str, long beg, long len, VALUE val) +{ + long slen; + char *p, *e; + rb_encoding *enc; + int singlebyte = single_byte_optimizable(str); + int cr; + + if (len < 0) rb_raise(rb_eIndexError, "negative length %ld", len); + + StringValue(val); + enc = rb_enc_check(str, val); + slen = str_strlen(str, enc); /* rb_enc_check */ + + if (slen < beg) { + out_of_range: + rb_raise(rb_eIndexError, "index %ld out of string", beg); + } + if (beg < 0) { + if (-beg > slen) { + goto out_of_range; + } + beg += slen; + } + if (slen < len || slen < beg + len) { + len = slen - beg; + } + str_modify_keep_cr(str); + p = str_nth(RSTRING_PTR(str), RSTRING_END(str), beg, enc, singlebyte); + if (!p) p = RSTRING_END(str); + e = str_nth(p, RSTRING_END(str), len, enc, singlebyte); + if (!e) e = RSTRING_END(str); + /* error check */ + beg = p - RSTRING_PTR(str); /* physical position */ + len = e - p; /* physical length */ + rb_str_splice_0(str, beg, len, val); + rb_enc_associate(str, enc); + cr = ENC_CODERANGE_AND(ENC_CODERANGE(str), ENC_CODERANGE(val)); + if (cr != ENC_CODERANGE_BROKEN) + ENC_CODERANGE_SET(str, cr); +} + +#define rb_str_splice(str, beg, len, val) rb_str_update(str, beg, len, val) + +static void +rb_str_subpat_set(VALUE str, VALUE re, VALUE backref, VALUE val) +{ + int nth; + VALUE match; + long start, end, len; + rb_encoding *enc; + struct re_registers *regs; + + if (rb_reg_search(re, str, 0, 0) < 0) { + rb_raise(rb_eIndexError, "regexp not matched"); + } + match = rb_backref_get(); + nth = rb_reg_backref_number(match, backref); + regs = RMATCH_REGS(match); + if (nth >= regs->num_regs) { + out_of_range: + rb_raise(rb_eIndexError, "index %d out of regexp", nth); + } + if (nth < 0) { + if (-nth >= regs->num_regs) { + goto out_of_range; + } + nth += regs->num_regs; + } + + start = BEG(nth); + if (start == -1) { + rb_raise(rb_eIndexError, "regexp group %d not matched", nth); + } + end = END(nth); + len = end - start; + StringValue(val); + enc = rb_enc_check(str, val); + rb_str_splice_0(str, start, len, val); + rb_enc_associate(str, enc); +} + +static VALUE +rb_str_aset(VALUE str, VALUE indx, VALUE val) +{ + long idx, beg; + + if (FIXNUM_P(indx)) { + idx = FIX2LONG(indx); + num_index: + rb_str_splice(str, idx, 1, val); + return val; + } + + if (SPECIAL_CONST_P(indx)) goto generic; + switch (TYPE(indx)) { + case T_REGEXP: + rb_str_subpat_set(str, indx, INT2FIX(0), val); + return val; + + case T_STRING: + beg = rb_str_index(str, indx, 0); + if (beg < 0) { + rb_raise(rb_eIndexError, "string not matched"); + } + beg = rb_str_sublen(str, beg); + rb_str_splice(str, beg, str_strlen(indx, NULL), val); + return val; + + generic: + default: + /* check if indx is Range */ + { + long beg, len; + if (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 2)) { + rb_str_splice(str, beg, len, val); + return val; + } + } + idx = NUM2LONG(indx); + goto num_index; + } +} + +/* + * call-seq: + * str[fixnum] = new_str + * str[fixnum, fixnum] = new_str + * str[range] = aString + * str[regexp] = new_str + * str[regexp, fixnum] = new_str + * str[regexp, name] = new_str + * str[other_str] = new_str + * + * Element Assignment---Replaces some or all of the content of str. The + * portion of the string affected is determined using the same criteria as + * String#[]. If the replacement string is not the same length as + * the text it is replacing, the string will be adjusted accordingly. If the + * regular expression or string is used as the index doesn't match a position + * in the string, IndexError is raised. If the regular expression + * form is used, the optional second Fixnum allows you to specify + * which portion of the match to replace (effectively using the + * MatchData indexing rules. The forms that take a + * Fixnum will raise an IndexError if the value is + * out of range; the Range form will raise a + * RangeError, and the Regexp and String + * will raise an IndexError on negative match. + */ + +static VALUE +rb_str_aset_m(int argc, VALUE *argv, VALUE str) +{ + if (argc == 3) { + if (RB_TYPE_P(argv[0], T_REGEXP)) { + rb_str_subpat_set(str, argv[0], argv[1], argv[2]); + } + else { + rb_str_splice(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]); + } + return argv[2]; + } + rb_check_arity(argc, 2, 3); + return rb_str_aset(str, argv[0], argv[1]); +} + +/* + * call-seq: + * str.insert(index, other_str) -> str + * + * Inserts other_str before the character at the given + * index, modifying str. Negative indices count from the + * end of the string, and insert after the given character. + * The intent is insert aString so that it starts at the given + * index. + * + * "abcd".insert(0, 'X') #=> "Xabcd" + * "abcd".insert(3, 'X') #=> "abcXd" + * "abcd".insert(4, 'X') #=> "abcdX" + * "abcd".insert(-3, 'X') #=> "abXcd" + * "abcd".insert(-1, 'X') #=> "abcdX" + */ + +static VALUE +rb_str_insert(VALUE str, VALUE idx, VALUE str2) +{ + long pos = NUM2LONG(idx); + + if (pos == -1) { + return rb_str_append(str, str2); + } + else if (pos < 0) { + pos++; + } + rb_str_splice(str, pos, 0, str2); + return str; +} + + +/* + * call-seq: + * str.slice!(fixnum) -> new_str or nil + * str.slice!(fixnum, fixnum) -> new_str or nil + * str.slice!(range) -> new_str or nil + * str.slice!(regexp) -> new_str or nil + * str.slice!(other_str) -> new_str or nil + * + * Deletes the specified portion from str, and returns the portion + * deleted. + * + * string = "this is a string" + * string.slice!(2) #=> "i" + * string.slice!(3..6) #=> " is " + * string.slice!(/s.*t/) #=> "sa st" + * string.slice!("r") #=> "r" + * string #=> "thing" + */ + +static VALUE +rb_str_slice_bang(int argc, VALUE *argv, VALUE str) +{ + VALUE result; + VALUE buf[3]; + int i; + + rb_check_arity(argc, 1, 2); + for (i=0; i= 0) { + VALUE match; + str = rb_str_new_frozen(str); + rb_backref_set_string(str, pos, RSTRING_LEN(pat)); + match = rb_backref_get(); + OBJ_INFECT(match, pat); + } + else { + rb_backref_set(Qnil); + } + } + return pos; + } + else { + return rb_reg_search0(pat, str, pos, 0, set_backref_str); + } +} + + +/* + * call-seq: + * str.sub!(pattern, replacement) -> str or nil + * str.sub!(pattern) {|match| block } -> str or nil + * + * Performs the same substitution as String#sub in-place. + * + * Returns +str+ if a substitution was performed or +nil+ if no substitution + * was performed. + */ + +static VALUE +rb_str_sub_bang(int argc, VALUE *argv, VALUE str) +{ + VALUE pat, repl, hash = Qnil; + int iter = 0; + int tainted = 0; + long plen; + int min_arity = rb_block_given_p() ? 1 : 2; + long beg; + + rb_check_arity(argc, min_arity, 2); + if (argc == 1) { + iter = 1; + } + else { + repl = argv[1]; + hash = rb_check_hash_type(argv[1]); + if (NIL_P(hash)) { + StringValue(repl); + } + if (OBJ_TAINTED(repl)) tainted = 1; + } + + pat = get_pat_quoted(argv[0], 1); + + str_modifiable(str); + beg = rb_pat_search(pat, str, 0, 1); + if (beg >= 0) { + rb_encoding *enc; + int cr = ENC_CODERANGE(str); + long beg0, end0; + VALUE match, match0 = Qnil; + struct re_registers *regs; + char *p, *rp; + long len, rlen; + + match = rb_backref_get(); + regs = RMATCH_REGS(match); + if (RB_TYPE_P(pat, T_STRING)) { + beg0 = beg; + end0 = beg0 + RSTRING_LEN(pat); + match0 = pat; + } + else { + beg0 = BEG(0); + end0 = END(0); + if (iter) match0 = rb_reg_nth_match(0, match); + } + + if (iter || !NIL_P(hash)) { + p = RSTRING_PTR(str); len = RSTRING_LEN(str); + + if (iter) { + repl = rb_obj_as_string(rb_yield(match0)); + } + else { + repl = rb_hash_aref(hash, rb_str_subseq(str, beg0, end0 - beg0)); + repl = rb_obj_as_string(repl); + } + str_mod_check(str, p, len); + rb_check_frozen(str); + } + else { + repl = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat); + } + + enc = rb_enc_compatible(str, repl); + if (!enc) { + rb_encoding *str_enc = STR_ENC_GET(str); + p = RSTRING_PTR(str); len = RSTRING_LEN(str); + if (coderange_scan(p, beg0, str_enc) != ENC_CODERANGE_7BIT || + coderange_scan(p+end0, len-end0, str_enc) != ENC_CODERANGE_7BIT) { + rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", + rb_enc_name(str_enc), + rb_enc_name(STR_ENC_GET(repl))); + } + enc = STR_ENC_GET(repl); + } + rb_str_modify(str); + rb_enc_associate(str, enc); + if (OBJ_TAINTED(repl)) tainted = 1; + if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) { + int cr2 = ENC_CODERANGE(repl); + if (cr2 == ENC_CODERANGE_BROKEN || + (cr == ENC_CODERANGE_VALID && cr2 == ENC_CODERANGE_7BIT)) + cr = ENC_CODERANGE_UNKNOWN; + else + cr = cr2; + } + plen = end0 - beg0; + rp = RSTRING_PTR(repl); rlen = RSTRING_LEN(repl); + len = RSTRING_LEN(str); + if (rlen > plen) { + RESIZE_CAPA(str, len + rlen - plen); + } + p = RSTRING_PTR(str); + if (rlen != plen) { + memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen); + } + memcpy(p + beg0, rp, rlen); + len += rlen - plen; + STR_SET_LEN(str, len); + TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str)); + ENC_CODERANGE_SET(str, cr); + if (tainted) OBJ_TAINT(str); + + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.sub(pattern, replacement) -> new_str + * str.sub(pattern, hash) -> new_str + * str.sub(pattern) {|match| block } -> new_str + * + * Returns a copy of +str+ with the _first_ occurrence of +pattern+ + * replaced by the second argument. The +pattern+ is typically a Regexp; if + * given as a String, any regular expression metacharacters it contains will + * be interpreted literally, e.g. '\\\d' will match a backlash + * followed by 'd', instead of a digit. + * + * If +replacement+ is a String it will be substituted for the matched text. + * It may contain back-references to the pattern's capture groups of the form + * "\\d", where d is a group number, or + * "\\k", where n is a group name. If it is a + * double-quoted string, both back-references must be preceded by an + * additional backslash. However, within +replacement+ the special match + * variables, such as &$, will not refer to the current match. + * If +replacement+ is a String that looks like a pattern's capture group but + * is actaully not a pattern capture group e.g. "\\'", then it + * will have to be preceded by two backslashes like so "\\\\'". + * + * If the second argument is a Hash, and the matched text is one of its keys, + * the corresponding value is the replacement string. + * + * In the block form, the current match string is passed in as a parameter, + * and variables such as $1, $2, $`, + * $&, and $' will be set appropriately. The value + * returned by the block will be substituted for the match on each call. + * + * The result inherits any tainting in the original string or any supplied + * replacement string. + * + * "hello".sub(/[aeiou]/, '*') #=> "h*llo" + * "hello".sub(/([aeiou])/, '<\1>') #=> "hllo" + * "hello".sub(/./) {|s| s.ord.to_s + ' ' } #=> "104 ello" + * "hello".sub(/(?[aeiou])/, '*\k*') #=> "h*e*llo" + * 'Is SHELL your preferred shell?'.sub(/[[:upper:]]{2,}/, ENV) + * #=> "Is /bin/bash your preferred shell?" + */ + +static VALUE +rb_str_sub(int argc, VALUE *argv, VALUE str) +{ + str = rb_str_dup(str); + rb_str_sub_bang(argc, argv, str); + return str; +} + +static VALUE +str_gsub(int argc, VALUE *argv, VALUE str, int bang) +{ + VALUE pat, val = Qnil, repl, match, match0 = Qnil, dest, hash = Qnil; + struct re_registers *regs; + long beg, n; + long beg0, end0; + long offset, blen, slen, len, last; + enum {STR, ITER, MAP} mode = STR; + char *sp, *cp; + int tainted = 0; + int need_backref = -1; + rb_encoding *str_enc; + + switch (argc) { + case 1: + RETURN_ENUMERATOR(str, argc, argv); + mode = ITER; + break; + case 2: + repl = argv[1]; + hash = rb_check_hash_type(argv[1]); + if (NIL_P(hash)) { + StringValue(repl); + } + else { + mode = MAP; + } + if (OBJ_TAINTED(repl)) tainted = 1; + break; + default: + rb_check_arity(argc, 1, 2); + } + + pat = get_pat_quoted(argv[0], 1); + beg = rb_pat_search(pat, str, 0, need_backref); + if (beg < 0) { + if (bang) return Qnil; /* no match, no substitution */ + return rb_str_dup(str); + } + + offset = 0; + n = 0; + blen = RSTRING_LEN(str) + 30; /* len + margin */ + dest = rb_str_buf_new(blen); + sp = RSTRING_PTR(str); + slen = RSTRING_LEN(str); + cp = sp; + str_enc = STR_ENC_GET(str); + rb_enc_associate(dest, str_enc); + ENC_CODERANGE_SET(dest, rb_enc_asciicompat(str_enc) ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID); + + do { + n++; + + match = rb_backref_get(); + regs = RMATCH_REGS(match); + if (RB_TYPE_P(pat, T_STRING)) { + beg0 = beg; + end0 = beg0 + RSTRING_LEN(pat); + match0 = pat; + } + else { + beg0 = BEG(0); + end0 = END(0); + if (mode == ITER) match0 = rb_reg_nth_match(0, match); + } + + if (mode) { + if (mode == ITER) { + val = rb_obj_as_string(rb_yield(match0)); + } + else { + val = rb_hash_aref(hash, rb_str_subseq(str, beg0, end0 - beg0)); + val = rb_obj_as_string(val); + } + str_mod_check(str, sp, slen); + if (val == dest) { /* paranoid check [ruby-dev:24827] */ + rb_raise(rb_eRuntimeError, "block should not cheat"); + } + } + else if (need_backref) { + val = rb_reg_regsub(repl, str, regs, RB_TYPE_P(pat, T_STRING) ? Qnil : pat); + if (need_backref < 0) { + need_backref = val != repl; + } + } + else { + val = repl; + } + + + if (OBJ_TAINTED(val)) tainted = 1; + + len = beg0 - offset; /* copy pre-match substr */ + if (len) { + rb_enc_str_buf_cat(dest, cp, len, str_enc); + } + + rb_str_buf_append(dest, val); + + last = offset; + offset = end0; + if (beg0 == end0) { + /* + * Always consume at least one character of the input string + * in order to prevent infinite loops. + */ + if (RSTRING_LEN(str) <= end0) break; + len = rb_enc_fast_mbclen(RSTRING_PTR(str)+end0, RSTRING_END(str), str_enc); + rb_enc_str_buf_cat(dest, RSTRING_PTR(str)+end0, len, str_enc); + offset = end0 + len; + } + cp = RSTRING_PTR(str) + offset; + if (offset > RSTRING_LEN(str)) break; + beg = rb_pat_search(pat, str, offset, need_backref); + } while (beg >= 0); + if (RSTRING_LEN(str) > offset) { + rb_enc_str_buf_cat(dest, cp, RSTRING_LEN(str) - offset, str_enc); + } + rb_pat_search(pat, str, last, 1); + if (bang) { + rb_str_shared_replace(str, dest); + } + else { + RBASIC_SET_CLASS(dest, rb_obj_class(str)); + OBJ_INFECT(dest, str); + str = dest; + } + + if (tainted) OBJ_TAINT(str); + return str; +} + + +/* + * call-seq: + * str.gsub!(pattern, replacement) -> str or nil + * str.gsub!(pattern) {|match| block } -> str or nil + * str.gsub!(pattern) -> an_enumerator + * + * Performs the substitutions of String#gsub in place, returning + * str, or nil if no substitutions were performed. + * If no block and no replacement is given, an enumerator is returned instead. + */ + +static VALUE +rb_str_gsub_bang(int argc, VALUE *argv, VALUE str) +{ + str_modify_keep_cr(str); + return str_gsub(argc, argv, str, 1); +} + + +/* + * call-seq: + * str.gsub(pattern, replacement) -> new_str + * str.gsub(pattern, hash) -> new_str + * str.gsub(pattern) {|match| block } -> new_str + * str.gsub(pattern) -> enumerator + * + * Returns a copy of str with the all occurrences of + * pattern substituted for the second argument. The pattern is + * typically a Regexp; if given as a String, any + * regular expression metacharacters it contains will be interpreted + * literally, e.g. '\\\d' will match a backlash followed by 'd', + * instead of a digit. + * + * If replacement is a String it will be substituted for + * the matched text. It may contain back-references to the pattern's capture + * groups of the form \\\d, where d is a group number, or + * \\\k, where n is a group name. If it is a + * double-quoted string, both back-references must be preceded by an + * additional backslash. However, within replacement the special match + * variables, such as $&, will not refer to the current match. + * + * If the second argument is a Hash, and the matched text is one + * of its keys, the corresponding value is the replacement string. + * + * In the block form, the current match string is passed in as a parameter, + * and variables such as $1, $2, $`, + * $&, and $' will be set appropriately. The value + * returned by the block will be substituted for the match on each call. + * + * The result inherits any tainting in the original string or any supplied + * replacement string. + * + * When neither a block nor a second argument is supplied, an + * Enumerator is returned. + * + * "hello".gsub(/[aeiou]/, '*') #=> "h*ll*" + * "hello".gsub(/([aeiou])/, '<\1>') #=> "hll" + * "hello".gsub(/./) {|s| s.ord.to_s + ' '} #=> "104 101 108 108 111 " + * "hello".gsub(/(?[aeiou])/, '{\k}') #=> "h{e}ll{o}" + * 'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*') #=> "h3ll*" + */ + +static VALUE +rb_str_gsub(int argc, VALUE *argv, VALUE str) +{ + return str_gsub(argc, argv, str, 0); +} + + +/* + * call-seq: + * str.replace(other_str) -> str + * + * Replaces the contents and taintedness of str with the corresponding + * values in other_str. + * + * s = "hello" #=> "hello" + * s.replace "world" #=> "world" + */ + +VALUE +rb_str_replace(VALUE str, VALUE str2) +{ + str_modifiable(str); + if (str == str2) return str; + + StringValue(str2); + str_discard(str); + return str_replace(str, str2); +} + +/* + * call-seq: + * string.clear -> string + * + * Makes string empty. + * + * a = "abcde" + * a.clear #=> "" + */ + +static VALUE +rb_str_clear(VALUE str) +{ + str_discard(str); + STR_SET_EMBED(str); + STR_SET_EMBED_LEN(str, 0); + RSTRING_PTR(str)[0] = 0; + if (rb_enc_asciicompat(STR_ENC_GET(str))) + ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); + else + ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); + return str; +} + +/* + * call-seq: + * string.chr -> string + * + * Returns a one-character string at the beginning of the string. + * + * a = "abcde" + * a.chr #=> "a" + */ + +static VALUE +rb_str_chr(VALUE str) +{ + return rb_str_substr(str, 0, 1); +} + +/* + * call-seq: + * str.getbyte(index) -> 0 .. 255 + * + * returns the indexth byte as an integer. + */ +static VALUE +rb_str_getbyte(VALUE str, VALUE index) +{ + long pos = NUM2LONG(index); + + if (pos < 0) + pos += RSTRING_LEN(str); + if (pos < 0 || RSTRING_LEN(str) <= pos) + return Qnil; + + return INT2FIX((unsigned char)RSTRING_PTR(str)[pos]); +} + +/* + * call-seq: + * str.setbyte(index, integer) -> integer + * + * modifies the indexth byte as integer. + */ +static VALUE +rb_str_setbyte(VALUE str, VALUE index, VALUE value) +{ + long pos = NUM2LONG(index); + int byte = NUM2INT(value); + + rb_str_modify(str); + + if (pos < -RSTRING_LEN(str) || RSTRING_LEN(str) <= pos) + rb_raise(rb_eIndexError, "index %ld out of string", pos); + if (pos < 0) + pos += RSTRING_LEN(str); + + RSTRING_PTR(str)[pos] = byte; + + return value; +} + +static VALUE +str_byte_substr(VALUE str, long beg, long len) +{ + char *p, *s = RSTRING_PTR(str); + long n = RSTRING_LEN(str); + VALUE str2; + + if (beg > n || len < 0) return Qnil; + if (beg < 0) { + beg += n; + if (beg < 0) return Qnil; + } + if (beg + len > n) + len = n - beg; + if (len <= 0) { + len = 0; + p = 0; + } + else + p = s + beg; + + if (len > RSTRING_EMBED_LEN_MAX && SHARABLE_SUBSTRING_P(beg, len, n)) { + str2 = rb_str_new_frozen(str); + str2 = str_new_shared(rb_obj_class(str2), str2); + RSTRING(str2)->as.heap.ptr += beg; + RSTRING(str2)->as.heap.len = len; + } + else { + str2 = rb_str_new_with_class(str, p, len); + } + + str_enc_copy(str2, str); + + if (RSTRING_LEN(str2) == 0) { + if (!rb_enc_asciicompat(STR_ENC_GET(str))) + ENC_CODERANGE_SET(str2, ENC_CODERANGE_VALID); + else + ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT); + } + else { + switch (ENC_CODERANGE(str)) { + case ENC_CODERANGE_7BIT: + ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT); + break; + default: + ENC_CODERANGE_SET(str2, ENC_CODERANGE_UNKNOWN); + break; + } + } + + OBJ_INFECT(str2, str); + + return str2; +} + +static VALUE +str_byte_aref(VALUE str, VALUE indx) +{ + long idx; + switch (TYPE(indx)) { + case T_FIXNUM: + idx = FIX2LONG(indx); + + num_index: + str = str_byte_substr(str, idx, 1); + if (NIL_P(str) || RSTRING_LEN(str) == 0) return Qnil; + return str; + + default: + /* check if indx is Range */ + { + long beg, len = RSTRING_LEN(str); + + switch (rb_range_beg_len(indx, &beg, &len, len, 0)) { + case Qfalse: + break; + case Qnil: + return Qnil; + default: + return str_byte_substr(str, beg, len); + } + } + idx = NUM2LONG(indx); + goto num_index; + } + + UNREACHABLE; +} + +/* + * call-seq: + * str.byteslice(fixnum) -> new_str or nil + * str.byteslice(fixnum, fixnum) -> new_str or nil + * str.byteslice(range) -> new_str or nil + * + * Byte Reference---If passed a single Fixnum, returns a + * substring of one byte at that position. If passed two Fixnum + * objects, returns a substring starting at the offset given by the first, and + * a length given by the second. If given a Range, a substring containing + * bytes at offsets given by the range is returned. In all three cases, if + * an offset is negative, it is counted from the end of str. Returns + * nil if the initial offset falls outside the string, the length + * is negative, or the beginning of the range is greater than the end. + * The encoding of the resulted string keeps original encoding. + * + * "hello".byteslice(1) #=> "e" + * "hello".byteslice(-1) #=> "o" + * "hello".byteslice(1, 2) #=> "el" + * "\x80\u3042".byteslice(1, 3) #=> "\u3042" + * "\x03\u3042\xff".byteslice(1..3) #=> "\u3042" + */ + +static VALUE +rb_str_byteslice(int argc, VALUE *argv, VALUE str) +{ + if (argc == 2) { + return str_byte_substr(str, NUM2LONG(argv[0]), NUM2LONG(argv[1])); + } + rb_check_arity(argc, 1, 2); + return str_byte_aref(str, argv[0]); +} + +/* + * call-seq: + * str.reverse -> new_str + * + * Returns a new string with the characters from str in reverse order. + * + * "stressed".reverse #=> "desserts" + */ + +static VALUE +rb_str_reverse(VALUE str) +{ + rb_encoding *enc; + VALUE rev; + char *s, *e, *p; + int cr; + + if (RSTRING_LEN(str) <= 1) return rb_str_dup(str); + enc = STR_ENC_GET(str); + rev = rb_str_new_with_class(str, 0, RSTRING_LEN(str)); + s = RSTRING_PTR(str); e = RSTRING_END(str); + p = RSTRING_END(rev); + cr = ENC_CODERANGE(str); + + if (RSTRING_LEN(str) > 1) { + if (single_byte_optimizable(str)) { + while (s < e) { + *--p = *s++; + } + } + else if (cr == ENC_CODERANGE_VALID) { + while (s < e) { + int clen = rb_enc_fast_mbclen(s, e, enc); + + p -= clen; + memcpy(p, s, clen); + s += clen; + } + } + else { + cr = rb_enc_asciicompat(enc) ? + ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID; + while (s < e) { + int clen = rb_enc_mbclen(s, e, enc); + + if (clen > 1 || (*s & 0x80)) cr = ENC_CODERANGE_UNKNOWN; + p -= clen; + memcpy(p, s, clen); + s += clen; + } + } + } + STR_SET_LEN(rev, RSTRING_LEN(str)); + OBJ_INFECT(rev, str); + str_enc_copy(rev, str); + ENC_CODERANGE_SET(rev, cr); + + return rev; +} + + +/* + * call-seq: + * str.reverse! -> str + * + * Reverses str in place. + */ + +static VALUE +rb_str_reverse_bang(VALUE str) +{ + if (RSTRING_LEN(str) > 1) { + if (single_byte_optimizable(str)) { + char *s, *e, c; + + str_modify_keep_cr(str); + s = RSTRING_PTR(str); + e = RSTRING_END(str) - 1; + while (s < e) { + c = *s; + *s++ = *e; + *e-- = c; + } + } + else { + rb_str_shared_replace(str, rb_str_reverse(str)); + } + } + else { + str_modify_keep_cr(str); + } + return str; +} + + +/* + * call-seq: + * str.include? other_str -> true or false + * + * Returns true if str contains the given string or + * character. + * + * "hello".include? "lo" #=> true + * "hello".include? "ol" #=> false + * "hello".include? ?h #=> true + */ + +static VALUE +rb_str_include(VALUE str, VALUE arg) +{ + long i; + + StringValue(arg); + i = rb_str_index(str, arg, 0); + + if (i == -1) return Qfalse; + return Qtrue; +} + + +/* + * call-seq: + * str.to_i(base=10) -> integer + * + * Returns the result of interpreting leading characters in str as an + * integer base base (between 2 and 36). Extraneous characters past the + * end of a valid number are ignored. If there is not a valid number at the + * start of str, 0 is returned. This method never raises an + * exception when base is valid. + * + * "12345".to_i #=> 12345 + * "99 red balloons".to_i #=> 99 + * "0a".to_i #=> 0 + * "0a".to_i(16) #=> 10 + * "hello".to_i #=> 0 + * "1100101".to_i(2) #=> 101 + * "1100101".to_i(8) #=> 294977 + * "1100101".to_i(10) #=> 1100101 + * "1100101".to_i(16) #=> 17826049 + */ + +static VALUE +rb_str_to_i(int argc, VALUE *argv, VALUE str) +{ + int base; + + if (argc == 0) base = 10; + else { + VALUE b; + + rb_scan_args(argc, argv, "01", &b); + base = NUM2INT(b); + } + if (base < 0) { + rb_raise(rb_eArgError, "invalid radix %d", base); + } + return rb_str_to_inum(str, base, FALSE); +} + + +/* + * call-seq: + * str.to_f -> float + * + * Returns the result of interpreting leading characters in str as a + * floating point number. Extraneous characters past the end of a valid number + * are ignored. If there is not a valid number at the start of str, + * 0.0 is returned. This method never raises an exception. + * + * "123.45e1".to_f #=> 1234.5 + * "45.67 degrees".to_f #=> 45.67 + * "thx1138".to_f #=> 0.0 + */ + +static VALUE +rb_str_to_f(VALUE str) +{ + return DBL2NUM(rb_str_to_dbl(str, FALSE)); +} + + +/* + * call-seq: + * str.to_s -> str + * str.to_str -> str + * + * Returns the receiver. + */ + +static VALUE +rb_str_to_s(VALUE str) +{ + if (rb_obj_class(str) != rb_cString) { + return str_duplicate(rb_cString, str); + } + return str; +} + +#if 0 +static void +str_cat_char(VALUE str, unsigned int c, rb_encoding *enc) +{ + char s[RUBY_MAX_CHAR_LEN]; + int n = rb_enc_codelen(c, enc); + + rb_enc_mbcput(c, s, enc); + rb_enc_str_buf_cat(str, s, n, enc); +} +#endif + +#define CHAR_ESC_LEN 13 /* sizeof(\x{ hex of 32bit unsigned int } \0) */ + +int +rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p) +{ + char buf[CHAR_ESC_LEN + 1]; + int l; + +#if SIZEOF_INT > 4 + c &= 0xffffffff; +#endif + if (unicode_p) { + if (c < 0x7F && ISPRINT(c)) { + snprintf(buf, CHAR_ESC_LEN, "%c", c); + } + else if (c < 0x10000) { + snprintf(buf, CHAR_ESC_LEN, "\\u%04X", c); + } + else { + snprintf(buf, CHAR_ESC_LEN, "\\u{%X}", c); + } + } + else { + if (c < 0x100) { + snprintf(buf, CHAR_ESC_LEN, "\\x%02X", c); + } + else { + snprintf(buf, CHAR_ESC_LEN, "\\x{%X}", c); + } + } + l = (int)strlen(buf); /* CHAR_ESC_LEN cannot exceed INT_MAX */ + rb_str_buf_cat(result, buf, l); + return l; +} + +/* + * call-seq: + * str.inspect -> string + * + * Returns a printable version of _str_, surrounded by quote marks, + * with special characters escaped. + * + * str = "hello" + * str[3] = "\b" + * str.inspect #=> "\"hel\\bo\"" + */ + +VALUE +rb_str_inspect(VALUE str) +{ + int encidx = ENCODING_GET(str); + rb_encoding *enc = rb_enc_from_index(encidx), *actenc; + const char *p, *pend, *prev; + char buf[CHAR_ESC_LEN + 1]; + VALUE result = rb_str_buf_new(0); + rb_encoding *resenc = rb_default_internal_encoding(); + int unicode_p = rb_enc_unicode_p(enc); + int asciicompat = rb_enc_asciicompat(enc); + + if (resenc == NULL) resenc = rb_default_external_encoding(); + if (!rb_enc_asciicompat(resenc)) resenc = rb_usascii_encoding(); + rb_enc_associate(result, resenc); + str_buf_cat2(result, "\""); + + p = RSTRING_PTR(str); pend = RSTRING_END(str); + prev = p; + actenc = get_actual_encoding(encidx, str); + if (actenc != enc) { + enc = actenc; + if (unicode_p) unicode_p = rb_enc_unicode_p(enc); + } + while (p < pend) { + unsigned int c, cc; + int n; + + n = rb_enc_precise_mbclen(p, pend, enc); + if (!MBCLEN_CHARFOUND_P(n)) { + if (p > prev) str_buf_cat(result, prev, p - prev); + n = rb_enc_mbminlen(enc); + if (pend < p + n) + n = (int)(pend - p); + while (n--) { + snprintf(buf, CHAR_ESC_LEN, "\\x%02X", *p & 0377); + str_buf_cat(result, buf, strlen(buf)); + prev = ++p; + } + continue; + } + n = MBCLEN_CHARFOUND_LEN(n); + c = rb_enc_mbc_to_codepoint(p, pend, enc); + p += n; + if ((asciicompat || unicode_p) && + (c == '"'|| c == '\\' || + (c == '#' && + p < pend && + MBCLEN_CHARFOUND_P(rb_enc_precise_mbclen(p,pend,enc)) && + (cc = rb_enc_codepoint(p,pend,enc), + (cc == '$' || cc == '@' || cc == '{'))))) { + if (p - n > prev) str_buf_cat(result, prev, p - n - prev); + str_buf_cat2(result, "\\"); + if (asciicompat || enc == resenc) { + prev = p - n; + continue; + } + } + switch (c) { + case '\n': cc = 'n'; break; + case '\r': cc = 'r'; break; + case '\t': cc = 't'; break; + case '\f': cc = 'f'; break; + case '\013': cc = 'v'; break; + case '\010': cc = 'b'; break; + case '\007': cc = 'a'; break; + case 033: cc = 'e'; break; + default: cc = 0; break; + } + if (cc) { + if (p - n > prev) str_buf_cat(result, prev, p - n - prev); + buf[0] = '\\'; + buf[1] = (char)cc; + str_buf_cat(result, buf, 2); + prev = p; + continue; + } + if ((enc == resenc && rb_enc_isprint(c, enc)) || + (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c))) { + continue; + } + else { + if (p - n > prev) str_buf_cat(result, prev, p - n - prev); + rb_str_buf_cat_escaped_char(result, c, unicode_p); + prev = p; + continue; + } + } + if (p > prev) str_buf_cat(result, prev, p - prev); + str_buf_cat2(result, "\""); + + OBJ_INFECT(result, str); + return result; +} + +#define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{')) + +/* + * call-seq: + * str.dump -> new_str + * + * Produces a version of +str+ with all non-printing characters replaced by + * \nnn notation and all special characters escaped. + * + * "hello \n ''".dump #=> "\"hello \\n ''\" + */ + +VALUE +rb_str_dump(VALUE str) +{ + rb_encoding *enc = rb_enc_get(str); + long len; + const char *p, *pend; + char *q, *qend; + VALUE result; + int u8 = (enc == rb_utf8_encoding()); + + len = 2; /* "" */ + p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); + while (p < pend) { + unsigned char c = *p++; + switch (c) { + case '"': case '\\': + case '\n': case '\r': + case '\t': case '\f': + case '\013': case '\010': case '\007': case '\033': + len += 2; + break; + + case '#': + len += IS_EVSTR(p, pend) ? 2 : 1; + break; + + default: + if (ISPRINT(c)) { + len++; + } + else { + if (u8 && c > 0x7F) { /* \u{NN} */ + int n = rb_enc_precise_mbclen(p-1, pend, enc); + if (MBCLEN_CHARFOUND_P(n)) { + unsigned int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc); + while (cc >>= 4) len++; + len += 5; + p += MBCLEN_CHARFOUND_LEN(n)-1; + break; + } + } + len += 4; /* \xNN */ + } + break; + } + } + if (!rb_enc_asciicompat(enc)) { + len += 19; /* ".force_encoding('')" */ + len += strlen(enc->name); + } + + result = rb_str_new_with_class(str, 0, len); + p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); + q = RSTRING_PTR(result); qend = q + len + 1; + + *q++ = '"'; + while (p < pend) { + unsigned char c = *p++; + + if (c == '"' || c == '\\') { + *q++ = '\\'; + *q++ = c; + } + else if (c == '#') { + if (IS_EVSTR(p, pend)) *q++ = '\\'; + *q++ = '#'; + } + else if (c == '\n') { + *q++ = '\\'; + *q++ = 'n'; + } + else if (c == '\r') { + *q++ = '\\'; + *q++ = 'r'; + } + else if (c == '\t') { + *q++ = '\\'; + *q++ = 't'; + } + else if (c == '\f') { + *q++ = '\\'; + *q++ = 'f'; + } + else if (c == '\013') { + *q++ = '\\'; + *q++ = 'v'; + } + else if (c == '\010') { + *q++ = '\\'; + *q++ = 'b'; + } + else if (c == '\007') { + *q++ = '\\'; + *q++ = 'a'; + } + else if (c == '\033') { + *q++ = '\\'; + *q++ = 'e'; + } + else if (ISPRINT(c)) { + *q++ = c; + } + else { + *q++ = '\\'; + if (u8) { + int n = rb_enc_precise_mbclen(p-1, pend, enc) - 1; + if (MBCLEN_CHARFOUND_P(n)) { + int cc = rb_enc_mbc_to_codepoint(p-1, pend, enc); + p += n; + snprintf(q, qend-q, "u{%x}", cc); + q += strlen(q); + continue; + } + } + snprintf(q, qend-q, "x%02X", c); + q += 3; + } + } + *q++ = '"'; + *q = '\0'; + if (!rb_enc_asciicompat(enc)) { + snprintf(q, qend-q, ".force_encoding(\"%s\")", enc->name); + enc = rb_ascii8bit_encoding(); + } + OBJ_INFECT(result, str); + /* result from dump is ASCII */ + rb_enc_associate(result, enc); + ENC_CODERANGE_SET(result, ENC_CODERANGE_7BIT); + return result; +} + + +static void +rb_str_check_dummy_enc(rb_encoding *enc) +{ + if (rb_enc_dummy_p(enc)) { + rb_raise(rb_eEncCompatError, "incompatible encoding with this operation: %s", + rb_enc_name(enc)); + } +} + +/* + * call-seq: + * str.upcase! -> str or nil + * + * Upcases the contents of str, returning nil if no changes + * were made. + * Note: case replacement is effective only in ASCII region. + */ + +static VALUE +rb_str_upcase_bang(VALUE str) +{ + rb_encoding *enc; + char *s, *send; + int modify = 0; + int n; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + s = RSTRING_PTR(str); send = RSTRING_END(str); + if (single_byte_optimizable(str)) { + while (s < send) { + unsigned int c = *(unsigned char*)s; + + if (rb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') { + *s = 'A' + (c - 'a'); + modify = 1; + } + s++; + } + } + else { + int ascompat = rb_enc_asciicompat(enc); + + while (s < send) { + unsigned int c; + + if (ascompat && (c = *(unsigned char*)s) < 0x80) { + if (rb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') { + *s = 'A' + (c - 'a'); + modify = 1; + } + s++; + } + else { + c = rb_enc_codepoint_len(s, send, &n, enc); + if (rb_enc_islower(c, enc)) { + /* assuming toupper returns codepoint with same size */ + rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc); + modify = 1; + } + s += n; + } + } + } + + if (modify) return str; + return Qnil; +} + + +/* + * call-seq: + * str.upcase -> new_str + * + * Returns a copy of str with all lowercase letters replaced with their + * uppercase counterparts. The operation is locale insensitive---only + * characters ``a'' to ``z'' are affected. + * Note: case replacement is effective only in ASCII region. + * + * "hEllO".upcase #=> "HELLO" + */ + +static VALUE +rb_str_upcase(VALUE str) +{ + str = rb_str_dup(str); + rb_str_upcase_bang(str); + return str; +} + + +/* + * call-seq: + * str.downcase! -> str or nil + * + * Downcases the contents of str, returning nil if no + * changes were made. + * Note: case replacement is effective only in ASCII region. + */ + +static VALUE +rb_str_downcase_bang(VALUE str) +{ + rb_encoding *enc; + char *s, *send; + int modify = 0; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + s = RSTRING_PTR(str); send = RSTRING_END(str); + if (single_byte_optimizable(str)) { + while (s < send) { + unsigned int c = *(unsigned char*)s; + + if (rb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') { + *s = 'a' + (c - 'A'); + modify = 1; + } + s++; + } + } + else { + int ascompat = rb_enc_asciicompat(enc); + + while (s < send) { + unsigned int c; + int n; + + if (ascompat && (c = *(unsigned char*)s) < 0x80) { + if (rb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') { + *s = 'a' + (c - 'A'); + modify = 1; + } + s++; + } + else { + c = rb_enc_codepoint_len(s, send, &n, enc); + if (rb_enc_isupper(c, enc)) { + /* assuming toupper returns codepoint with same size */ + rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc); + modify = 1; + } + s += n; + } + } + } + + if (modify) return str; + return Qnil; +} + + +/* + * call-seq: + * str.downcase -> new_str + * + * Returns a copy of str with all uppercase letters replaced with their + * lowercase counterparts. The operation is locale insensitive---only + * characters ``A'' to ``Z'' are affected. + * Note: case replacement is effective only in ASCII region. + * + * "hEllO".downcase #=> "hello" + */ + +static VALUE +rb_str_downcase(VALUE str) +{ + str = rb_str_dup(str); + rb_str_downcase_bang(str); + return str; +} + + +/* + * call-seq: + * str.capitalize! -> str or nil + * + * Modifies str by converting the first character to uppercase and the + * remainder to lowercase. Returns nil if no changes are made. + * Note: case conversion is effective only in ASCII region. + * + * a = "hello" + * a.capitalize! #=> "Hello" + * a #=> "Hello" + * a.capitalize! #=> nil + */ + +static VALUE +rb_str_capitalize_bang(VALUE str) +{ + rb_encoding *enc; + char *s, *send; + int modify = 0; + unsigned int c; + int n; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; + s = RSTRING_PTR(str); send = RSTRING_END(str); + + c = rb_enc_codepoint_len(s, send, &n, enc); + if (rb_enc_islower(c, enc)) { + rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc); + modify = 1; + } + s += n; + while (s < send) { + c = rb_enc_codepoint_len(s, send, &n, enc); + if (rb_enc_isupper(c, enc)) { + rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc); + modify = 1; + } + s += n; + } + + if (modify) return str; + return Qnil; +} + + +/* + * call-seq: + * str.capitalize -> new_str + * + * Returns a copy of str with the first character converted to uppercase + * and the remainder to lowercase. + * Note: case conversion is effective only in ASCII region. + * + * "hello".capitalize #=> "Hello" + * "HELLO".capitalize #=> "Hello" + * "123ABC".capitalize #=> "123abc" + */ + +static VALUE +rb_str_capitalize(VALUE str) +{ + str = rb_str_dup(str); + rb_str_capitalize_bang(str); + return str; +} + + +/* + * call-seq: + * str.swapcase! -> str or nil + * + * Equivalent to String#swapcase, but modifies the receiver in + * place, returning str, or nil if no changes were made. + * Note: case conversion is effective only in ASCII region. + */ + +static VALUE +rb_str_swapcase_bang(VALUE str) +{ + rb_encoding *enc; + char *s, *send; + int modify = 0; + int n; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + s = RSTRING_PTR(str); send = RSTRING_END(str); + while (s < send) { + unsigned int c = rb_enc_codepoint_len(s, send, &n, enc); + + if (rb_enc_isupper(c, enc)) { + /* assuming toupper returns codepoint with same size */ + rb_enc_mbcput(rb_enc_tolower(c, enc), s, enc); + modify = 1; + } + else if (rb_enc_islower(c, enc)) { + /* assuming tolower returns codepoint with same size */ + rb_enc_mbcput(rb_enc_toupper(c, enc), s, enc); + modify = 1; + } + s += n; + } + + if (modify) return str; + return Qnil; +} + + +/* + * call-seq: + * str.swapcase -> new_str + * + * Returns a copy of str with uppercase alphabetic characters converted + * to lowercase and lowercase characters converted to uppercase. + * Note: case conversion is effective only in ASCII region. + * + * "Hello".swapcase #=> "hELLO" + * "cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11" + */ + +static VALUE +rb_str_swapcase(VALUE str) +{ + str = rb_str_dup(str); + rb_str_swapcase_bang(str); + return str; +} + +typedef unsigned char *USTR; + +struct tr { + int gen; + unsigned int now, max; + char *p, *pend; +}; + +static unsigned int +trnext(struct tr *t, rb_encoding *enc) +{ + int n; + + for (;;) { + if (!t->gen) { +nextpart: + if (t->p == t->pend) return -1; + if (rb_enc_ascget(t->p, t->pend, &n, enc) == '\\' && t->p + n < t->pend) { + t->p += n; + } + t->now = rb_enc_codepoint_len(t->p, t->pend, &n, enc); + t->p += n; + if (rb_enc_ascget(t->p, t->pend, &n, enc) == '-' && t->p + n < t->pend) { + t->p += n; + if (t->p < t->pend) { + unsigned int c = rb_enc_codepoint_len(t->p, t->pend, &n, enc); + t->p += n; + if (t->now > c) { + if (t->now < 0x80 && c < 0x80) { + rb_raise(rb_eArgError, + "invalid range \"%c-%c\" in string transliteration", + t->now, c); + } + else { + rb_raise(rb_eArgError, "invalid range in string transliteration"); + } + continue; /* not reached */ + } + t->gen = 1; + t->max = c; + } + } + return t->now; + } + else { + while (ONIGENC_CODE_TO_MBCLEN(enc, ++t->now) <= 0) { + if (t->now == t->max) { + t->gen = 0; + goto nextpart; + } + } + if (t->now < t->max) { + return t->now; + } + else { + t->gen = 0; + return t->max; + } + } + } +} + +static VALUE rb_str_delete_bang(int,VALUE*,VALUE); + +static VALUE +tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) +{ + const unsigned int errc = -1; + unsigned int trans[256]; + rb_encoding *enc, *e1, *e2; + struct tr trsrc, trrepl; + int cflag = 0; + unsigned int c, c0, last = 0; + int modify = 0, i, l; + char *s, *send; + VALUE hash = 0; + int singlebyte = single_byte_optimizable(str); + int cr; + +#define CHECK_IF_ASCII(c) \ + (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \ + (cr = ENC_CODERANGE_VALID) : 0) + + StringValue(src); + StringValue(repl); + if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; + if (RSTRING_LEN(repl) == 0) { + return rb_str_delete_bang(1, &src, str); + } + + cr = ENC_CODERANGE(str); + e1 = rb_enc_check(str, src); + e2 = rb_enc_check(str, repl); + if (e1 == e2) { + enc = e1; + } + else { + enc = rb_enc_check(src, repl); + } + trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src); + if (RSTRING_LEN(src) > 1 && + rb_enc_ascget(trsrc.p, trsrc.pend, &l, enc) == '^' && + trsrc.p + l < trsrc.pend) { + cflag = 1; + trsrc.p += l; + } + trrepl.p = RSTRING_PTR(repl); + trrepl.pend = trrepl.p + RSTRING_LEN(repl); + trsrc.gen = trrepl.gen = 0; + trsrc.now = trrepl.now = 0; + trsrc.max = trrepl.max = 0; + + if (cflag) { + for (i=0; i<256; i++) { + trans[i] = 1; + } + while ((c = trnext(&trsrc, enc)) != errc) { + if (c < 256) { + trans[c] = errc; + } + else { + if (!hash) hash = rb_hash_new(); + rb_hash_aset(hash, UINT2NUM(c), Qtrue); + } + } + while ((c = trnext(&trrepl, enc)) != errc) + /* retrieve last replacer */; + last = trrepl.now; + for (i=0; i<256; i++) { + if (trans[i] != errc) { + trans[i] = last; + } + } + } + else { + unsigned int r; + + for (i=0; i<256; i++) { + trans[i] = errc; + } + while ((c = trnext(&trsrc, enc)) != errc) { + r = trnext(&trrepl, enc); + if (r == errc) r = trrepl.now; + if (c < 256) { + trans[c] = r; + if (rb_enc_codelen(r, enc) != 1) singlebyte = 0; + } + else { + if (!hash) hash = rb_hash_new(); + rb_hash_aset(hash, UINT2NUM(c), UINT2NUM(r)); + } + } + } + + if (cr == ENC_CODERANGE_VALID) + cr = ENC_CODERANGE_7BIT; + str_modify_keep_cr(str); + s = RSTRING_PTR(str); send = RSTRING_END(str); + if (sflag) { + int clen, tlen; + long offset, max = RSTRING_LEN(str); + unsigned int save = -1; + char *buf = ALLOC_N(char, max), *t = buf; + + while (s < send) { + int may_modify = 0; + + c0 = c = rb_enc_codepoint_len(s, send, &clen, e1); + tlen = enc == e1 ? clen : rb_enc_codelen(c, enc); + + s += clen; + if (c < 256) { + c = trans[c]; + } + else if (hash) { + VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c)); + if (NIL_P(tmp)) { + if (cflag) c = last; + else c = errc; + } + else if (cflag) c = errc; + else c = NUM2INT(tmp); + } + else { + c = errc; + } + if (c != (unsigned int)-1) { + if (save == c) { + CHECK_IF_ASCII(c); + continue; + } + save = c; + tlen = rb_enc_codelen(c, enc); + modify = 1; + } + else { + save = -1; + c = c0; + if (enc != e1) may_modify = 1; + } + while (t - buf + tlen >= max) { + offset = t - buf; + max *= 2; + REALLOC_N(buf, char, max); + t = buf + offset; + } + rb_enc_mbcput(c, t, enc); + if (may_modify && memcmp(s, t, tlen) != 0) { + modify = 1; + } + CHECK_IF_ASCII(c); + t += tlen; + } + if (!STR_EMBED_P(str)) { + ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); + } + TERM_FILL(t, rb_enc_mbminlen(enc)); + RSTRING(str)->as.heap.ptr = buf; + RSTRING(str)->as.heap.len = t - buf; + STR_SET_NOEMBED(str); + RSTRING(str)->as.heap.aux.capa = max; + } + else if (rb_enc_mbmaxlen(enc) == 1 || (singlebyte && !hash)) { + while (s < send) { + c = (unsigned char)*s; + if (trans[c] != errc) { + if (!cflag) { + c = trans[c]; + *s = c; + modify = 1; + } + else { + *s = last; + modify = 1; + } + } + CHECK_IF_ASCII(c); + s++; + } + } + else { + int clen, tlen, max = (int)(RSTRING_LEN(str) * 1.2); + long offset; + char *buf = ALLOC_N(char, max), *t = buf; + + while (s < send) { + int may_modify = 0; + c0 = c = rb_enc_codepoint_len(s, send, &clen, e1); + tlen = enc == e1 ? clen : rb_enc_codelen(c, enc); + + if (c < 256) { + c = trans[c]; + } + else if (hash) { + VALUE tmp = rb_hash_lookup(hash, UINT2NUM(c)); + if (NIL_P(tmp)) { + if (cflag) c = last; + else c = errc; + } + else if (cflag) c = errc; + else c = NUM2INT(tmp); + } + else { + c = cflag ? last : errc; + } + if (c != errc) { + tlen = rb_enc_codelen(c, enc); + modify = 1; + } + else { + c = c0; + if (enc != e1) may_modify = 1; + } + while (t - buf + tlen >= max) { + offset = t - buf; + max *= 2; + REALLOC_N(buf, char, max); + t = buf + offset; + } + if (s != t) { + rb_enc_mbcput(c, t, enc); + if (may_modify && memcmp(s, t, tlen) != 0) { + modify = 1; + } + } + CHECK_IF_ASCII(c); + s += clen; + t += tlen; + } + if (!STR_EMBED_P(str)) { + ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); + } + TERM_FILL(t, rb_enc_mbminlen(enc)); + RSTRING(str)->as.heap.ptr = buf; + RSTRING(str)->as.heap.len = t - buf; + STR_SET_NOEMBED(str); + RSTRING(str)->as.heap.aux.capa = max; + } + + if (modify) { + if (cr != ENC_CODERANGE_BROKEN) + ENC_CODERANGE_SET(str, cr); + rb_enc_associate(str, enc); + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.tr!(from_str, to_str) -> str or nil + * + * Translates str in place, using the same rules as + * String#tr. Returns str, or nil if no + * changes were made. + */ + +static VALUE +rb_str_tr_bang(VALUE str, VALUE src, VALUE repl) +{ + return tr_trans(str, src, repl, 0); +} + + +/* + * call-seq: + * str.tr(from_str, to_str) => new_str + * + * Returns a copy of +str+ with the characters in +from_str+ replaced by the + * corresponding characters in +to_str+. If +to_str+ is shorter than + * +from_str+, it is padded with its last character in order to maintain the + * correspondence. + * + * "hello".tr('el', 'ip') #=> "hippo" + * "hello".tr('aeiou', '*') #=> "h*ll*" + * "hello".tr('aeiou', 'AA*') #=> "hAll*" + * + * Both strings may use the c1-c2 notation to denote ranges of + * characters, and +from_str+ may start with a ^, which denotes + * all characters except those listed. + * + * "hello".tr('a-y', 'b-z') #=> "ifmmp" + * "hello".tr('^aeiou', '*') #=> "*e**o" + * + * The backslash character \ can be used to escape + * ^ or - and is otherwise ignored unless it + * appears at the end of a range or the end of the +from_str+ or +to_str+: + * + * "hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld" + * "hello-world".tr("a\\-eo", "*") #=> "h*ll**w*rld" + * + * "hello\r\nworld".tr("\r", "") #=> "hello\nworld" + * "hello\r\nworld".tr("\\r", "") #=> "hello\r\nwold" + * "hello\r\nworld".tr("\\\r", "") #=> "hello\nworld" + * + * "X['\\b']".tr("X\\", "") #=> "['b']" + * "X['\\b']".tr("X-\\]", "") #=> "'b'" + */ + +static VALUE +rb_str_tr(VALUE str, VALUE src, VALUE repl) +{ + str = rb_str_dup(str); + tr_trans(str, src, repl, 0); + return str; +} + +#define TR_TABLE_SIZE 257 +static void +tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first, + VALUE *tablep, VALUE *ctablep, rb_encoding *enc) +{ + const unsigned int errc = -1; + char buf[256]; + struct tr tr; + unsigned int c; + VALUE table = 0, ptable = 0; + int i, l, cflag = 0; + + tr.p = RSTRING_PTR(str); tr.pend = tr.p + RSTRING_LEN(str); + tr.gen = tr.now = tr.max = 0; + + if (RSTRING_LEN(str) > 1 && rb_enc_ascget(tr.p, tr.pend, &l, enc) == '^') { + cflag = 1; + tr.p += l; + } + if (first) { + for (i=0; i<256; i++) { + stable[i] = 1; + } + stable[256] = cflag; + } + else if (stable[256] && !cflag) { + stable[256] = 0; + } + for (i=0; i<256; i++) { + buf[i] = cflag; + } + + while ((c = trnext(&tr, enc)) != errc) { + if (c < 256) { + buf[c & 0xff] = !cflag; + } + else { + VALUE key = UINT2NUM(c); + + if (!table && (first || *tablep || stable[256])) { + if (cflag) { + ptable = *ctablep; + table = ptable ? ptable : rb_hash_new(); + *ctablep = table; + } + else { + table = rb_hash_new(); + ptable = *tablep; + *tablep = table; + } + } + if (table && (!ptable || (cflag ^ !NIL_P(rb_hash_aref(ptable, key))))) { + rb_hash_aset(table, key, Qtrue); + } + } + } + for (i=0; i<256; i++) { + stable[i] = stable[i] && buf[i]; + } + if (!table && !cflag) { + *tablep = 0; + } +} + + +static int +tr_find(unsigned int c, const char table[TR_TABLE_SIZE], VALUE del, VALUE nodel) +{ + if (c < 256) { + return table[c] != 0; + } + else { + VALUE v = UINT2NUM(c); + + if (del) { + if (!NIL_P(rb_hash_lookup(del, v)) && + (!nodel || NIL_P(rb_hash_lookup(nodel, v)))) { + return TRUE; + } + } + else if (nodel && !NIL_P(rb_hash_lookup(nodel, v))) { + return FALSE; + } + return table[256] ? TRUE : FALSE; + } +} + +/* + * call-seq: + * str.delete!([other_str]+) -> str or nil + * + * Performs a delete operation in place, returning str, or + * nil if str was not modified. + */ + +static VALUE +rb_str_delete_bang(int argc, VALUE *argv, VALUE str) +{ + char squeez[TR_TABLE_SIZE]; + rb_encoding *enc = 0; + char *s, *send, *t; + VALUE del = 0, nodel = 0; + int modify = 0; + int i, ascompat, cr; + + if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; + rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); + for (i=0; i new_str + * + * Returns a copy of str with all characters in the intersection of its + * arguments deleted. Uses the same rules for building the set of characters as + * String#count. + * + * "hello".delete "l","lo" #=> "heo" + * "hello".delete "lo" #=> "he" + * "hello".delete "aeiou", "^e" #=> "hell" + * "hello".delete "ej-m" #=> "ho" + */ + +static VALUE +rb_str_delete(int argc, VALUE *argv, VALUE str) +{ + str = rb_str_dup(str); + rb_str_delete_bang(argc, argv, str); + return str; +} + + +/* + * call-seq: + * str.squeeze!([other_str]*) -> str or nil + * + * Squeezes str in place, returning either str, or + * nil if no changes were made. + */ + +static VALUE +rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str) +{ + char squeez[TR_TABLE_SIZE]; + rb_encoding *enc = 0; + VALUE del = 0, nodel = 0; + char *s, *send, *t; + int i, modify = 0; + int ascompat, singlebyte = single_byte_optimizable(str); + unsigned int save; + + if (argc == 0) { + enc = STR_ENC_GET(str); + } + else { + for (i=0; i 0 && !squeez[c])) { + *t++ = save = c; + } + } + } + else { + while (s < send) { + unsigned int c; + int clen; + + if (ascompat && (c = *(unsigned char*)s) < 0x80) { + if (c != save || (argc > 0 && !squeez[c])) { + *t++ = save = c; + } + s++; + } + else { + c = rb_enc_codepoint_len(s, send, &clen, enc); + + if (c != save || (argc > 0 && !tr_find(c, squeez, del, nodel))) { + if (t != s) rb_enc_mbcput(c, t, enc); + save = c; + t += clen; + } + s += clen; + } + } + } + + TERM_FILL(t, TERM_LEN(str)); + if (t - RSTRING_PTR(str) != RSTRING_LEN(str)) { + STR_SET_LEN(str, t - RSTRING_PTR(str)); + modify = 1; + } + + if (modify) return str; + return Qnil; +} + + +/* + * call-seq: + * str.squeeze([other_str]*) -> new_str + * + * Builds a set of characters from the other_str parameter(s) using the + * procedure described for String#count. Returns a new string + * where runs of the same character that occur in this set are replaced by a + * single character. If no arguments are given, all runs of identical + * characters are replaced by a single character. + * + * "yellow moon".squeeze #=> "yelow mon" + * " now is the".squeeze(" ") #=> " now is the" + * "putters shoot balls".squeeze("m-z") #=> "puters shot balls" + */ + +static VALUE +rb_str_squeeze(int argc, VALUE *argv, VALUE str) +{ + str = rb_str_dup(str); + rb_str_squeeze_bang(argc, argv, str); + return str; +} + + +/* + * call-seq: + * str.tr_s!(from_str, to_str) -> str or nil + * + * Performs String#tr_s processing on str in place, + * returning str, or nil if no changes were made. + */ + +static VALUE +rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl) +{ + return tr_trans(str, src, repl, 1); +} + + +/* + * call-seq: + * str.tr_s(from_str, to_str) -> new_str + * + * Processes a copy of str as described under String#tr, + * then removes duplicate characters in regions that were affected by the + * translation. + * + * "hello".tr_s('l', 'r') #=> "hero" + * "hello".tr_s('el', '*') #=> "h*o" + * "hello".tr_s('el', 'hx') #=> "hhxo" + */ + +static VALUE +rb_str_tr_s(VALUE str, VALUE src, VALUE repl) +{ + str = rb_str_dup(str); + tr_trans(str, src, repl, 1); + return str; +} + + +/* + * call-seq: + * str.count([other_str]+) -> fixnum + * + * Each +other_str+ parameter defines a set of characters to count. The + * intersection of these sets defines the characters to count in +str+. Any + * +other_str+ that starts with a caret ^ is negated. The + * sequence c1-c2 means all characters between c1 and c2. The + * backslash character \\ can be used to escape ^ or + * - and is otherwise ignored unless it appears at the end of a + * sequence or the end of a +other_str+. + * + * a = "hello world" + * a.count "lo" #=> 5 + * a.count "lo", "o" #=> 2 + * a.count "hello", "^l" #=> 4 + * a.count "ej-m" #=> 4 + * + * "hello^world".count "\\^aeiou" #=> 4 + * "hello-world".count "a\\-eo" #=> 4 + * + * c = "hello world\\r\\n" + * c.count "\\" #=> 2 + * c.count "\\A" #=> 0 + * c.count "X-\\w" #=> 3 + */ + +static VALUE +rb_str_count(int argc, VALUE *argv, VALUE str) +{ + char table[TR_TABLE_SIZE]; + rb_encoding *enc = 0; + VALUE del = 0, nodel = 0, tstr; + char *s, *send; + int i; + int ascompat; + + rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); + + tstr = argv[0]; + StringValue(tstr); + enc = rb_enc_check(str, tstr); + if (argc == 1) { + const char *ptstr; + if (RSTRING_LEN(tstr) == 1 && rb_enc_asciicompat(enc) && + (ptstr = RSTRING_PTR(tstr), + ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc, (const unsigned char *)ptstr, (const unsigned char *)ptstr+1)) && + !is_broken_string(str)) { + int n = 0; + int clen; + unsigned char c = rb_enc_codepoint_len(ptstr, ptstr+1, &clen, enc); + + s = RSTRING_PTR(str); + if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0); + send = RSTRING_END(str); + while (s < send) { + if (*(unsigned char*)s++ == c) n++; + } + return INT2NUM(n); + } + } + + tr_setup_table(tstr, table, TRUE, &del, &nodel, enc); + for (i=1; i anArray + * + * Divides str into substrings based on a delimiter, returning an array + * of these substrings. + * + * If pattern is a String, then its contents are used as + * the delimiter when splitting str. If pattern is a single + * space, str is split on whitespace, with leading whitespace and runs + * of contiguous whitespace characters ignored. + * + * If pattern is a Regexp, str is divided where the + * pattern matches. Whenever the pattern matches a zero-length string, + * str is split into individual characters. If pattern contains + * groups, the respective matches will be returned in the array as well. + * + * If pattern is omitted, the value of $; is used. If + * $; is nil (which is the default), str is + * split on whitespace as if ` ' were specified. + * + * If the limit parameter is omitted, trailing null fields are + * suppressed. If limit is a positive number, at most that number of + * fields will be returned (if limit is 1, the entire + * string is returned as the only entry in an array). If negative, there is no + * limit to the number of fields returned, and trailing null fields are not + * suppressed. + * + * When the input +str+ is empty an empty Array is returned as the string is + * considered to have no fields to split. + * + * " now's the time".split #=> ["now's", "the", "time"] + * " now's the time".split(' ') #=> ["now's", "the", "time"] + * " now's the time".split(/ /) #=> ["", "now's", "", "the", "time"] + * "1, 2.34,56, 7".split(%r{,\s*}) #=> ["1", "2.34", "56", "7"] + * "hello".split(//) #=> ["h", "e", "l", "l", "o"] + * "hello".split(//, 3) #=> ["h", "e", "llo"] + * "hi mom".split(%r{\s*}) #=> ["h", "i", "m", "o", "m"] + * + * "mellow yellow".split("ello") #=> ["m", "w y", "w"] + * "1,2,,3,4,,".split(',') #=> ["1", "2", "", "3", "4"] + * "1,2,,3,4,,".split(',', 4) #=> ["1", "2", "", "3,4,,"] + * "1,2,,3,4,,".split(',', -4) #=> ["1", "2", "", "3", "4", "", ""] + * + * "".split(',', -1) #=> [] + */ + +static VALUE +rb_str_split_m(int argc, VALUE *argv, VALUE str) +{ + rb_encoding *enc; + VALUE spat; + VALUE limit; + enum {awk, string, regexp} split_type; + long beg, end, i = 0; + int lim = 0; + VALUE result, tmp; + + if (rb_scan_args(argc, argv, "02", &spat, &limit) == 2) { + lim = NUM2INT(limit); + if (lim <= 0) limit = Qnil; + else if (lim == 1) { + if (RSTRING_LEN(str) == 0) + return rb_ary_new2(0); + return rb_ary_new3(1, str); + } + i = 1; + } + + enc = STR_ENC_GET(str); + if (NIL_P(spat) && NIL_P(spat = rb_fs)) { + split_type = awk; + } + else { + spat = get_pat_quoted(spat, 0); + if (BUILTIN_TYPE(spat) == T_STRING) { + rb_encoding *enc2 = STR_ENC_GET(spat); + + mustnot_broken(spat); + split_type = string; + if (RSTRING_LEN(spat) == 0) { + /* Special case - split into chars */ + spat = rb_reg_regcomp(spat); + split_type = regexp; + } + else if (rb_enc_asciicompat(enc2) == 1) { + if (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){ + split_type = awk; + } + } + else { + int l; + if (rb_enc_ascget(RSTRING_PTR(spat), RSTRING_END(spat), &l, enc2) == ' ' && + RSTRING_LEN(spat) == l) { + split_type = awk; + } + } + } + else { + split_type = regexp; + } + } + + result = rb_ary_new(); + beg = 0; + if (split_type == awk) { + char *ptr = RSTRING_PTR(str); + char *eptr = RSTRING_END(str); + char *bptr = ptr; + int skip = 1; + unsigned int c; + + end = beg; + if (is_ascii_string(str)) { + while (ptr < eptr) { + c = (unsigned char)*ptr++; + if (skip) { + if (ascii_isspace(c)) { + beg = ptr - bptr; + } + else { + end = ptr - bptr; + skip = 0; + if (!NIL_P(limit) && lim <= i) break; + } + } + else if (ascii_isspace(c)) { + rb_ary_push(result, rb_str_subseq(str, beg, end-beg)); + skip = 1; + beg = ptr - bptr; + if (!NIL_P(limit)) ++i; + } + else { + end = ptr - bptr; + } + } + } + else { + while (ptr < eptr) { + int n; + + c = rb_enc_codepoint_len(ptr, eptr, &n, enc); + ptr += n; + if (skip) { + if (rb_isspace(c)) { + beg = ptr - bptr; + } + else { + end = ptr - bptr; + skip = 0; + if (!NIL_P(limit) && lim <= i) break; + } + } + else if (rb_isspace(c)) { + rb_ary_push(result, rb_str_subseq(str, beg, end-beg)); + skip = 1; + beg = ptr - bptr; + if (!NIL_P(limit)) ++i; + } + else { + end = ptr - bptr; + } + } + } + } + else if (split_type == string) { + char *ptr = RSTRING_PTR(str); + char *temp = ptr; + char *eptr = RSTRING_END(str); + char *sptr = RSTRING_PTR(spat); + long slen = RSTRING_LEN(spat); + + mustnot_broken(str); + enc = rb_enc_check(str, spat); + while (ptr < eptr && + (end = rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) { + /* Check we are at the start of a char */ + char *t = rb_enc_right_char_head(ptr, ptr + end, eptr, enc); + if (t != ptr + end) { + ptr = t; + continue; + } + rb_ary_push(result, rb_str_subseq(str, ptr - temp, end)); + ptr += end + slen; + if (!NIL_P(limit) && lim <= ++i) break; + } + beg = ptr - temp; + } + else { + char *ptr = RSTRING_PTR(str); + long len = RSTRING_LEN(str); + long start = beg; + long idx; + int last_null = 0; + struct re_registers *regs; + + while ((end = rb_reg_search(spat, str, start, 0)) >= 0) { + regs = RMATCH_REGS(rb_backref_get()); + if (start == end && BEG(0) == END(0)) { + if (!ptr) { + rb_ary_push(result, str_new_empty(str)); + break; + } + else if (last_null == 1) { + rb_ary_push(result, rb_str_subseq(str, beg, + rb_enc_fast_mbclen(ptr+beg, + ptr+len, + enc))); + beg = start; + } + else { + if (ptr+start == ptr+len) + start++; + else + start += rb_enc_fast_mbclen(ptr+start,ptr+len,enc); + last_null = 1; + continue; + } + } + else { + rb_ary_push(result, rb_str_subseq(str, beg, end-beg)); + beg = start = END(0); + } + last_null = 0; + + for (idx=1; idx < regs->num_regs; idx++) { + if (BEG(idx) == -1) continue; + if (BEG(idx) == END(idx)) + tmp = str_new_empty(str); + else + tmp = rb_str_subseq(str, BEG(idx), END(idx)-BEG(idx)); + rb_ary_push(result, tmp); + } + if (!NIL_P(limit) && lim <= ++i) break; + } + } + if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) { + if (RSTRING_LEN(str) == beg) + tmp = str_new_empty(str); + else + tmp = rb_str_subseq(str, beg, RSTRING_LEN(str)-beg); + rb_ary_push(result, tmp); + } + if (NIL_P(limit) && lim == 0) { + long len; + while ((len = RARRAY_LEN(result)) > 0 && + (tmp = RARRAY_AREF(result, len-1), RSTRING_LEN(tmp) == 0)) + rb_ary_pop(result); + } + + return result; +} + +VALUE +rb_str_split(VALUE str, const char *sep0) +{ + VALUE sep; + + StringValue(str); + sep = rb_str_new_cstr(sep0); + return rb_str_split_m(1, &sep, str); +} + + +static VALUE +rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, int wantarray) +{ + rb_encoding *enc; + VALUE line, rs, orig = str; + const char *ptr, *pend, *subptr, *subend, *rsptr, *hit, *adjusted; + long pos, len, rslen; + int paragraph_mode = 0; + + VALUE UNINITIALIZED_VAR(ary); + + if (argc == 0) + rs = rb_rs; + else + rb_scan_args(argc, argv, "01", &rs); + + if (rb_block_given_p()) { + if (wantarray) { +#if STRING_ENUMERATORS_WANTARRAY + rb_warn("given block not used"); + ary = rb_ary_new(); +#else + rb_warning("passing a block to String#lines is deprecated"); + wantarray = 0; +#endif + } + } + else { + if (wantarray) + ary = rb_ary_new(); + else + RETURN_ENUMERATOR(str, argc, argv); + } + + if (NIL_P(rs)) { + if (wantarray) { + rb_ary_push(ary, str); + return ary; + } + else { + rb_yield(str); + return orig; + } + } + + str = rb_str_new_frozen(str); + ptr = subptr = RSTRING_PTR(str); + pend = RSTRING_END(str); + len = RSTRING_LEN(str); + StringValue(rs); + rslen = RSTRING_LEN(rs); + + if (rs == rb_default_rs) + enc = rb_enc_get(str); + else + enc = rb_enc_check(str, rs); + + if (rslen == 0) { + rsptr = "\n\n"; + rslen = 2; + paragraph_mode = 1; + } + else { + rsptr = RSTRING_PTR(rs); + } + + if ((rs == rb_default_rs || paragraph_mode) && !rb_enc_asciicompat(enc)) { + rs = rb_str_new(rsptr, rslen); + rs = rb_str_encode(rs, rb_enc_from_encoding(enc), 0, Qnil); + rsptr = RSTRING_PTR(rs); + rslen = RSTRING_LEN(rs); + } + + while (subptr < pend) { + pos = rb_memsearch(rsptr, rslen, subptr, pend - subptr, enc); + if (pos < 0) break; + hit = subptr + pos; + adjusted = rb_enc_right_char_head(subptr, hit, pend, enc); + if (hit != adjusted) { + subptr = adjusted; + continue; + } + subend = hit + rslen; + if (paragraph_mode) { + while (subend < pend && rb_enc_is_newline(subend, pend, enc)) { + subend += rb_enc_mbclen(subend, pend, enc); + } + } + line = rb_str_subseq(str, subptr - ptr, subend - subptr); + if (wantarray) { + rb_ary_push(ary, line); + } + else { + rb_yield(line); + str_mod_check(str, ptr, len); + } + subptr = subend; + } + + if (subptr != pend) { + line = rb_str_subseq(str, subptr - ptr, pend - subptr); + if (wantarray) + rb_ary_push(ary, line); + else + rb_yield(line); + RB_GC_GUARD(str); + } + + if (wantarray) + return ary; + else + return orig; +} + +/* + * call-seq: + * str.each_line(separator=$/) {|substr| block } -> str + * str.each_line(separator=$/) -> an_enumerator + * + * Splits str using the supplied parameter as the record + * separator ($/ by default), passing each substring in + * turn to the supplied block. If a zero-length record separator is + * supplied, the string is split into paragraphs delimited by + * multiple successive newlines. + * + * If no block is given, an enumerator is returned instead. + * + * print "Example one\n" + * "hello\nworld".each_line {|s| p s} + * print "Example two\n" + * "hello\nworld".each_line('l') {|s| p s} + * print "Example three\n" + * "hello\n\n\nworld".each_line('') {|s| p s} + * + * produces: + * + * Example one + * "hello\n" + * "world" + * Example two + * "hel" + * "l" + * "o\nworl" + * "d" + * Example three + * "hello\n\n\n" + * "world" + */ + +static VALUE +rb_str_each_line(int argc, VALUE *argv, VALUE str) +{ + return rb_str_enumerate_lines(argc, argv, str, 0); +} + +/* + * call-seq: + * str.lines(separator=$/) -> an_array + * + * Returns an array of lines in str split using the supplied + * record separator ($/ by default). This is a + * shorthand for str.each_line(separator).to_a. + * + * If a block is given, which is a deprecated form, works the same as + * each_line. + */ + +static VALUE +rb_str_lines(int argc, VALUE *argv, VALUE str) +{ + return rb_str_enumerate_lines(argc, argv, str, 1); +} + +static VALUE +rb_str_each_byte_size(VALUE str, VALUE args, VALUE eobj) +{ + return LONG2FIX(RSTRING_LEN(str)); +} + +static VALUE +rb_str_enumerate_bytes(VALUE str, int wantarray) +{ + long i; + VALUE UNINITIALIZED_VAR(ary); + + if (rb_block_given_p()) { + if (wantarray) { +#if STRING_ENUMERATORS_WANTARRAY + rb_warn("given block not used"); + ary = rb_ary_new(); +#else + rb_warning("passing a block to String#bytes is deprecated"); + wantarray = 0; +#endif + } + } + else { + if (wantarray) + ary = rb_ary_new2(RSTRING_LEN(str)); + else + RETURN_SIZED_ENUMERATOR(str, 0, 0, rb_str_each_byte_size); + } + + for (i=0; i str + * str.each_byte -> an_enumerator + * + * Passes each byte in str to the given block, or returns an + * enumerator if no block is given. + * + * "hello".each_byte {|c| print c, ' ' } + * + * produces: + * + * 104 101 108 108 111 + */ + +static VALUE +rb_str_each_byte(VALUE str) +{ + return rb_str_enumerate_bytes(str, 0); +} + +/* + * call-seq: + * str.bytes -> an_array + * + * Returns an array of bytes in str. This is a shorthand for + * str.each_byte.to_a. + * + * If a block is given, which is a deprecated form, works the same as + * each_byte. + */ + +static VALUE +rb_str_bytes(VALUE str) +{ + return rb_str_enumerate_bytes(str, 1); +} + +static VALUE +rb_str_each_char_size(VALUE str, VALUE args, VALUE eobj) +{ + return rb_str_length(str); +} + +static VALUE +rb_str_enumerate_chars(VALUE str, int wantarray) +{ + VALUE orig = str; + VALUE substr; + long i, len, n; + const char *ptr; + rb_encoding *enc; + VALUE UNINITIALIZED_VAR(ary); + + str = rb_str_new_frozen(str); + ptr = RSTRING_PTR(str); + len = RSTRING_LEN(str); + enc = rb_enc_get(str); + + if (rb_block_given_p()) { + if (wantarray) { +#if STRING_ENUMERATORS_WANTARRAY + rb_warn("given block not used"); + ary = rb_ary_new_capa(str_strlen(str, enc)); /* str's enc*/ +#else + rb_warning("passing a block to String#chars is deprecated"); + wantarray = 0; +#endif + } + } + else { + if (wantarray) + ary = rb_ary_new_capa(str_strlen(str, enc)); /* str's enc*/ + else + return SIZED_ENUMERATOR(str, 0, 0, rb_str_each_char_size); + } + + switch (ENC_CODERANGE(str)) { + case ENC_CODERANGE_VALID: + case ENC_CODERANGE_7BIT: + for (i = 0; i < len; i += n) { + n = rb_enc_fast_mbclen(ptr + i, ptr + len, enc); + substr = rb_str_subseq(str, i, n); + if (wantarray) + rb_ary_push(ary, substr); + else + rb_yield(substr); + } + break; + default: + for (i = 0; i < len; i += n) { + n = rb_enc_mbclen(ptr + i, ptr + len, enc); + substr = rb_str_subseq(str, i, n); + if (wantarray) + rb_ary_push(ary, substr); + else + rb_yield(substr); + } + } + RB_GC_GUARD(str); + if (wantarray) + return ary; + else + return orig; +} + +/* + * call-seq: + * str.each_char {|cstr| block } -> str + * str.each_char -> an_enumerator + * + * Passes each character in str to the given block, or returns + * an enumerator if no block is given. + * + * "hello".each_char {|c| print c, ' ' } + * + * produces: + * + * h e l l o + */ + +static VALUE +rb_str_each_char(VALUE str) +{ + return rb_str_enumerate_chars(str, 0); +} + +/* + * call-seq: + * str.chars -> an_array + * + * Returns an array of characters in str. This is a shorthand + * for str.each_char.to_a. + * + * If a block is given, which is a deprecated form, works the same as + * each_char. + */ + +static VALUE +rb_str_chars(VALUE str) +{ + return rb_str_enumerate_chars(str, 1); +} + + +static VALUE +rb_str_enumerate_codepoints(VALUE str, int wantarray) +{ + VALUE orig = str; + int n; + unsigned int c; + const char *ptr, *end; + rb_encoding *enc; + VALUE UNINITIALIZED_VAR(ary); + + if (single_byte_optimizable(str)) + return rb_str_enumerate_bytes(str, wantarray); + + str = rb_str_new_frozen(str); + ptr = RSTRING_PTR(str); + end = RSTRING_END(str); + enc = STR_ENC_GET(str); + + if (rb_block_given_p()) { + if (wantarray) { +#if STRING_ENUMERATORS_WANTARRAY + rb_warn("given block not used"); + ary = rb_ary_new_capa(str_strlen(str, enc)); /* str's enc*/ +#else + rb_warning("passing a block to String#codepoints is deprecated"); + wantarray = 0; +#endif + } + } + else { + if (wantarray) + ary = rb_ary_new_capa(str_strlen(str, enc)); /* str's enc*/ + else + RETURN_SIZED_ENUMERATOR(str, 0, 0, rb_str_each_char_size); + } + + while (ptr < end) { + c = rb_enc_codepoint_len(ptr, end, &n, enc); + if (wantarray) + rb_ary_push(ary, UINT2NUM(c)); + else + rb_yield(UINT2NUM(c)); + ptr += n; + } + RB_GC_GUARD(str); + if (wantarray) + return ary; + else + return orig; +} + +/* + * call-seq: + * str.each_codepoint {|integer| block } -> str + * str.each_codepoint -> an_enumerator + * + * Passes the Integer ordinal of each character in str, + * also known as a codepoint when applied to Unicode strings to the + * given block. + * + * If no block is given, an enumerator is returned instead. + * + * "hello\u0639".each_codepoint {|c| print c, ' ' } + * + * produces: + * + * 104 101 108 108 111 1593 + */ + +static VALUE +rb_str_each_codepoint(VALUE str) +{ + return rb_str_enumerate_codepoints(str, 0); +} + +/* + * call-seq: + * str.codepoints -> an_array + * + * Returns an array of the Integer ordinals of the + * characters in str. This is a shorthand for + * str.each_codepoint.to_a. + * + * If a block is given, which is a deprecated form, works the same as + * each_codepoint. + */ + +static VALUE +rb_str_codepoints(VALUE str) +{ + return rb_str_enumerate_codepoints(str, 1); +} + + +static long +chopped_length(VALUE str) +{ + rb_encoding *enc = STR_ENC_GET(str); + const char *p, *p2, *beg, *end; + + beg = RSTRING_PTR(str); + end = beg + RSTRING_LEN(str); + if (beg > end) return 0; + p = rb_enc_prev_char(beg, end, end, enc); + if (!p) return 0; + if (p > beg && rb_enc_ascget(p, end, 0, enc) == '\n') { + p2 = rb_enc_prev_char(beg, p, end, enc); + if (p2 && rb_enc_ascget(p2, end, 0, enc) == '\r') p = p2; + } + return p - beg; +} + +/* + * call-seq: + * str.chop! -> str or nil + * + * Processes str as for String#chop, returning str, + * or nil if str is the empty string. See also + * String#chomp!. + */ + +static VALUE +rb_str_chop_bang(VALUE str) +{ + str_modify_keep_cr(str); + if (RSTRING_LEN(str) > 0) { + long len; + len = chopped_length(str); + STR_SET_LEN(str, len); + TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str)); + if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) { + ENC_CODERANGE_CLEAR(str); + } + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.chop -> new_str + * + * Returns a new String with the last character removed. If the + * string ends with \r\n, both characters are removed. Applying + * chop to an empty string returns an empty + * string. String#chomp is often a safer alternative, as it leaves + * the string unchanged if it doesn't end in a record separator. + * + * "string\r\n".chop #=> "string" + * "string\n\r".chop #=> "string\n" + * "string\n".chop #=> "string" + * "string".chop #=> "strin" + * "x".chop.chop #=> "" + */ + +static VALUE +rb_str_chop(VALUE str) +{ + return rb_str_subseq(str, 0, chopped_length(str)); +} + + +static long +chompped_length(VALUE str, VALUE rs) +{ + rb_encoding *enc; + int newline; + char *pp, *e, *rsptr; + long rslen; + char *const p = RSTRING_PTR(str); + long len = RSTRING_LEN(str); + + if (len == 0) return 0; + e = p + len; + if (rs == rb_default_rs) { + smart_chomp: + enc = rb_enc_get(str); + if (rb_enc_mbminlen(enc) > 1) { + pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc); + if (rb_enc_is_newline(pp, e, enc)) { + e = pp; + } + pp = e - rb_enc_mbminlen(enc); + if (pp >= p) { + pp = rb_enc_left_char_head(p, pp, e, enc); + if (rb_enc_ascget(pp, e, 0, enc) == '\r') { + e = pp; + } + } + } + else { + switch (*(e-1)) { /* not e[-1] to get rid of VC bug */ + case '\n': + if (--e > p && *(e-1) == '\r') { + --e; + } + break; + case '\r': + --e; + break; + } + } + return e - p; + } + + enc = rb_enc_get(str); + RSTRING_GETMEM(rs, rsptr, rslen); + if (rslen == 0) { + if (rb_enc_mbminlen(enc) > 1) { + while (e > p) { + pp = rb_enc_left_char_head(p, e-rb_enc_mbminlen(enc), e, enc); + if (!rb_enc_is_newline(pp, e, enc)) break; + e = pp; + pp -= rb_enc_mbminlen(enc); + if (pp >= p) { + pp = rb_enc_left_char_head(p, pp, e, enc); + if (rb_enc_ascget(pp, e, 0, enc) == '\r') { + e = pp; + } + } + } + } + else { + while (e > p && *(e-1) == '\n') { + --e; + if (e > p && *(e-1) == '\r') + --e; + } + } + return e - p; + } + if (rslen > len) return len; + + enc = rb_enc_get(rs); + newline = rsptr[rslen-1]; + if (rslen == rb_enc_mbminlen(enc)) { + if (rslen == 1) { + if (newline == '\n') + goto smart_chomp; + } + else { + if (rb_enc_is_newline(rsptr, rsptr+rslen, enc)) + goto smart_chomp; + } + } + + enc = rb_enc_check(str, rs); + if (is_broken_string(rs)) { + return len; + } + pp = e - rslen; + if (p[len-1] == newline && + (rslen <= 1 || + memcmp(rsptr, pp, rslen) == 0)) { + if (rb_enc_left_char_head(p, pp, e, enc) == pp) + return len - rslen; + RB_GC_GUARD(rs); + } + return len; +} + +static VALUE +chomp_rs(int argc, const VALUE *argv) +{ + rb_check_arity(argc, 0, 1); + if (argc > 0) { + VALUE rs = argv[0]; + if (!NIL_P(rs)) StringValue(rs); + return rs; + } + else { + return rb_rs; + } +} + +/* + * call-seq: + * str.chomp!(separator=$/) -> str or nil + * + * Modifies str in place as described for String#chomp, + * returning str, or nil if no modifications were made. + */ + +static VALUE +rb_str_chomp_bang(int argc, VALUE *argv, VALUE str) +{ + VALUE rs; + long olen; + str_modify_keep_cr(str); + if ((olen = RSTRING_LEN(str)) > 0 && !NIL_P(rs = chomp_rs(argc, argv))) { + long len; + len = chompped_length(str, rs); + if (len < olen) { + STR_SET_LEN(str, len); + TERM_FILL(&RSTRING_PTR(str)[len], TERM_LEN(str)); + if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) { + ENC_CODERANGE_CLEAR(str); + } + return str; + } + } + return Qnil; +} + + +/* + * call-seq: + * str.chomp(separator=$/) -> new_str + * + * Returns a new String with the given record separator removed + * from the end of str (if present). If $/ has not been + * changed from the default Ruby record separator, then chomp also + * removes carriage return characters (that is it will remove \n, + * \r, and \r\n). If $/ is an empty string, + * it will remove all trailing newlines from the string. + * + * "hello".chomp #=> "hello" + * "hello\n".chomp #=> "hello" + * "hello\r\n".chomp #=> "hello" + * "hello\n\r".chomp #=> "hello\n" + * "hello\r".chomp #=> "hello" + * "hello \n there".chomp #=> "hello \n there" + * "hello".chomp("llo") #=> "he" + * "hello\r\n\r\n".chomp('') #=> "hello" + * "hello\r\n\r\r\n".chomp('') #=> "hello\r\n\r" + */ + +static VALUE +rb_str_chomp(int argc, VALUE *argv, VALUE str) +{ + VALUE rs = chomp_rs(argc, argv); + if (NIL_P(rs)) return rb_str_dup(str); + return rb_str_subseq(str, 0, chompped_length(str, rs)); +} + +static long +lstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc) +{ + const char *const start = s; + + if (!s || s >= e) return 0; + /* remove spaces at head */ + while (s < e) { + int n; + unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); + + if (!rb_isspace(cc)) break; + s += n; + } + return s - start; +} + +/* + * call-seq: + * str.lstrip! -> self or nil + * + * Removes leading whitespace from str, returning nil if no + * change was made. See also String#rstrip! and + * String#strip!. + * + * " hello ".lstrip #=> "hello " + * "hello".lstrip! #=> nil + */ + +static VALUE +rb_str_lstrip_bang(VALUE str) +{ + rb_encoding *enc; + char *start, *s; + long olen, loffset; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + RSTRING_GETMEM(str, start, olen); + loffset = lstrip_offset(str, start, start+olen, enc); + if (loffset > 0) { + long len = olen-loffset; + s = start + loffset; + memmove(start, s, len); + STR_SET_LEN(str, len); +#if !SHARABLE_MIDDLE_SUBSTRING + TERM_FILL(start+len, rb_enc_mbminlen(enc)); +#endif + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.lstrip -> new_str + * + * Returns a copy of str with leading whitespace removed. See also + * String#rstrip and String#strip. + * + * " hello ".lstrip #=> "hello " + * "hello".lstrip #=> "hello" + */ + +static VALUE +rb_str_lstrip(VALUE str) +{ + char *start; + long len, loffset; + RSTRING_GETMEM(str, start, len); + loffset = lstrip_offset(str, start, start+len, STR_ENC_GET(str)); + if (loffset <= 0) return rb_str_dup(str); + return rb_str_subseq(str, loffset, len - loffset); +} + +static long +rstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc) +{ + const char *t; + + rb_str_check_dummy_enc(enc); + if (!s || s >= e) return 0; + t = e; + + /* remove trailing spaces or '\0's */ + if (single_byte_optimizable(str)) { + unsigned char c; + while (s < t && ((c = *(t-1)) == '\0' || ascii_isspace(c))) t--; + } + else { + char *tp; + + while ((tp = rb_enc_prev_char(s, t, e, enc)) != NULL) { + unsigned int c = rb_enc_codepoint(tp, e, enc); + if (c && !rb_isspace(c)) break; + t = tp; + } + } + return e - t; +} + +/* + * call-seq: + * str.rstrip! -> self or nil + * + * Removes trailing whitespace from str, returning nil if + * no change was made. See also String#lstrip! and + * String#strip!. + * + * " hello ".rstrip #=> " hello" + * "hello".rstrip! #=> nil + */ + +static VALUE +rb_str_rstrip_bang(VALUE str) +{ + rb_encoding *enc; + char *start; + long olen, roffset; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + RSTRING_GETMEM(str, start, olen); + roffset = rstrip_offset(str, start, start+olen, enc); + if (roffset > 0) { + long len = olen - roffset; + + STR_SET_LEN(str, len); +#if !SHARABLE_MIDDLE_SUBSTRING + TERM_FILL(start+len, rb_enc_mbminlen(enc)); +#endif + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.rstrip -> new_str + * + * Returns a copy of str with trailing whitespace removed. See also + * String#lstrip and String#strip. + * + * " hello ".rstrip #=> " hello" + * "hello".rstrip #=> "hello" + */ + +static VALUE +rb_str_rstrip(VALUE str) +{ + rb_encoding *enc; + char *start; + long olen, roffset; + + enc = STR_ENC_GET(str); + RSTRING_GETMEM(str, start, olen); + roffset = rstrip_offset(str, start, start+olen, enc); + + if (roffset <= 0) return rb_str_dup(str); + return rb_str_subseq(str, 0, olen-roffset); +} + + +/* + * call-seq: + * str.strip! -> str or nil + * + * Removes leading and trailing whitespace from str. Returns + * nil if str was not altered. + */ + +static VALUE +rb_str_strip_bang(VALUE str) +{ + char *start; + long olen, loffset, roffset; + rb_encoding *enc; + + str_modify_keep_cr(str); + enc = STR_ENC_GET(str); + RSTRING_GETMEM(str, start, olen); + loffset = lstrip_offset(str, start, start+olen, enc); + roffset = rstrip_offset(str, start+loffset, start+olen, enc); + + if (loffset > 0 || roffset > 0) { + long len = olen-roffset; + if (loffset > 0) { + len -= loffset; + memmove(start, start + loffset, len); + } + STR_SET_LEN(str, len); +#if !SHARABLE_MIDDLE_SUBSTRING + TERM_FILL(start+len, rb_enc_mbminlen(enc)); +#endif + return str; + } + return Qnil; +} + + +/* + * call-seq: + * str.strip -> new_str + * + * Returns a copy of str with leading and trailing whitespace removed. + * + * " hello ".strip #=> "hello" + * "\tgoodbye\r\n".strip #=> "goodbye" + */ + +static VALUE +rb_str_strip(VALUE str) +{ + char *start; + long olen, loffset, roffset; + rb_encoding *enc = STR_ENC_GET(str); + + RSTRING_GETMEM(str, start, olen); + loffset = lstrip_offset(str, start, start+olen, enc); + roffset = rstrip_offset(str, start+loffset, start+olen, enc); + + if (loffset <= 0 && roffset <= 0) return rb_str_dup(str); + return rb_str_subseq(str, loffset, olen-loffset-roffset); +} + +static VALUE +scan_once(VALUE str, VALUE pat, long *start) +{ + VALUE result, match; + struct re_registers *regs; + int i; + + if (rb_pat_search(pat, str, *start, 1) >= 0) { + match = rb_backref_get(); + regs = RMATCH_REGS(match); + if (BEG(0) == END(0)) { + rb_encoding *enc = STR_ENC_GET(str); + /* + * Always consume at least one character of the input string + */ + if (RSTRING_LEN(str) > END(0)) + *start = END(0)+rb_enc_fast_mbclen(RSTRING_PTR(str)+END(0), + RSTRING_END(str), enc); + else + *start = END(0)+1; + } + else { + *start = END(0); + } + if (regs->num_regs == 1) { + return rb_reg_nth_match(0, match); + } + result = rb_ary_new2(regs->num_regs); + for (i=1; i < regs->num_regs; i++) { + rb_ary_push(result, rb_reg_nth_match(i, match)); + } + + return result; + } + return Qnil; +} + + +/* + * call-seq: + * str.scan(pattern) -> array + * str.scan(pattern) {|match, ...| block } -> str + * + * Both forms iterate through str, matching the pattern (which may be a + * Regexp or a String). For each match, a result is + * generated and either added to the result array or passed to the block. If + * the pattern contains no groups, each individual result consists of the + * matched string, $&. If the pattern contains groups, each + * individual result is itself an array containing one entry per group. + * + * a = "cruel world" + * a.scan(/\w+/) #=> ["cruel", "world"] + * a.scan(/.../) #=> ["cru", "el ", "wor"] + * a.scan(/(...)/) #=> [["cru"], ["el "], ["wor"]] + * a.scan(/(..)(..)/) #=> [["cr", "ue"], ["l ", "wo"]] + * + * And the block form: + * + * a.scan(/\w+/) {|w| print "<<#{w}>> " } + * print "\n" + * a.scan(/(.)(.)/) {|x,y| print y, x } + * print "\n" + * + * produces: + * + * <> <> + * rceu lowlr + */ + +static VALUE +rb_str_scan(VALUE str, VALUE pat) +{ + VALUE result; + long start = 0; + long last = -1, prev = 0; + char *p = RSTRING_PTR(str); long len = RSTRING_LEN(str); + + pat = get_pat_quoted(pat, 1); + mustnot_broken(str); + if (!rb_block_given_p()) { + VALUE ary = rb_ary_new(); + + while (!NIL_P(result = scan_once(str, pat, &start))) { + last = prev; + prev = start; + rb_ary_push(ary, result); + } + if (last >= 0) rb_pat_search(pat, str, last, 1); + return ary; + } + + while (!NIL_P(result = scan_once(str, pat, &start))) { + last = prev; + prev = start; + rb_yield(result); + str_mod_check(str, p, len); + } + if (last >= 0) rb_pat_search(pat, str, last, 1); + return str; +} + + +/* + * call-seq: + * str.hex -> integer + * + * Treats leading characters from str as a string of hexadecimal digits + * (with an optional sign and an optional 0x) and returns the + * corresponding number. Zero is returned on error. + * + * "0x0a".hex #=> 10 + * "-1234".hex #=> -4660 + * "0".hex #=> 0 + * "wombat".hex #=> 0 + */ + +static VALUE +rb_str_hex(VALUE str) +{ + return rb_str_to_inum(str, 16, FALSE); +} + + +/* + * call-seq: + * str.oct -> integer + * + * Treats leading characters of str as a string of octal digits (with an + * optional sign) and returns the corresponding number. Returns 0 if the + * conversion fails. + * + * "123".oct #=> 83 + * "-377".oct #=> -255 + * "bad".oct #=> 0 + * "0377bad".oct #=> 255 + */ + +static VALUE +rb_str_oct(VALUE str) +{ + return rb_str_to_inum(str, -8, FALSE); +} + + +/* + * call-seq: + * str.crypt(salt_str) -> new_str + * + * Applies a one-way cryptographic hash to str by invoking the + * standard library function crypt(3) with the given + * salt string. While the format and the result are system and + * implementation dependent, using a salt matching the regular + * expression \A[a-zA-Z0-9./]{2} should be valid and + * safe on any platform, in which only the first two characters are + * significant. + * + * This method is for use in system specific scripts, so if you want + * a cross-platform hash function consider using Digest or OpenSSL + * instead. + */ + +static VALUE +rb_str_crypt(VALUE str, VALUE salt) +{ + extern char *crypt(const char *, const char *); + VALUE result; + const char *s, *saltp; + char *res; +#ifdef BROKEN_CRYPT + char salt_8bit_clean[3]; +#endif + + StringValue(salt); + mustnot_wchar(str); + mustnot_wchar(salt); + if (RSTRING_LEN(salt) < 2) { + short_salt: + rb_raise(rb_eArgError, "salt too short (need >=2 bytes)"); + } + + s = RSTRING_PTR(str); + if (!s) s = ""; + saltp = RSTRING_PTR(salt); + if (!saltp[0] || !saltp[1]) goto short_salt; +#ifdef BROKEN_CRYPT + if (!ISASCII((unsigned char)saltp[0]) || !ISASCII((unsigned char)saltp[1])) { + salt_8bit_clean[0] = saltp[0] & 0x7f; + salt_8bit_clean[1] = saltp[1] & 0x7f; + salt_8bit_clean[2] = '\0'; + saltp = salt_8bit_clean; + } +#endif + res = crypt(s, saltp); + if (!res) { + rb_sys_fail("crypt"); + } + result = rb_str_new_cstr(res); + OBJ_INFECT(result, str); + OBJ_INFECT(result, salt); + return result; +} + + +/* + * call-seq: + * str.ord -> integer + * + * Return the Integer ordinal of a one-character string. + * + * "a".ord #=> 97 + */ + +VALUE +rb_str_ord(VALUE s) +{ + unsigned int c; + + c = rb_enc_codepoint(RSTRING_PTR(s), RSTRING_END(s), STR_ENC_GET(s)); + return UINT2NUM(c); +} +/* + * call-seq: + * str.sum(n=16) -> integer + * + * Returns a basic n-bit checksum of the characters in str, + * where n is the optional Fixnum parameter, defaulting + * to 16. The result is simply the sum of the binary value of each byte in + * str modulo 2**n - 1. This is not a particularly good + * checksum. + */ + +static VALUE +rb_str_sum(int argc, VALUE *argv, VALUE str) +{ + VALUE vbits; + int bits; + char *ptr, *p, *pend; + long len; + VALUE sum = INT2FIX(0); + unsigned long sum0 = 0; + + if (argc == 0) { + bits = 16; + } + else { + rb_scan_args(argc, argv, "01", &vbits); + bits = NUM2INT(vbits); + if (bits < 0) + bits = 0; + } + ptr = p = RSTRING_PTR(str); + len = RSTRING_LEN(str); + pend = p + len; + + while (p < pend) { + if (FIXNUM_MAX - UCHAR_MAX < sum0) { + sum = rb_funcall(sum, '+', 1, LONG2FIX(sum0)); + str_mod_check(str, ptr, len); + sum0 = 0; + } + sum0 += (unsigned char)*p; + p++; + } + + if (bits == 0) { + if (sum0) { + sum = rb_funcall(sum, '+', 1, LONG2FIX(sum0)); + } + } + else { + if (sum == INT2FIX(0)) { + if (bits < (int)sizeof(long)*CHAR_BIT) { + sum0 &= (((unsigned long)1)<= width) return rb_str_dup(str); + n = width - len; + llen = (jflag == 'l') ? 0 : ((jflag == 'r') ? n : n/2); + rlen = n - llen; + cr = ENC_CODERANGE(str); + if (flen > 1) { + llen2 = str_offset(f, f + flen, llen % fclen, enc, singlebyte); + rlen2 = str_offset(f, f + flen, rlen % fclen, enc, singlebyte); + } + size = RSTRING_LEN(str); + if ((len = llen / fclen + rlen / fclen) >= LONG_MAX / flen || + (len *= flen) >= LONG_MAX - llen2 - rlen2 || + (len += llen2 + rlen2) >= LONG_MAX - size) { + rb_raise(rb_eArgError, "argument too big"); + } + len += size; + res = rb_str_new_with_class(str, 0, len); + p = RSTRING_PTR(res); + if (flen <= 1) { + memset(p, *f, llen); + p += llen; + } + else { + while (llen >= fclen) { + memcpy(p,f,flen); + p += flen; + llen -= fclen; + } + if (llen > 0) { + memcpy(p, f, llen2); + p += llen2; + } + } + memcpy(p, RSTRING_PTR(str), size); + p += size; + if (flen <= 1) { + memset(p, *f, rlen); + p += rlen; + } + else { + while (rlen >= fclen) { + memcpy(p,f,flen); + p += flen; + rlen -= fclen; + } + if (rlen > 0) { + memcpy(p, f, rlen2); + p += rlen2; + } + } + TERM_FILL(p, rb_enc_mbminlen(enc)); + STR_SET_LEN(res, p-RSTRING_PTR(res)); + OBJ_INFECT(res, str); + if (!NIL_P(pad)) OBJ_INFECT(res, pad); + rb_enc_associate(res, enc); + if (argc == 2) + cr = ENC_CODERANGE_AND(cr, ENC_CODERANGE(pad)); + if (cr != ENC_CODERANGE_BROKEN) + ENC_CODERANGE_SET(res, cr); + return res; +} + + +/* + * call-seq: + * str.ljust(integer, padstr=' ') -> new_str + * + * If integer is greater than the length of str, returns a new + * String of length integer with str left justified + * and padded with padstr; otherwise, returns str. + * + * "hello".ljust(4) #=> "hello" + * "hello".ljust(20) #=> "hello " + * "hello".ljust(20, '1234') #=> "hello123412341234123" + */ + +static VALUE +rb_str_ljust(int argc, VALUE *argv, VALUE str) +{ + return rb_str_justify(argc, argv, str, 'l'); +} + + +/* + * call-seq: + * str.rjust(integer, padstr=' ') -> new_str + * + * If integer is greater than the length of str, returns a new + * String of length integer with str right justified + * and padded with padstr; otherwise, returns str. + * + * "hello".rjust(4) #=> "hello" + * "hello".rjust(20) #=> " hello" + * "hello".rjust(20, '1234') #=> "123412341234123hello" + */ + +static VALUE +rb_str_rjust(int argc, VALUE *argv, VALUE str) +{ + return rb_str_justify(argc, argv, str, 'r'); +} + + +/* + * call-seq: + * str.center(width, padstr=' ') -> new_str + * + * Centers +str+ in +width+. If +width+ is greater than the length of +str+, + * returns a new String of length +width+ with +str+ centered and padded with + * +padstr+; otherwise, returns +str+. + * + * "hello".center(4) #=> "hello" + * "hello".center(20) #=> " hello " + * "hello".center(20, '123') #=> "1231231hello12312312" + */ + +static VALUE +rb_str_center(int argc, VALUE *argv, VALUE str) +{ + return rb_str_justify(argc, argv, str, 'c'); +} + +/* + * call-seq: + * str.partition(sep) -> [head, sep, tail] + * str.partition(regexp) -> [head, match, tail] + * + * Searches sep or pattern (regexp) in the string + * and returns the part before it, the match, and the part + * after it. + * If it is not found, returns two empty strings and str. + * + * "hello".partition("l") #=> ["he", "l", "lo"] + * "hello".partition("x") #=> ["hello", "", ""] + * "hello".partition(/.l/) #=> ["h", "el", "lo"] + */ + +static VALUE +rb_str_partition(VALUE str, VALUE sep) +{ + long pos; + + sep = get_pat_quoted(sep, 0); + if (RB_TYPE_P(sep, T_REGEXP)) { + pos = rb_reg_search(sep, str, 0, 0); + if (pos < 0) { + failed: + return rb_ary_new3(3, str, str_new_empty(str), str_new_empty(str)); + } + sep = rb_str_subpat(str, sep, INT2FIX(0)); + if (pos == 0 && RSTRING_LEN(sep) == 0) goto failed; + } + else { + pos = rb_str_index(str, sep, 0); + if (pos < 0) goto failed; + } + return rb_ary_new3(3, rb_str_subseq(str, 0, pos), + sep, + rb_str_subseq(str, pos+RSTRING_LEN(sep), + RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); +} + +/* + * call-seq: + * str.rpartition(sep) -> [head, sep, tail] + * str.rpartition(regexp) -> [head, match, tail] + * + * Searches sep or pattern (regexp) in the string from the end + * of the string, and returns the part before it, the match, and the part + * after it. + * If it is not found, returns two empty strings and str. + * + * "hello".rpartition("l") #=> ["hel", "l", "o"] + * "hello".rpartition("x") #=> ["", "", "hello"] + * "hello".rpartition(/.l/) #=> ["he", "ll", "o"] + */ + +static VALUE +rb_str_rpartition(VALUE str, VALUE sep) +{ + long pos = RSTRING_LEN(str); + int regex = FALSE; + + if (RB_TYPE_P(sep, T_REGEXP)) { + pos = rb_reg_search(sep, str, pos, 1); + regex = TRUE; + } + else { + VALUE tmp; + + tmp = rb_check_string_type(sep); + if (NIL_P(tmp)) { + rb_raise(rb_eTypeError, "type mismatch: %s given", + rb_obj_classname(sep)); + } + sep = tmp; + pos = rb_str_sublen(str, pos); + pos = rb_str_rindex(str, sep, pos); + } + if (pos < 0) { + return rb_ary_new3(3, str_new_empty(str), str_new_empty(str), str); + } + if (regex) { + sep = rb_reg_nth_match(0, rb_backref_get()); + } + else { + pos = rb_str_offset(str, pos); + } + return rb_ary_new3(3, rb_str_subseq(str, 0, pos), + sep, + rb_str_subseq(str, pos+RSTRING_LEN(sep), + RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); +} + +/* + * call-seq: + * str.start_with?([prefixes]+) -> true or false + * + * Returns true if +str+ starts with one of the +prefixes+ given. + * + * "hello".start_with?("hell") #=> true + * + * # returns true if one of the prefixes matches. + * "hello".start_with?("heaven", "hell") #=> true + * "hello".start_with?("heaven", "paradise") #=> false + */ + +static VALUE +rb_str_start_with(int argc, VALUE *argv, VALUE str) +{ + int i; + + for (i=0; i true or false + * + * Returns true if +str+ ends with one of the +suffixes+ given. + */ + +static VALUE +rb_str_end_with(int argc, VALUE *argv, VALUE str) +{ + int i; + char *p, *s, *e; + rb_encoding *enc; + + for (i=0; i str + * + * Changes the encoding to +encoding+ and returns self. + */ + +static VALUE +rb_str_force_encoding(VALUE str, VALUE enc) +{ + str_modifiable(str); + rb_enc_associate(str, rb_to_encoding(enc)); + ENC_CODERANGE_CLEAR(str); + return str; +} + +/* + * call-seq: + * str.b -> str + * + * Returns a copied string whose encoding is ASCII-8BIT. + */ + +static VALUE +rb_str_b(VALUE str) +{ + VALUE str2 = str_alloc(rb_cString); + str_replace_shared_without_enc(str2, str); + OBJ_INFECT(str2, str); + ENC_CODERANGE_CLEAR(str2); + return str2; +} + +/* + * call-seq: + * str.valid_encoding? -> true or false + * + * Returns true for a string which encoded correctly. + * + * "\xc2\xa1".force_encoding("UTF-8").valid_encoding? #=> true + * "\xc2".force_encoding("UTF-8").valid_encoding? #=> false + * "\x80".force_encoding("UTF-8").valid_encoding? #=> false + */ + +static VALUE +rb_str_valid_encoding_p(VALUE str) +{ + int cr = rb_enc_str_coderange(str); + + return cr == ENC_CODERANGE_BROKEN ? Qfalse : Qtrue; +} + +/* + * call-seq: + * str.ascii_only? -> true or false + * + * Returns true for a string which has only ASCII characters. + * + * "abc".force_encoding("UTF-8").ascii_only? #=> true + * "abc\u{6666}".force_encoding("UTF-8").ascii_only? #=> false + */ + +static VALUE +rb_str_is_ascii_only_p(VALUE str) +{ + int cr = rb_enc_str_coderange(str); + + return cr == ENC_CODERANGE_7BIT ? Qtrue : Qfalse; +} + +/** + * Shortens _str_ and adds three dots, an ellipsis, if it is longer + * than _len_ characters. + * + * \param str the string to ellipsize. + * \param len the maximum string length. + * \return the ellipsized string. + * \pre _len_ must not be negative. + * \post the length of the returned string in characters is less than or equal to _len_. + * \post If the length of _str_ is less than or equal _len_, returns _str_ itself. + * \post the encoding of returned string is equal to the encoding of _str_. + * \post the class of returned string is equal to the class of _str_. + * \note the length is counted in characters. + */ +VALUE +rb_str_ellipsize(VALUE str, long len) +{ + static const char ellipsis[] = "..."; + const long ellipsislen = sizeof(ellipsis) - 1; + rb_encoding *const enc = rb_enc_get(str); + const long blen = RSTRING_LEN(str); + const char *const p = RSTRING_PTR(str), *e = p + blen; + VALUE estr, ret = 0; + + if (len < 0) rb_raise(rb_eIndexError, "negative length %ld", len); + if (len * rb_enc_mbminlen(enc) >= blen || + (e = rb_enc_nth(p, e, len, enc)) - p == blen) { + ret = str; + } + else if (len <= ellipsislen || + !(e = rb_enc_step_back(p, e, e, len = ellipsislen, enc))) { + if (rb_enc_asciicompat(enc)) { + ret = rb_str_new_with_class(str, ellipsis, len); + rb_enc_associate(ret, enc); + } + else { + estr = rb_usascii_str_new(ellipsis, len); + ret = rb_str_encode(estr, rb_enc_from_encoding(enc), 0, Qnil); + } + } + else if (ret = rb_str_subseq(str, 0, e - p), rb_enc_asciicompat(enc)) { + rb_str_cat(ret, ellipsis, ellipsislen); + } + else { + estr = rb_str_encode(rb_usascii_str_new(ellipsis, ellipsislen), + rb_enc_from_encoding(enc), 0, Qnil); + rb_str_append(ret, estr); + } + return ret; +} + +static VALUE +str_compat_and_valid(VALUE str, rb_encoding *enc) +{ + int cr; + str = StringValue(str); + cr = rb_enc_str_coderange(str); + if (cr == ENC_CODERANGE_BROKEN) { + rb_raise(rb_eArgError, "replacement must be valid byte sequence '%+"PRIsVALUE"'", str); + } + else if (cr == ENC_CODERANGE_7BIT) { + rb_encoding *e = STR_ENC_GET(str); + if (!rb_enc_asciicompat(enc)) { + rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", + rb_enc_name(enc), rb_enc_name(e)); + } + } + else { /* ENC_CODERANGE_VALID */ + rb_encoding *e = STR_ENC_GET(str); + if (enc != e) { + rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", + rb_enc_name(enc), rb_enc_name(e)); + } + } + return str; +} + +/** + * @param str the string to be scrubbed + * @param repl the replacement character + * @return If given string is invalid, returns a new string. Otherwise, returns Qnil. + */ +VALUE +rb_str_scrub(VALUE str, VALUE repl) +{ + int cr = ENC_CODERANGE(str); + rb_encoding *enc; + int encidx; + + if (cr == ENC_CODERANGE_7BIT || cr == ENC_CODERANGE_VALID) + return Qnil; + + enc = STR_ENC_GET(str); + if (!NIL_P(repl)) { + repl = str_compat_and_valid(repl, enc); + } + + if (rb_enc_dummy_p(enc)) { + return Qnil; + } + encidx = rb_enc_to_index(enc); + +#define DEFAULT_REPLACE_CHAR(str) do { \ + static const char replace[sizeof(str)-1] = str; \ + rep = replace; replen = (int)sizeof(replace); \ + } while (0) + + if (rb_enc_asciicompat(enc)) { + const char *p = RSTRING_PTR(str); + const char *e = RSTRING_END(str); + const char *p1 = p; + const char *rep; + long replen; + int rep7bit_p; + VALUE buf = Qnil; + if (rb_block_given_p()) { + rep = NULL; + replen = 0; + rep7bit_p = FALSE; + } + else if (!NIL_P(repl)) { + rep = RSTRING_PTR(repl); + replen = RSTRING_LEN(repl); + rep7bit_p = (ENC_CODERANGE(repl) == ENC_CODERANGE_7BIT); + } + else if (encidx == rb_utf8_encindex()) { + DEFAULT_REPLACE_CHAR("\xEF\xBF\xBD"); + rep7bit_p = FALSE; + } + else { + DEFAULT_REPLACE_CHAR("?"); + rep7bit_p = TRUE; + } + cr = ENC_CODERANGE_7BIT; + + p = search_nonascii(p, e); + if (!p) { + p = e; + } + while (p < e) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (MBCLEN_NEEDMORE_P(ret)) { + break; + } + else if (MBCLEN_CHARFOUND_P(ret)) { + cr = ENC_CODERANGE_VALID; + p += MBCLEN_CHARFOUND_LEN(ret); + } + else if (MBCLEN_INVALID_P(ret)) { + /* + * p1~p: valid ascii/multibyte chars + * p ~e: invalid bytes + unknown bytes + */ + long clen = rb_enc_mbmaxlen(enc); + if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str)); + if (p > p1) { + rb_str_buf_cat(buf, p1, p - p1); + } + + if (e - p < clen) clen = e - p; + if (clen <= 2) { + clen = 1; + } + else { + const char *q = p; + clen--; + for (; clen > 1; clen--) { + ret = rb_enc_precise_mbclen(q, q + clen, enc); + if (MBCLEN_NEEDMORE_P(ret)) break; + if (MBCLEN_INVALID_P(ret)) continue; + UNREACHABLE; + } + } + if (rep) { + rb_str_buf_cat(buf, rep, replen); + if (!rep7bit_p) cr = ENC_CODERANGE_VALID; + } + else { + repl = rb_yield(rb_enc_str_new(p, clen, enc)); + repl = str_compat_and_valid(repl, enc); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID) + cr = ENC_CODERANGE_VALID; + } + p += clen; + p1 = p; + p = search_nonascii(p, e); + if (!p) { + p = e; + break; + } + } + else { + UNREACHABLE; + } + } + if (NIL_P(buf)) { + if (p == e) { + ENC_CODERANGE_SET(str, cr); + return Qnil; + } + buf = rb_str_buf_new(RSTRING_LEN(str)); + } + if (p1 < p) { + rb_str_buf_cat(buf, p1, p - p1); + } + if (p < e) { + if (rep) { + rb_str_buf_cat(buf, rep, replen); + if (!rep7bit_p) cr = ENC_CODERANGE_VALID; + } + else { + repl = rb_yield(rb_enc_str_new(p, e-p, enc)); + repl = str_compat_and_valid(repl, enc); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID) + cr = ENC_CODERANGE_VALID; + } + } + ENCODING_CODERANGE_SET(buf, rb_enc_to_index(enc), cr); + return buf; + } + else { + /* ASCII incompatible */ + const char *p = RSTRING_PTR(str); + const char *e = RSTRING_END(str); + const char *p1 = p; + VALUE buf = Qnil; + const char *rep; + long replen; + long mbminlen = rb_enc_mbminlen(enc); + if (!NIL_P(repl)) { + rep = RSTRING_PTR(repl); + replen = RSTRING_LEN(repl); + } + else if (encidx == ENCINDEX_UTF_16BE) { + DEFAULT_REPLACE_CHAR("\xFF\xFD"); + } + else if (encidx == ENCINDEX_UTF_16LE) { + DEFAULT_REPLACE_CHAR("\xFD\xFF"); + } + else if (encidx == ENCINDEX_UTF_32BE) { + DEFAULT_REPLACE_CHAR("\x00\x00\xFF\xFD"); + } + else if (encidx == ENCINDEX_UTF_32LE) { + DEFAULT_REPLACE_CHAR("\xFD\xFF\x00\x00"); + } + else { + DEFAULT_REPLACE_CHAR("?"); + } + + while (p < e) { + int ret = rb_enc_precise_mbclen(p, e, enc); + if (MBCLEN_NEEDMORE_P(ret)) { + break; + } + else if (MBCLEN_CHARFOUND_P(ret)) { + p += MBCLEN_CHARFOUND_LEN(ret); + } + else if (MBCLEN_INVALID_P(ret)) { + const char *q = p; + long clen = rb_enc_mbmaxlen(enc); + if (NIL_P(buf)) buf = rb_str_buf_new(RSTRING_LEN(str)); + if (p > p1) rb_str_buf_cat(buf, p1, p - p1); + + if (e - p < clen) clen = e - p; + if (clen <= mbminlen * 2) { + clen = mbminlen; + } + else { + clen -= mbminlen; + for (; clen > mbminlen; clen-=mbminlen) { + ret = rb_enc_precise_mbclen(q, q + clen, enc); + if (MBCLEN_NEEDMORE_P(ret)) break; + if (MBCLEN_INVALID_P(ret)) continue; + UNREACHABLE; + } + } + if (rep) { + rb_str_buf_cat(buf, rep, replen); + } + else { + repl = rb_yield(rb_enc_str_new(p, e-p, enc)); + repl = str_compat_and_valid(repl, enc); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + } + p += clen; + p1 = p; + } + else { + UNREACHABLE; + } + } + if (NIL_P(buf)) { + if (p == e) { + ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); + return Qnil; + } + buf = rb_str_buf_new(RSTRING_LEN(str)); + } + if (p1 < p) { + rb_str_buf_cat(buf, p1, p - p1); + } + if (p < e) { + if (rep) { + rb_str_buf_cat(buf, rep, replen); + } + else { + repl = rb_yield(rb_enc_str_new(p, e-p, enc)); + repl = str_compat_and_valid(repl, enc); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + } + } + ENCODING_CODERANGE_SET(buf, rb_enc_to_index(enc), ENC_CODERANGE_VALID); + return buf; + } +} + +/* + * call-seq: + * str.scrub -> new_str + * str.scrub(repl) -> new_str + * str.scrub{|bytes|} -> new_str + * + * If the string is invalid byte sequence then replace invalid bytes with given replacement + * character, else returns self. + * If block is given, replace invalid bytes with returned value of the block. + * + * "abc\u3042\x81".scrub #=> "abc\u3042\uFFFD" + * "abc\u3042\x81".scrub("*") #=> "abc\u3042*" + * "abc\u3042\xE3\x80".scrub{|bytes| '<'+bytes.unpack('H*')[0]+'>' } #=> "abc\u3042" + */ +static VALUE +str_scrub(int argc, VALUE *argv, VALUE str) +{ + VALUE repl = argc ? (rb_check_arity(argc, 0, 1), argv[0]) : Qnil; + VALUE new = rb_str_scrub(str, repl); + return NIL_P(new) ? rb_str_dup(str): new; +} + +/* + * call-seq: + * str.scrub! -> str + * str.scrub!(repl) -> str + * str.scrub!{|bytes|} -> str + * + * If the string is invalid byte sequence then replace invalid bytes with given replacement + * character, else returns self. + * If block is given, replace invalid bytes with returned value of the block. + * + * "abc\u3042\x81".scrub! #=> "abc\u3042\uFFFD" + * "abc\u3042\x81".scrub!("*") #=> "abc\u3042*" + * "abc\u3042\xE3\x80".scrub!{|bytes| '<'+bytes.unpack('H*')[0]+'>' } #=> "abc\u3042" + */ +static VALUE +str_scrub_bang(int argc, VALUE *argv, VALUE str) +{ + VALUE repl = argc ? (rb_check_arity(argc, 0, 1), argv[0]) : Qnil; + VALUE new = rb_str_scrub(str, repl); + if (!NIL_P(new)) rb_str_replace(str, new); + return str; +} + +/********************************************************************** + * Document-class: Symbol + * + * Symbol objects represent names and some strings + * inside the Ruby + * interpreter. They are generated using the :name and + * :"string" literals + * syntax, and by the various to_sym methods. The same + * Symbol object will be created for a given name or string + * for the duration of a program's execution, regardless of the context + * or meaning of that name. Thus if Fred is a constant in + * one context, a method in another, and a class in a third, the + * Symbol :Fred will be the same object in + * all three contexts. + * + * module One + * class Fred + * end + * $f1 = :Fred + * end + * module Two + * Fred = 1 + * $f2 = :Fred + * end + * def Fred() + * end + * $f3 = :Fred + * $f1.object_id #=> 2514190 + * $f2.object_id #=> 2514190 + * $f3.object_id #=> 2514190 + * + */ + + +/* + * call-seq: + * sym == obj -> true or false + * + * Equality---If sym and obj are exactly the same + * symbol, returns true. + */ + +#define sym_equal rb_obj_equal + +static int +sym_printable(const char *s, const char *send, rb_encoding *enc) +{ + while (s < send) { + int n; + int c = rb_enc_precise_mbclen(s, send, enc); + + if (!MBCLEN_CHARFOUND_P(c)) return FALSE; + n = MBCLEN_CHARFOUND_LEN(c); + c = rb_enc_mbc_to_codepoint(s, send, enc); + if (!rb_enc_isprint(c, enc)) return FALSE; + s += n; + } + return TRUE; +} + +int +rb_str_symname_p(VALUE sym) +{ + rb_encoding *enc; + const char *ptr; + long len; + rb_encoding *resenc = rb_default_internal_encoding(); + + if (resenc == NULL) resenc = rb_default_external_encoding(); + enc = STR_ENC_GET(sym); + ptr = RSTRING_PTR(sym); + len = RSTRING_LEN(sym); + if ((resenc != enc && !rb_str_is_ascii_only_p(sym)) || len != (long)strlen(ptr) || + !rb_enc_symname_p(ptr, enc) || !sym_printable(ptr, ptr + len, enc)) { + return FALSE; + } + return TRUE; +} + +VALUE +rb_str_quote_unprintable(VALUE str) +{ + rb_encoding *enc; + const char *ptr; + long len; + rb_encoding *resenc; + + Check_Type(str, T_STRING); + resenc = rb_default_internal_encoding(); + if (resenc == NULL) resenc = rb_default_external_encoding(); + enc = STR_ENC_GET(str); + ptr = RSTRING_PTR(str); + len = RSTRING_LEN(str); + if ((resenc != enc && !rb_str_is_ascii_only_p(str)) || + !sym_printable(ptr, ptr + len, enc)) { + return rb_str_inspect(str); + } + return str; +} + +VALUE +rb_id_quote_unprintable(ID id) +{ + return rb_str_quote_unprintable(rb_id2str(id)); +} + +/* + * call-seq: + * sym.inspect -> string + * + * Returns the representation of sym as a symbol literal. + * + * :fred.inspect #=> ":fred" + */ + +static VALUE +sym_inspect(VALUE sym) +{ + VALUE str; + const char *ptr; + long len; + char *dest; + + sym = rb_sym2str(sym); + if (!rb_str_symname_p(sym)) { + str = rb_str_inspect(sym); + len = RSTRING_LEN(str); + rb_str_resize(str, len + 1); + dest = RSTRING_PTR(str); + memmove(dest + 1, dest, len); + dest[0] = ':'; + } + else { + rb_encoding *enc = STR_ENC_GET(sym); + ptr = RSTRING_PTR(sym); + len = RSTRING_LEN(sym); + str = rb_enc_str_new(0, len + 1, enc); + dest = RSTRING_PTR(str); + dest[0] = ':'; + memcpy(dest + 1, ptr, len); + } + return str; +} + + +/* + * call-seq: + * sym.id2name -> string + * sym.to_s -> string + * + * Returns the name or string corresponding to sym. + * + * :fred.id2name #=> "fred" + */ + + +VALUE +rb_sym_to_s(VALUE sym) +{ + return str_new_shared(rb_cString, rb_sym2str(sym)); +} + + +/* + * call-seq: + * sym.to_sym -> sym + * sym.intern -> sym + * + * In general, to_sym returns the Symbol corresponding + * to an object. As sym is already a symbol, self is returned + * in this case. + */ + +static VALUE +sym_to_sym(VALUE sym) +{ + return sym; +} + +static VALUE +sym_call(VALUE args, VALUE sym, int argc, VALUE *argv, VALUE passed_proc) +{ + VALUE obj; + + if (argc < 1) { + rb_raise(rb_eArgError, "no receiver given"); + } + obj = argv[0]; + return rb_funcall_with_block(obj, (ID)sym, argc - 1, argv + 1, passed_proc); +} + +/* + * call-seq: + * sym.to_proc + * + * Returns a _Proc_ object which respond to the given method by _sym_. + * + * (1..3).collect(&:to_s) #=> ["1", "2", "3"] + */ + +static VALUE +sym_to_proc(VALUE sym) +{ + static VALUE sym_proc_cache = Qfalse; + enum {SYM_PROC_CACHE_SIZE = 67}; + VALUE proc; + long id, index; + VALUE *aryp; + + if (!sym_proc_cache) { + sym_proc_cache = rb_ary_tmp_new(SYM_PROC_CACHE_SIZE * 2); + rb_gc_register_mark_object(sym_proc_cache); + rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE*2 - 1, Qnil); + } + + id = SYM2ID(sym); + index = (id % SYM_PROC_CACHE_SIZE) << 1; + + aryp = RARRAY_PTR(sym_proc_cache); + if (aryp[index] == sym) { + return aryp[index + 1]; + } + else { + proc = rb_proc_new(sym_call, (VALUE)id); + rb_block_clear_env_self(proc); + aryp[index] = sym; + aryp[index + 1] = proc; + return proc; + } +} + +/* + * call-seq: + * + * sym.succ + * + * Same as sym.to_s.succ.intern. + */ + +static VALUE +sym_succ(VALUE sym) +{ + return rb_str_intern(rb_str_succ(rb_sym2str(sym))); +} + +/* + * call-seq: + * + * symbol <=> other_symbol -> -1, 0, +1 or nil + * + * Compares +symbol+ with +other_symbol+ after calling #to_s on each of the + * symbols. Returns -1, 0, +1 or nil depending on whether +symbol+ is less + * than, equal to, or greater than +other_symbol+. + * + * +nil+ is returned if the two values are incomparable. + * + * See String#<=> for more information. + */ + +static VALUE +sym_cmp(VALUE sym, VALUE other) +{ + if (!SYMBOL_P(other)) { + return Qnil; + } + return rb_str_cmp_m(rb_sym2str(sym), rb_sym2str(other)); +} + +/* + * call-seq: + * + * sym.casecmp(other) -> -1, 0, +1 or nil + * + * Case-insensitive version of Symbol#<=>. + */ + +static VALUE +sym_casecmp(VALUE sym, VALUE other) +{ + if (!SYMBOL_P(other)) { + return Qnil; + } + return rb_str_casecmp(rb_sym2str(sym), rb_sym2str(other)); +} + +/* + * call-seq: + * sym =~ obj -> fixnum or nil + * sym.match(obj) -> fixnum or nil + * + * Returns sym.to_s =~ obj. + */ + +static VALUE +sym_match(VALUE sym, VALUE other) +{ + return rb_str_match(rb_sym2str(sym), other); +} + +/* + * call-seq: + * sym[idx] -> char + * sym[b, n] -> string + * sym.slice(idx) -> char + * sym.slice(b, n) -> string + * + * Returns sym.to_s[]. + */ + +static VALUE +sym_aref(int argc, VALUE *argv, VALUE sym) +{ + return rb_str_aref_m(argc, argv, rb_sym2str(sym)); +} + +/* + * call-seq: + * sym.length -> integer + * sym.size -> integer + * + * Same as sym.to_s.length. + */ + +static VALUE +sym_length(VALUE sym) +{ + return rb_str_length(rb_sym2str(sym)); +} + +/* + * call-seq: + * sym.empty? -> true or false + * + * Returns that _sym_ is :"" or not. + */ + +static VALUE +sym_empty(VALUE sym) +{ + return rb_str_empty(rb_sym2str(sym)); +} + +/* + * call-seq: + * sym.upcase -> symbol + * + * Same as sym.to_s.upcase.intern. + */ + +static VALUE +sym_upcase(VALUE sym) +{ + return rb_str_intern(rb_str_upcase(rb_sym2str(sym))); +} + +/* + * call-seq: + * sym.downcase -> symbol + * + * Same as sym.to_s.downcase.intern. + */ + +static VALUE +sym_downcase(VALUE sym) +{ + return rb_str_intern(rb_str_downcase(rb_sym2str(sym))); +} + +/* + * call-seq: + * sym.capitalize -> symbol + * + * Same as sym.to_s.capitalize.intern. + */ + +static VALUE +sym_capitalize(VALUE sym) +{ + return rb_str_intern(rb_str_capitalize(rb_sym2str(sym))); +} + +/* + * call-seq: + * sym.swapcase -> symbol + * + * Same as sym.to_s.swapcase.intern. + */ + +static VALUE +sym_swapcase(VALUE sym) +{ + return rb_str_intern(rb_str_swapcase(rb_sym2str(sym))); +} + +/* + * call-seq: + * sym.encoding -> encoding + * + * Returns the Encoding object that represents the encoding of _sym_. + */ + +static VALUE +sym_encoding(VALUE sym) +{ + return rb_obj_encoding(rb_sym2str(sym)); +} + +static VALUE +string_for_symbol(VALUE name) +{ + if (!RB_TYPE_P(name, T_STRING)) { + VALUE tmp = rb_check_string_type(name); + if (NIL_P(tmp)) { + rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a symbol", + name); + } + name = tmp; + } + return name; +} + +ID +rb_to_id(VALUE name) +{ + if (SYMBOL_P(name)) { + return SYM2ID(name); + } + name = string_for_symbol(name); + return rb_intern_str(name); +} + +VALUE +rb_to_symbol(VALUE name) +{ + if (SYMBOL_P(name)) { + return name; + } + name = string_for_symbol(name); + return rb_str_intern(name); +} + +/* + * A String object holds and manipulates an arbitrary sequence of + * bytes, typically representing characters. String objects may be created + * using String::new or as literals. + * + * Because of aliasing issues, users of strings should be aware of the methods + * that modify the contents of a String object. Typically, + * methods with names ending in ``!'' modify their receiver, while those + * without a ``!'' return a new String. However, there are + * exceptions, such as String#[]=. + * + */ + +void +Init_String(void) +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + rb_cString = rb_define_class("String", rb_cObject); + rb_include_module(rb_cString, rb_mComparable); + rb_define_alloc_func(rb_cString, empty_str_alloc); + rb_define_singleton_method(rb_cString, "try_convert", rb_str_s_try_convert, 1); + rb_define_method(rb_cString, "initialize", rb_str_init, -1); + rb_define_method(rb_cString, "initialize_copy", rb_str_replace, 1); + rb_define_method(rb_cString, "<=>", rb_str_cmp_m, 1); + rb_define_method(rb_cString, "==", rb_str_equal, 1); + rb_define_method(rb_cString, "===", rb_str_equal, 1); + rb_define_method(rb_cString, "eql?", rb_str_eql, 1); + rb_define_method(rb_cString, "hash", rb_str_hash_m, 0); + rb_define_method(rb_cString, "casecmp", rb_str_casecmp, 1); + rb_define_method(rb_cString, "+", rb_str_plus, 1); + rb_define_method(rb_cString, "*", rb_str_times, 1); + rb_define_method(rb_cString, "%", rb_str_format_m, 1); + rb_define_method(rb_cString, "[]", rb_str_aref_m, -1); + rb_define_method(rb_cString, "[]=", rb_str_aset_m, -1); + rb_define_method(rb_cString, "insert", rb_str_insert, 2); + rb_define_method(rb_cString, "length", rb_str_length, 0); + rb_define_method(rb_cString, "size", rb_str_length, 0); + rb_define_method(rb_cString, "bytesize", rb_str_bytesize, 0); + rb_define_method(rb_cString, "empty?", rb_str_empty, 0); + rb_define_method(rb_cString, "=~", rb_str_match, 1); + rb_define_method(rb_cString, "match", rb_str_match_m, -1); + rb_define_method(rb_cString, "succ", rb_str_succ, 0); + rb_define_method(rb_cString, "succ!", rb_str_succ_bang, 0); + rb_define_method(rb_cString, "next", rb_str_succ, 0); + rb_define_method(rb_cString, "next!", rb_str_succ_bang, 0); + rb_define_method(rb_cString, "upto", rb_str_upto, -1); + rb_define_method(rb_cString, "index", rb_str_index_m, -1); + rb_define_method(rb_cString, "rindex", rb_str_rindex_m, -1); + rb_define_method(rb_cString, "replace", rb_str_replace, 1); + rb_define_method(rb_cString, "clear", rb_str_clear, 0); + rb_define_method(rb_cString, "chr", rb_str_chr, 0); + rb_define_method(rb_cString, "getbyte", rb_str_getbyte, 1); + rb_define_method(rb_cString, "setbyte", rb_str_setbyte, 2); + rb_define_method(rb_cString, "byteslice", rb_str_byteslice, -1); + rb_define_method(rb_cString, "scrub", str_scrub, -1); + rb_define_method(rb_cString, "scrub!", str_scrub_bang, -1); + rb_define_method(rb_cString, "freeze", rb_obj_freeze, 0); + + rb_define_method(rb_cString, "to_i", rb_str_to_i, -1); + rb_define_method(rb_cString, "to_f", rb_str_to_f, 0); + rb_define_method(rb_cString, "to_s", rb_str_to_s, 0); + rb_define_method(rb_cString, "to_str", rb_str_to_s, 0); + rb_define_method(rb_cString, "inspect", rb_str_inspect, 0); + rb_define_method(rb_cString, "dump", rb_str_dump, 0); + + rb_define_method(rb_cString, "upcase", rb_str_upcase, 0); + rb_define_method(rb_cString, "downcase", rb_str_downcase, 0); + rb_define_method(rb_cString, "capitalize", rb_str_capitalize, 0); + rb_define_method(rb_cString, "swapcase", rb_str_swapcase, 0); + + rb_define_method(rb_cString, "upcase!", rb_str_upcase_bang, 0); + rb_define_method(rb_cString, "downcase!", rb_str_downcase_bang, 0); + rb_define_method(rb_cString, "capitalize!", rb_str_capitalize_bang, 0); + rb_define_method(rb_cString, "swapcase!", rb_str_swapcase_bang, 0); + + rb_define_method(rb_cString, "hex", rb_str_hex, 0); + rb_define_method(rb_cString, "oct", rb_str_oct, 0); + rb_define_method(rb_cString, "split", rb_str_split_m, -1); + rb_define_method(rb_cString, "lines", rb_str_lines, -1); + rb_define_method(rb_cString, "bytes", rb_str_bytes, 0); + rb_define_method(rb_cString, "chars", rb_str_chars, 0); + rb_define_method(rb_cString, "codepoints", rb_str_codepoints, 0); + rb_define_method(rb_cString, "reverse", rb_str_reverse, 0); + rb_define_method(rb_cString, "reverse!", rb_str_reverse_bang, 0); + rb_define_method(rb_cString, "concat", rb_str_concat, 1); + rb_define_method(rb_cString, "<<", rb_str_concat, 1); + rb_define_method(rb_cString, "prepend", rb_str_prepend, 1); + rb_define_method(rb_cString, "crypt", rb_str_crypt, 1); + rb_define_method(rb_cString, "intern", rb_str_intern, 0); /* in symbol.c */ + rb_define_method(rb_cString, "to_sym", rb_str_intern, 0); /* in symbol.c */ + rb_define_method(rb_cString, "ord", rb_str_ord, 0); + + rb_define_method(rb_cString, "include?", rb_str_include, 1); + rb_define_method(rb_cString, "start_with?", rb_str_start_with, -1); + rb_define_method(rb_cString, "end_with?", rb_str_end_with, -1); + + rb_define_method(rb_cString, "scan", rb_str_scan, 1); + + rb_define_method(rb_cString, "ljust", rb_str_ljust, -1); + rb_define_method(rb_cString, "rjust", rb_str_rjust, -1); + rb_define_method(rb_cString, "center", rb_str_center, -1); + + rb_define_method(rb_cString, "sub", rb_str_sub, -1); + rb_define_method(rb_cString, "gsub", rb_str_gsub, -1); + rb_define_method(rb_cString, "chop", rb_str_chop, 0); + rb_define_method(rb_cString, "chomp", rb_str_chomp, -1); + rb_define_method(rb_cString, "strip", rb_str_strip, 0); + rb_define_method(rb_cString, "lstrip", rb_str_lstrip, 0); + rb_define_method(rb_cString, "rstrip", rb_str_rstrip, 0); + + rb_define_method(rb_cString, "sub!", rb_str_sub_bang, -1); + rb_define_method(rb_cString, "gsub!", rb_str_gsub_bang, -1); + rb_define_method(rb_cString, "chop!", rb_str_chop_bang, 0); + rb_define_method(rb_cString, "chomp!", rb_str_chomp_bang, -1); + rb_define_method(rb_cString, "strip!", rb_str_strip_bang, 0); + rb_define_method(rb_cString, "lstrip!", rb_str_lstrip_bang, 0); + rb_define_method(rb_cString, "rstrip!", rb_str_rstrip_bang, 0); + + rb_define_method(rb_cString, "tr", rb_str_tr, 2); + rb_define_method(rb_cString, "tr_s", rb_str_tr_s, 2); + rb_define_method(rb_cString, "delete", rb_str_delete, -1); + rb_define_method(rb_cString, "squeeze", rb_str_squeeze, -1); + rb_define_method(rb_cString, "count", rb_str_count, -1); + + rb_define_method(rb_cString, "tr!", rb_str_tr_bang, 2); + rb_define_method(rb_cString, "tr_s!", rb_str_tr_s_bang, 2); + rb_define_method(rb_cString, "delete!", rb_str_delete_bang, -1); + rb_define_method(rb_cString, "squeeze!", rb_str_squeeze_bang, -1); + + rb_define_method(rb_cString, "each_line", rb_str_each_line, -1); + rb_define_method(rb_cString, "each_byte", rb_str_each_byte, 0); + rb_define_method(rb_cString, "each_char", rb_str_each_char, 0); + rb_define_method(rb_cString, "each_codepoint", rb_str_each_codepoint, 0); + + rb_define_method(rb_cString, "sum", rb_str_sum, -1); + + rb_define_method(rb_cString, "slice", rb_str_aref_m, -1); + rb_define_method(rb_cString, "slice!", rb_str_slice_bang, -1); + + rb_define_method(rb_cString, "partition", rb_str_partition, 1); + rb_define_method(rb_cString, "rpartition", rb_str_rpartition, 1); + + rb_define_method(rb_cString, "encoding", rb_obj_encoding, 0); /* in encoding.c */ + rb_define_method(rb_cString, "force_encoding", rb_str_force_encoding, 1); + rb_define_method(rb_cString, "b", rb_str_b, 0); + rb_define_method(rb_cString, "valid_encoding?", rb_str_valid_encoding_p, 0); + rb_define_method(rb_cString, "ascii_only?", rb_str_is_ascii_only_p, 0); + + id_to_s = rb_intern("to_s"); + + rb_fs = Qnil; + rb_define_variable("$;", &rb_fs); + rb_define_variable("$-F", &rb_fs); + + rb_cSymbol = rb_define_class("Symbol", rb_cObject); + rb_include_module(rb_cSymbol, rb_mComparable); + rb_undef_alloc_func(rb_cSymbol); + rb_undef_method(CLASS_OF(rb_cSymbol), "new"); + rb_define_singleton_method(rb_cSymbol, "all_symbols", rb_sym_all_symbols, 0); /* in symbol.c */ + + rb_define_method(rb_cSymbol, "==", sym_equal, 1); + rb_define_method(rb_cSymbol, "===", sym_equal, 1); + rb_define_method(rb_cSymbol, "inspect", sym_inspect, 0); + rb_define_method(rb_cSymbol, "to_s", rb_sym_to_s, 0); + rb_define_method(rb_cSymbol, "id2name", rb_sym_to_s, 0); + rb_define_method(rb_cSymbol, "intern", sym_to_sym, 0); + rb_define_method(rb_cSymbol, "to_sym", sym_to_sym, 0); + rb_define_method(rb_cSymbol, "to_proc", sym_to_proc, 0); + rb_define_method(rb_cSymbol, "succ", sym_succ, 0); + rb_define_method(rb_cSymbol, "next", sym_succ, 0); + + rb_define_method(rb_cSymbol, "<=>", sym_cmp, 1); + rb_define_method(rb_cSymbol, "casecmp", sym_casecmp, 1); + rb_define_method(rb_cSymbol, "=~", sym_match, 1); + + rb_define_method(rb_cSymbol, "[]", sym_aref, -1); + rb_define_method(rb_cSymbol, "slice", sym_aref, -1); + rb_define_method(rb_cSymbol, "length", sym_length, 0); + rb_define_method(rb_cSymbol, "size", sym_length, 0); + rb_define_method(rb_cSymbol, "empty?", sym_empty, 0); + rb_define_method(rb_cSymbol, "match", sym_match, 1); + + rb_define_method(rb_cSymbol, "upcase", sym_upcase, 0); + rb_define_method(rb_cSymbol, "downcase", sym_downcase, 0); + rb_define_method(rb_cSymbol, "capitalize", sym_capitalize, 0); + rb_define_method(rb_cSymbol, "swapcase", sym_swapcase, 0); + + rb_define_method(rb_cSymbol, "encoding", sym_encoding, 0); + + assert(rb_vm_fstring_table()); + st_foreach(rb_vm_fstring_table(), fstring_set_class_i, rb_cString); +} + +void +Init_frozen_strings(void) +{ + assert(!frozen_strings); + frozen_strings = st_init_table_with_size(&fstring_hash_type, 1000); +} -- cgit v1.2.3