diff options
Diffstat (limited to 'string.c')
| -rw-r--r-- | string.c | 11736 |
1 files changed, 5008 insertions, 6728 deletions
@@ -11,57 +11,43 @@ **********************************************************************/ -#include "ruby/internal/config.h" +#include "internal.h" +#include "ruby/re.h" +#include "encindex.h" +#include "probes.h" +#include "gc.h" +#include "ruby_assert.h" +#include "id.h" +#include "debug_counter.h" +#include "ruby/util.h" + +#define BEG(no) (regs->beg[(no)]) +#define END(no) (regs->end[(no)]) -#include <ctype.h> -#include <errno.h> #include <math.h> +#include <ctype.h> #ifdef HAVE_UNISTD_H -# include <unistd.h> +#include <unistd.h> #endif -#include "debug_counter.h" -#include "encindex.h" -#include "id.h" -#include "internal.h" -#include "internal/array.h" -#include "internal/compar.h" -#include "internal/compilers.h" -#include "internal/encoding.h" -#include "internal/error.h" -#include "internal/gc.h" -#include "internal/numeric.h" -#include "internal/object.h" -#include "internal/proc.h" -#include "internal/re.h" -#include "internal/sanitizers.h" -#include "internal/string.h" -#include "internal/transcode.h" -#include "probes.h" -#include "ruby/encoding.h" -#include "ruby/re.h" -#include "ruby/util.h" -#include "ruby_assert.h" -#include "vm_sync.h" - #if defined HAVE_CRYPT_R # if defined HAVE_CRYPT_H -# include <crypt.h> +# include <crypt.h> # endif #elif !defined HAVE_CRYPT # include "missing/crypt.h" # define HAVE_CRYPT_R 1 #endif -#define BEG(no) (regs->beg[(no)]) -#define END(no) (regs->end[(no)]) +#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 @@ -74,99 +60,71 @@ #undef rb_str_cat2 #undef rb_str_cat_cstr #undef rb_fstring_cstr +#undef rb_fstring_enc_cstr + +static VALUE rb_str_clear(VALUE str); VALUE rb_cString; VALUE rb_cSymbol; -/* Flags of RString +/* FLAGS of RString * - * 0: STR_SHARED (equal to ELTS_SHARED) - * The string is shared. The buffer this string points to is owned by - * another string (the shared root). * 1: RSTRING_NOEMBED - * The string is not embedded. When a string is embedded, the contents - * follow the header. When a string is not embedded, the contents is - * on a separately allocated buffer. - * 2: STR_CHILLED_LITERAL (will be frozen in a future version) - * The string was allocated as a literal in a file without an explicit `frozen_string_literal` comment. - * It emits a deprecation warning when mutated for the first time. - * 3: STR_CHILLED_SYMBOL_TO_S (will be frozen in a future version) - * The string was allocated by the `Symbol#to_s` method. - * It emits a deprecation warning when mutated for the first time. - * 4: STR_PRECOMPUTED_HASH - * The string is embedded and has its precomputed hashcode stored - * after the terminator. - * 5: STR_SHARED_ROOT - * Other strings may point to the contents of this string. When this - * flag is set, STR_SHARED must not be set. - * 6: STR_BORROWED - * When RSTRING_NOEMBED is set and klass is 0, this string is unsafe - * to be unshared by rb_str_tmp_frozen_release. + * 2: STR_SHARED (== ELTS_SHARED) + * 2-6: RSTRING_EMBED_LEN (5 bits == 32) + * 6: STR_IS_SHARED_M (shared, when RSTRING_NOEMBED==1 && klass==0) * 7: STR_TMPLOCK - * The pointer to the buffer is passed to a system call such as - * read(2). Any modification and realloc is prohibited. - * 8-9: ENC_CODERANGE - * Stores the coderange of the string. - * 10-16: ENCODING - * Stores the encoding of the string. + * 8-9: ENC_CODERANGE (2 bits) + * 10-16: ENCODING (7 bits == 128) * 17: RSTRING_FSTR - * The string is a fstring. The string is deduplicated in the fstring - * table. * 18: STR_NOFREE - * Do not free this string's buffer when the string is reclaimed - * by the garbage collector. Used for when the string buffer is a C - * string literal. * 19: STR_FAKESTR - * The string is not allocated or managed by the garbage collector. - * Typically, the string object header (struct RString) is temporarily - * allocated on C stack. */ #define RUBY_MAX_CHAR_LEN 16 -#define STR_PRECOMPUTED_HASH FL_USER4 -#define STR_SHARED_ROOT FL_USER5 -#define STR_BORROWED FL_USER6 +#define STR_IS_SHARED_M FL_USER6 #define STR_TMPLOCK FL_USER7 #define STR_NOFREE FL_USER18 #define STR_FAKESTR FL_USER19 #define STR_SET_NOEMBED(str) do {\ FL_SET((str), STR_NOEMBED);\ - FL_UNSET((str), STR_SHARED | STR_SHARED_ROOT | STR_BORROWED);\ + 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_EMBED(str) FL_UNSET((str), STR_NOEMBED | STR_SHARED | STR_NOFREE) #define STR_SET_LEN(str, n) do { \ - RSTRING(str)->len = (n); \ + if (STR_EMBED_P(str)) {\ + STR_SET_EMBED_LEN((str), (n));\ + }\ + else {\ + RSTRING(str)->as.heap.len = (n);\ + }\ } while (0) -static inline bool -str_encindex_fastpath(int encindex) -{ - // The overwhelming majority of strings are in one of these 3 encodings. - switch (encindex) { - case ENCINDEX_ASCII_8BIT: - case ENCINDEX_UTF_8: - case ENCINDEX_US_ASCII: - return true; - default: - return false; - } -} - -static inline bool -str_enc_fastpath(VALUE str) -{ - return str_encindex_fastpath(ENCODING_GET_INLINED(str)); -} +#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) (str_enc_fastpath(str) ? 1 : rb_enc_mbminlen(rb_enc_from_index(ENCODING_GET(str)))) +#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);\ + memset(term_fill_ptr, 0, term_fill_len);\ } while (0) #define RESIZE_CAPA(str,capacity) do {\ @@ -175,39 +133,34 @@ str_enc_fastpath(VALUE str) } while (0) #define RESIZE_CAPA_TERM(str,capacity,termlen) do {\ if (STR_EMBED_P(str)) {\ - if (str_embed_capa(str) < capacity + termlen) {\ - char *const tmp = ALLOC_N(char, (size_t)(capacity) + (termlen));\ - const long tlen = RSTRING_LEN(str);\ - memcpy(tmp, RSTRING_PTR(str), tlen);\ - RSTRING(str)->as.heap.ptr = tmp;\ - RSTRING(str)->len = tlen;\ + if (!STR_EMBEDDABLE_P(capacity, termlen)) {\ + char *const tmp = ALLOC_N(char, (size_t)(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);\ - }\ + RSTRING(str)->as.heap.aux.capa = (capacity);\ + }\ }\ else {\ - RUBY_ASSERT(!FL_TEST((str), STR_SHARED)); \ - SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, \ - (size_t)(capacity) + (termlen), STR_HEAP_SIZE(str)); \ - RSTRING(str)->as.heap.aux.capa = (capacity);\ + assert(!FL_TEST((str), STR_SHARED)); \ + REALLOC_N(RSTRING(str)->as.heap.ptr, char, (size_t)(capacity) + (termlen));\ + RSTRING(str)->as.heap.aux.capa = (capacity);\ }\ } while (0) #define STR_SET_SHARED(str, shared_str) do { \ if (!FL_TEST(str, STR_FAKESTR)) { \ - RUBY_ASSERT(RSTRING_PTR(shared_str) <= RSTRING_PTR(str)); \ - RUBY_ASSERT(RSTRING_PTR(str) <= RSTRING_PTR(shared_str) + RSTRING_LEN(shared_str)); \ - RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \ - FL_SET((str), STR_SHARED); \ - FL_SET((shared_str), STR_SHARED_ROOT); \ - if (RBASIC_CLASS((shared_str)) == 0) /* for CoW-friendliness */ \ - FL_SET_RAW((shared_str), STR_BORROWED); \ + RB_OBJ_WRITE((str), &RSTRING(str)->as.heap.aux.shared, (shared_str)); \ + FL_SET((str), STR_SHARED); \ + if (RBASIC_CLASS((shared_str)) == 0) /* for CoW-friendliness */ \ + FL_SET_RAW((shared_str), STR_IS_SHARED_M); \ } \ } while (0) #define STR_HEAP_PTR(str) (RSTRING(str)->as.heap.ptr) #define STR_HEAP_SIZE(str) ((size_t)RSTRING(str)->as.heap.aux.capa + TERM_LEN(str)) -/* TODO: include the terminator size in capa. */ #define STR_ENC_GET(str) get_encoding(str) @@ -220,63 +173,16 @@ str_enc_fastpath(VALUE str) #define SHARABLE_SUBSTRING_P(beg, len, end) 1 #endif - -static inline long -str_embed_capa(VALUE str) -{ - return rb_gc_obj_slot_size(str) - offsetof(struct RString, as.embed.ary); -} - -bool -rb_str_reembeddable_p(VALUE str) -{ - return !FL_TEST(str, STR_NOFREE|STR_SHARED_ROOT|STR_SHARED); -} - -static inline size_t -rb_str_embed_size(long capa) -{ - return offsetof(struct RString, as.embed.ary) + capa; -} - -size_t -rb_str_size_as_embedded(VALUE str) -{ - size_t real_size; - if (STR_EMBED_P(str)) { - real_size = rb_str_embed_size(RSTRING(str)->len) + TERM_LEN(str); - } - /* if the string is not currently embedded, but it can be embedded, how - * much space would it require */ - else if (rb_str_reembeddable_p(str)) { - real_size = rb_str_embed_size(RSTRING(str)->as.heap.aux.capa) + TERM_LEN(str); - } - else { - real_size = sizeof(struct RString); - } - - if (FL_TEST_RAW(str, STR_PRECOMPUTED_HASH)) { - real_size += sizeof(st_index_t); - } - - return real_size; -} - -static inline bool -STR_EMBEDDABLE_P(long len, long termlen) -{ - return rb_gc_size_allocatable_p(rb_str_embed_size(len + termlen)); -} +#define STR_EMBEDDABLE_P(len, termlen) \ + ((len) <= RSTRING_EMBED_LEN_MAX + 1 - (termlen)) static VALUE str_replace_shared_without_enc(VALUE str2, VALUE str); +static VALUE str_new_shared(VALUE klass, VALUE str); static VALUE str_new_frozen(VALUE klass, VALUE orig); -static VALUE str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding); static VALUE str_new_static(VALUE klass, const char *ptr, long len, int encindex); -static VALUE str_new(VALUE klass, const char *ptr, long len); static void str_make_independent_expand(VALUE str, long len, long expand, const int termlen); static inline void str_modifiable(VALUE str); static VALUE rb_str_downcase(int argc, VALUE *argv, VALUE str); -static inline VALUE str_alloc_embed(VALUE klass, size_t capa); static inline void str_make_independent(VALUE str) @@ -286,60 +192,50 @@ str_make_independent(VALUE str) str_make_independent_expand((str), len, 0L, termlen); } -static inline int str_dependent_p(VALUE str); - -void -rb_str_make_independent(VALUE str) -{ - if (str_dependent_p(str)) { - str_make_independent(str); - } -} +/* symbols for [up|down|swap]case/capitalize options */ +static VALUE sym_ascii, sym_turkic, sym_lithuanian, sym_fold; -void -rb_str_make_embedded(VALUE str) +static rb_encoding * +get_actual_encoding(const int encidx, VALUE str) { - RUBY_ASSERT(rb_str_reembeddable_p(str)); - RUBY_ASSERT(!STR_EMBED_P(str)); - - char *buf = RSTRING(str)->as.heap.ptr; - long len = RSTRING(str)->len; - - STR_SET_EMBED(str); - STR_SET_LEN(str, len); + const unsigned char *q; - if (len > 0) { - memcpy(RSTRING_PTR(str), buf, len); - ruby_xfree(buf); - } - - TERM_FILL(RSTRING(str)->as.embed.ary + len, TERM_LEN(str)); -} - -void -rb_debug_rstring_null_ptr(const char *func) -{ - fprintf(stderr, "%s is returning NULL!! " - "SIGSEGV is highly expected to follow immediately.\n" - "If you could reproduce, attach your debugger here, " - "and look at the passed string.\n", - func); + 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); } -/* symbols for [up|down|swap]case/capitalize options */ -static VALUE sym_ascii, sym_turkic, sym_lithuanian, sym_fold; - static rb_encoding * get_encoding(VALUE str) { - return rb_enc_from_index(ENCODING_GET(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))); + rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(STR_ENC_GET(str))); } } @@ -348,155 +244,65 @@ 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)); + rb_raise(rb_eArgError, "wide char encoding: %s", rb_enc_name(enc)); } } static int fstring_cmp(VALUE a, VALUE b); -static VALUE register_fstring(VALUE str, bool copy, bool force_precompute_hash); - -#if SIZEOF_LONG == SIZEOF_VOIDP -#define PRECOMPUTED_FAKESTR_HASH 1 -#else -#endif - -#ifdef PRECOMPUTED_FAKESTR_HASH -static st_index_t -fstring_hash(VALUE str) -{ - if (FL_TEST_RAW(str, STR_FAKESTR)) { - // register_fstring precomputes the hash and stores it in capa for fake strings - return (st_index_t)RSTRING(str)->as.heap.aux.capa; - } - else { - return rb_str_hash(str); - } -} -#else -#define fstring_hash rb_str_hash -#endif +static VALUE register_fstring(VALUE str); const struct st_hash_type rb_fstring_hash_type = { fstring_cmp, - fstring_hash, + rb_str_hash, }; -#define BARE_STRING_P(str) (!FL_ANY_RAW(str, FL_EXIVAR) && RBASIC_CLASS(str) == rb_cString) - -static inline st_index_t -str_do_hash(VALUE str) -{ - st_index_t h = rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str)); - int e = RSTRING_LEN(str) ? ENCODING_GET(str) : 0; - if (e && !is_ascii_string(str)) { - h = rb_hash_end(rb_hash_uint32(h, (uint32_t)e)); - } - return h; -} - -static VALUE -str_store_precomputed_hash(VALUE str, st_index_t hash) -{ - RUBY_ASSERT(!FL_TEST_RAW(str, STR_PRECOMPUTED_HASH)); - RUBY_ASSERT(STR_EMBED_P(str)); - -#if RUBY_DEBUG - size_t used_bytes = (RSTRING_LEN(str) + TERM_LEN(str)); - size_t free_bytes = str_embed_capa(str) - used_bytes; - RUBY_ASSERT(free_bytes >= sizeof(st_index_t)); -#endif - - memcpy(RSTRING_END(str) + TERM_LEN(str), &hash, sizeof(hash)); - - FL_SET(str, STR_PRECOMPUTED_HASH); - - return str; -} - -struct fstr_update_arg { - VALUE fstr; - bool copy; - bool force_precompute_hash; -}; +#define BARE_STRING_P(str) (!FL_ANY_RAW(str, FL_TAINT|FL_EXIVAR) && RBASIC_CLASS(str) == rb_cString) static int -fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t data, int existing) +fstr_update_callback(st_data_t *key, st_data_t *value, st_data_t arg, int existing) { - struct fstr_update_arg *arg = (struct fstr_update_arg *)data; + VALUE *fstr = (VALUE *)arg; VALUE str = (VALUE)*key; if (existing) { - /* because of lazy sweep, str may be unmarked already and swept - * at next time */ + /* because of lazy sweep, str may be unmarked already and swept + * at next time */ - if (rb_objspace_garbage_object_p(str)) { - arg->fstr = Qundef; - return ST_DELETE; - } + if (rb_objspace_garbage_object_p(str)) { + *fstr = Qundef; + return ST_DELETE; + } - arg->fstr = str; - return ST_STOP; + *fstr = str; + return ST_STOP; } else { - // Unless the string is empty or binary, its coderange has been precomputed. - int coderange = ENC_CODERANGE(str); - - if (FL_TEST_RAW(str, STR_FAKESTR)) { - if (arg->copy) { - VALUE new_str; - long len = RSTRING_LEN(str); - long capa = len + sizeof(st_index_t); - int term_len = TERM_LEN(str); - - if (arg->force_precompute_hash && STR_EMBEDDABLE_P(capa, term_len)) { - new_str = str_alloc_embed(rb_cString, capa + term_len); - memcpy(RSTRING_PTR(new_str), RSTRING_PTR(str), len); - STR_SET_LEN(new_str, RSTRING_LEN(str)); - TERM_FILL(RSTRING_END(new_str), TERM_LEN(str)); - rb_enc_copy(new_str, str); - str_store_precomputed_hash(new_str, fstring_hash(str)); - } - else { - new_str = str_new(rb_cString, RSTRING(str)->as.heap.ptr, RSTRING(str)->len); - rb_enc_copy(new_str, str); -#ifdef PRECOMPUTED_FAKESTR_HASH - if (rb_str_capacity(new_str) >= RSTRING_LEN(str) + term_len + sizeof(st_index_t)) { - str_store_precomputed_hash(new_str, (st_index_t)RSTRING(str)->as.heap.aux.capa); - } -#endif - } - str = new_str; - } - else { - str = str_new_static(rb_cString, RSTRING(str)->as.heap.ptr, - RSTRING(str)->len, - ENCODING_GET(str)); - } - OBJ_FREEZE(str); - } - else { - if (!OBJ_FROZEN(str) || CHILLED_STRING_P(str)) { - str = str_new_frozen(rb_cString, str); - } - if (STR_SHARED_P(str)) { /* str should not be shared */ - /* shared substring */ - str_make_independent(str); - RUBY_ASSERT(OBJ_FROZEN(str)); - } - if (!BARE_STRING_P(str)) { - str = str_new_frozen(rb_cString, str); - } - } - - ENC_CODERANGE_SET(str, coderange); - RBASIC(str)->flags |= RSTRING_FSTR; - - *key = *value = arg->fstr = str; - return ST_CONTINUE; - } -} - + if (FL_TEST_RAW(str, STR_FAKESTR)) { + str = str_new_static(rb_cString, RSTRING(str)->as.heap.ptr, + RSTRING(str)->as.heap.len, + ENCODING_GET(str)); + OBJ_FREEZE_RAW(str); + } + else { + str = str_new_frozen(rb_cString, str); + if (STR_SHARED_P(str)) { /* str should not be shared */ + /* shared substring */ + str_make_independent(str); + assert(OBJ_FROZEN(str)); + } + if (!BARE_STRING_P(str)) { + str = str_new_frozen(rb_cString, str); + } + } + RBASIC(str)->flags |= RSTRING_FSTR; + + *key = *value = *fstr = str; + return ST_CONTINUE; + } +} + +RUBY_FUNC_EXPORTED VALUE rb_fstring(VALUE str) { @@ -506,113 +312,77 @@ rb_fstring(VALUE str) Check_Type(str, T_STRING); if (FL_TEST(str, RSTRING_FSTR)) - return str; + return str; bare = BARE_STRING_P(str); - if (!bare) { - if (STR_EMBED_P(str)) { - OBJ_FREEZE(str); - return str; - } - - if (FL_TEST_RAW(str, STR_SHARED_ROOT | STR_SHARED) == STR_SHARED_ROOT) { - RUBY_ASSERT(OBJ_FROZEN(str)); - return str; - } + if (STR_EMBED_P(str) && !bare) { + OBJ_FREEZE_RAW(str); + return str; } - if (!FL_TEST_RAW(str, FL_FREEZE | STR_NOFREE | STR_CHILLED)) - rb_str_resize(str, RSTRING_LEN(str)); - - fstr = register_fstring(str, false, false); + fstr = register_fstring(str); if (!bare) { - str_replace_shared_without_enc(str, fstr); - OBJ_FREEZE(str); - return str; + str_replace_shared_without_enc(str, fstr); + OBJ_FREEZE_RAW(str); + return str; } return fstr; } static VALUE -register_fstring(VALUE str, bool copy, bool force_precompute_hash) +register_fstring(VALUE str) { - struct fstr_update_arg args = { - .copy = copy, - .force_precompute_hash = force_precompute_hash - }; - -#if SIZEOF_VOIDP == SIZEOF_LONG - if (FL_TEST_RAW(str, STR_FAKESTR)) { - // if the string hasn't been interned, we'll need the hash twice, so we - // compute it once and store it in capa - RSTRING(str)->as.heap.aux.capa = (long)str_do_hash(str); - } -#endif - - RB_VM_LOCK_ENTER(); - { - st_table *frozen_strings = rb_vm_fstring_table(); - do { - args.fstr = str; - st_update(frozen_strings, (st_data_t)str, fstr_update_callback, (st_data_t)&args); - } while (UNDEF_P(args.fstr)); - } - RB_VM_LOCK_LEAVE(); - - RUBY_ASSERT(OBJ_FROZEN(args.fstr)); - RUBY_ASSERT(!FL_TEST_RAW(args.fstr, STR_FAKESTR)); - RUBY_ASSERT(!FL_TEST_RAW(args.fstr, FL_EXIVAR)); - RUBY_ASSERT(RBASIC_CLASS(args.fstr) == rb_cString); + VALUE ret; + st_table *frozen_strings = rb_vm_fstring_table(); - return args.fstr; + do { + ret = str; + st_update(frozen_strings, (st_data_t)str, + fstr_update_callback, (st_data_t)&ret); + } while (ret == Qundef); + + assert(OBJ_FROZEN(ret)); + assert(!FL_TEST_RAW(ret, STR_FAKESTR)); + assert(!FL_TEST_RAW(ret, FL_EXIVAR)); + assert(!FL_TEST_RAW(ret, FL_TAINT)); + assert(RBASIC_CLASS(ret) == rb_cString); + 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|STR_FAKESTR; - - if (!name) { - RUBY_ASSERT_ALWAYS(len == 0); - name = ""; - } + /* 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->len = len; + fake_str->as.heap.len = len; fake_str->as.heap.ptr = (char *)name; fake_str->as.heap.aux.capa = len; return (VALUE)fake_str; } -/* - * set up a fake string which refers a static string literal. - */ 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)); } -/* - * rb_fstring_new and rb_fstring_cstr family create or lookup a frozen - * shared string which refers a static string literal. `ptr` must - * point a constant string. - */ VALUE rb_fstring_new(const char *ptr, long len) { struct RString fake_str; - return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), false, false); + return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII)); } VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc) { struct RString fake_str; - return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), false, false); + return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc)); } VALUE @@ -621,6 +391,12 @@ rb_fstring_cstr(const char *ptr) return rb_fstring_new(ptr, strlen(ptr)); } +VALUE +rb_fstring_enc_cstr(const char *ptr, rb_encoding *enc) +{ + return rb_fstring_enc_new(ptr, strlen(ptr), enc); +} + static int fstring_set_class_i(st_data_t key, st_data_t val, st_data_t arg) { @@ -636,34 +412,26 @@ fstring_cmp(VALUE a, VALUE b) RSTRING_GETMEM(a, aptr, alen); RSTRING_GETMEM(b, bptr, blen); return (alen != blen || - ENCODING_GET(a) != ENCODING_GET(b) || - memcmp(aptr, bptr, alen) != 0); + ENCODING_GET(a) != ENCODING_GET(b) || + memcmp(aptr, bptr, alen) != 0); } -static inline bool +static inline int single_byte_optimizable(VALUE str) { - int encindex = ENCODING_GET(str); - switch (encindex) { - case ENCINDEX_ASCII_8BIT: - case ENCINDEX_US_ASCII: - return true; - case ENCINDEX_UTF_8: - // For UTF-8 it's worth scanning the string coderange when unknown. - return rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT; - } + rb_encoding *enc; + /* Conservative. It may be ENC_CODERANGE_UNKNOWN. */ - if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT) { - return true; - } + if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT) + return 1; - if (rb_enc_mbmaxlen(rb_enc_from_index(encindex)) == 1) { - return true; - } + enc = STR_ENC_GET(str); + if (rb_enc_mbmaxlen(enc) == 1) + return 1; /* Conservative. Possibly single byte. * "\xa1" in Shift_JIS for example. */ - return false; + return 0; } VALUE rb_fs; @@ -672,64 +440,44 @@ static inline const char * search_nonascii(const char *p, const char *e) { const uintptr_t *s, *t; - -#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) -# if SIZEOF_UINTPTR_T == 8 -# define NONASCII_MASK UINT64_C(0x8080808080808080) -# elif SIZEOF_UINTPTR_T == 4 -# define NONASCII_MASK UINT32_C(0x80808080) -# else -# error "don't know what to do." -# endif -#else -# if SIZEOF_UINTPTR_T == 8 -# define NONASCII_MASK ((uintptr_t)0x80808080UL << 32 | (uintptr_t)0x80808080UL) -# elif SIZEOF_UINTPTR_T == 4 -# define NONASCII_MASK 0x80808080UL /* or...? */ -# else -# error "don't know what to do." -# endif +#if SIZEOF_VOIDP == 8 +# define NONASCII_MASK 0x8080808080808080ULL +#elif SIZEOF_VOIDP == 4 +# define NONASCII_MASK 0x80808080UL #endif if (UNALIGNED_WORD_ACCESS || e - p >= SIZEOF_VOIDP) { #if !UNALIGNED_WORD_ACCESS - if ((uintptr_t)p % SIZEOF_VOIDP) { - int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP; - p += l; - switch (l) { - default: UNREACHABLE; + if ((uintptr_t)p % SIZEOF_VOIDP) { + int l = SIZEOF_VOIDP - (uintptr_t)p % SIZEOF_VOIDP; + p += l; + switch (l) { + default: UNREACHABLE; #if SIZEOF_VOIDP > 4 - case 7: if (p[-7]&0x80) return p-7; - case 6: if (p[-6]&0x80) return p-6; - case 5: if (p[-5]&0x80) return p-5; - case 4: if (p[-4]&0x80) return p-4; -#endif - case 3: if (p[-3]&0x80) return p-3; - case 2: if (p[-2]&0x80) return p-2; - case 1: if (p[-1]&0x80) return p-1; - case 0: break; - } - } + case 7: if (p[-7]&0x80) return p-7; + case 6: if (p[-6]&0x80) return p-6; + case 5: if (p[-5]&0x80) return p-5; + case 4: if (p[-4]&0x80) return p-4; #endif -#if defined(HAVE_BUILTIN___BUILTIN_ASSUME_ALIGNED) &&! UNALIGNED_WORD_ACCESS -#define aligned_ptr(value) \ - __builtin_assume_aligned((value), sizeof(uintptr_t)) -#else -#define aligned_ptr(value) (uintptr_t *)(value) + case 3: if (p[-3]&0x80) return p-3; + case 2: if (p[-2]&0x80) return p-2; + case 1: if (p[-1]&0x80) return p-1; + case 0: break; + } + } #endif - s = aligned_ptr(p); - t = (uintptr_t *)(e - (SIZEOF_VOIDP-1)); -#undef aligned_ptr - for (;s < t; s++) { - if (*s & NONASCII_MASK) { + s = (const uintptr_t *)p; + t = (const uintptr_t *)(e - (SIZEOF_VOIDP-1)); + for (;s < t; s++) { + if (*s & NONASCII_MASK) { #ifdef WORDS_BIGENDIAN - return (const char *)s + (nlz_intptr(*s&NONASCII_MASK)>>3); + return (const char *)s + (nlz_intptr(*s&NONASCII_MASK)>>3); #else - return (const char *)s + (ntz_intptr(*s&NONASCII_MASK)>>3); + return (const char *)s + (ntz_intptr(*s&NONASCII_MASK)>>3); #endif - } - } - p = (const char *)s; + } + } + p = (const char *)s; } switch (e - p) { @@ -786,42 +534,42 @@ rb_str_coderange_scan_restartable(const char *s, const char *e, rb_encoding *enc const char *p = s; if (*cr == ENC_CODERANGE_BROKEN) - return e - s; + 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); + /* 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; + 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; - } + 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); - } + 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; @@ -833,20 +581,6 @@ str_enc_copy(VALUE str1, VALUE str2) rb_enc_set_index(str1, ENCODING_GET(str2)); } -/* Like str_enc_copy, but does not check frozen status of str1. - * You should use this only if you're certain that str1 is not frozen. */ -static inline void -str_enc_copy_direct(VALUE str1, VALUE str2) -{ - int inlined_encoding = RB_ENCODING_GET_INLINED(str2); - if (inlined_encoding == ENCODING_INLINE_MAX) { - rb_enc_set_index(str1, rb_enc_get_index(str2)); - } - else { - ENCODING_SET_INLINED(str1, inlined_encoding); - } -} - static void rb_enc_cr_str_copy_for_substr(VALUE dest, VALUE src) { @@ -855,25 +589,25 @@ rb_enc_cr_str_copy_for_substr(VALUE dest, VALUE 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; + 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; + 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; + 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; + break; } } @@ -884,55 +618,44 @@ rb_enc_cr_str_exact_copy(VALUE dest, VALUE src) ENC_CODERANGE_SET(dest, ENC_CODERANGE(src)); } -static int -enc_coderange_scan(VALUE str, rb_encoding *enc) -{ - return coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), enc); -} - -int -rb_enc_str_coderange_scan(VALUE str, rb_encoding *enc) -{ - return enc_coderange_scan(str, enc); -} - int rb_enc_str_coderange(VALUE str) { int cr = ENC_CODERANGE(str); if (cr == ENC_CODERANGE_UNKNOWN) { - cr = enc_coderange_scan(str, get_encoding(str)); + int encidx = ENCODING_GET(str); + rb_encoding *enc = rb_enc_from_index(encidx); + if (rb_enc_mbminlen(enc) > 1 && rb_enc_dummy_p(enc) && + rb_enc_mbminlen(enc = get_actual_encoding(encidx, str)) == 1) { + cr = ENC_CODERANGE_BROKEN; + } + else { + cr = coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), + enc); + } ENC_CODERANGE_SET(str, cr); } return cr; } -static inline bool -rb_enc_str_asciicompat(VALUE str) -{ - int encindex = ENCODING_GET_INLINED(str); - return str_encindex_fastpath(encindex) || rb_enc_asciicompat(rb_enc_get_from_index(encindex)); -} - int rb_enc_str_asciionly_p(VALUE str) { - switch(ENC_CODERANGE(str)) { - case ENC_CODERANGE_UNKNOWN: - return rb_enc_str_asciicompat(str) && is_ascii_string(str); - case ENC_CODERANGE_7BIT: - return true; - default: - return false; - } + 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"); + rb_raise(rb_eRuntimeError, "string modified"); } } @@ -940,13 +663,13 @@ static size_t str_capacity(VALUE str, const int termlen) { if (STR_EMBED_P(str)) { - return str_embed_capa(str) - termlen; + return (RSTRING_EMBED_LEN_MAX + 1 - termlen); } - else if (FL_ANY_RAW(str, STR_SHARED|STR_NOFREE)) { - return RSTRING(str)->len; + else if (FL_TEST(str, STR_SHARED|STR_NOFREE)) { + return RSTRING(str)->as.heap.len; } else { - return RSTRING(str)->as.heap.aux.capa; + return RSTRING(str)->as.heap.aux.capa; } } @@ -960,29 +683,14 @@ static inline void must_not_null(const char *ptr) { if (!ptr) { - rb_raise(rb_eArgError, "NULL pointer given"); + rb_raise(rb_eArgError, "NULL pointer given"); } } static inline VALUE -str_alloc_embed(VALUE klass, size_t capa) +str_alloc(VALUE klass) { - size_t size = rb_str_embed_size(capa); - RUBY_ASSERT(size > 0); - RUBY_ASSERT(rb_gc_size_allocatable_p(size)); - - NEWOBJ_OF(str, struct RString, klass, - T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, 0); - - return (VALUE)str; -} - -static inline VALUE -str_alloc_heap(VALUE klass) -{ - NEWOBJ_OF(str, struct RString, klass, - T_STRING | STR_NOEMBED | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), sizeof(struct RString), 0); - + NEWOBJ_OF(str, struct RString, klass, T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0)); return (VALUE)str; } @@ -990,51 +698,32 @@ static inline VALUE empty_str_alloc(VALUE klass) { RUBY_DTRACE_CREATE_HOOK(STRING, 0); - VALUE str = str_alloc_embed(klass, 0); - memset(RSTRING(str)->as.embed.ary, 0, str_embed_capa(str)); - ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); - return str; + return str_alloc(klass); } static VALUE -str_enc_new(VALUE klass, const char *ptr, long len, rb_encoding *enc) +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 (enc == NULL) { - enc = rb_ascii8bit_encoding(); + rb_raise(rb_eArgError, "negative string size (or size too big)"); } RUBY_DTRACE_CREATE_HOOK(STRING, len); - int termlen = rb_enc_mbminlen(enc); - - if (STR_EMBEDDABLE_P(len, termlen)) { - str = str_alloc_embed(klass, len + termlen); - if (len == 0) { - ENC_CODERANGE_SET(str, rb_enc_asciicompat(enc) ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID); - } + str = str_alloc(klass); + if (!STR_EMBEDDABLE_P(len, termlen)) { + RSTRING(str)->as.heap.aux.capa = len; + RSTRING(str)->as.heap.ptr = ALLOC_N(char, (size_t)len + termlen); + STR_SET_NOEMBED(str); } - else { - str = str_alloc_heap(klass); - RSTRING(str)->as.heap.aux.capa = len; - /* :FIXME: @shyouhei guesses `len + termlen` is guaranteed to never - * integer overflow. If we can STATIC_ASSERT that, the following - * mul_add_mul can be reverted to a simple ALLOC_N. */ - RSTRING(str)->as.heap.ptr = - rb_xmalloc_mul_add_mul(sizeof(char), len, sizeof(char), termlen); + else if (len == 0) { + ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); } - - rb_enc_raw_set(str, enc); - if (ptr) { - memcpy(RSTRING_PTR(str), ptr, len); + memcpy(RSTRING_PTR(str), ptr, len); } - STR_SET_LEN(str, len); TERM_FILL(RSTRING_PTR(str) + len, termlen); return str; @@ -1043,7 +732,7 @@ str_enc_new(VALUE klass, const char *ptr, long len, rb_encoding *enc) static VALUE str_new(VALUE klass, const char *ptr, long len) { - return str_enc_new(klass, ptr, len, rb_ascii8bit_encoding()); + return str_new0(klass, ptr, len, 1); } VALUE @@ -1055,43 +744,52 @@ rb_str_new(const char *ptr, long len) VALUE rb_usascii_str_new(const char *ptr, long len) { - return str_enc_new(rb_cString, ptr, len, rb_usascii_encoding()); + 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) { - return str_enc_new(rb_cString, ptr, len, rb_utf8_encoding()); + 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) { - return str_enc_new(rb_cString, ptr, len, 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); - /* rb_str_new_cstr() can take pointer from non-malloc-generated - * memory regions, and that cannot be detected by the MSAN. Just - * trust the programmer that the argument passed here is a sane C - * string. */ - __msan_unpoison_string(ptr); return rb_str_new(ptr, strlen(ptr)); } VALUE rb_usascii_str_new_cstr(const char *ptr) { - return rb_enc_str_new_cstr(ptr, rb_usascii_encoding()); + 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) { - return rb_enc_str_new_cstr(ptr, rb_utf8_encoding()); + VALUE str = rb_str_new_cstr(ptr); + rb_enc_associate_index(str, rb_utf8_encindex()); + return str; } VALUE @@ -1099,7 +797,7 @@ 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"); + rb_raise(rb_eArgError, "wchar encoding given"); } return rb_enc_str_new(ptr, strlen(ptr), enc); } @@ -1110,21 +808,23 @@ 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)"); + rb_raise(rb_eArgError, "negative string size (or size too big)"); } if (!ptr) { - str = str_enc_new(klass, ptr, len, rb_enc_from_index(encindex)); + rb_encoding *enc = rb_enc_get_from_index(encindex); + str = str_new0(klass, ptr, len, rb_enc_mbminlen(enc)); } else { - RUBY_DTRACE_CREATE_HOOK(STRING, len); - str = str_alloc_heap(klass); - RSTRING(str)->len = len; - RSTRING(str)->as.heap.ptr = (char *)ptr; - RSTRING(str)->as.heap.aux.capa = len; - RBASIC(str)->flags |= STR_NOFREE; - rb_enc_associate_index(str, encindex); - } + RUBY_DTRACE_CREATE_HOOK(STRING, len); + 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; } @@ -1152,20 +852,38 @@ 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)); } -static VALUE str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, - rb_encoding *from, rb_encoding *to, - int ecflags, VALUE ecopts); +VALUE +rb_tainted_str_new(const char *ptr, long len) +{ + VALUE str = rb_str_new(ptr, len); -static inline bool -is_enc_ascii_string(VALUE str, rb_encoding *enc) + OBJ_TAINT(str); + return str; +} + +static VALUE +rb_tainted_str_new_with_enc(const char *ptr, long len, rb_encoding *enc) { - int encidx = rb_enc_to_index(enc); - if (rb_enc_get_index(str) == encidx) - return is_ascii_string(str); - return enc_coderange_scan(str, enc) == ENC_CODERANGE_7BIT; + VALUE str = rb_enc_str_new(ptr, len, enc); + + 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; +} + +static VALUE str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, + rb_encoding *from, rb_encoding *to, + int ecflags, VALUE ecopts); + +VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts) { long len; @@ -1175,28 +893,29 @@ rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, if (!to) return str; if (!from) from = rb_enc_get(str); if (from == to) return str; - if ((rb_enc_asciicompat(to) && is_enc_ascii_string(str, from)) || - rb_is_ascii8bit_enc(to)) { - if (STR_ENC_GET(str) != to) { - str = rb_str_dup(str); - rb_enc_associate(str, 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; } RSTRING_GETMEM(str, ptr, len); newstr = str_cat_conv_enc_opts(rb_str_buf_new(len), 0, ptr, len, - from, to, ecflags, ecopts); + from, to, ecflags, ecopts); if (NIL_P(newstr)) { - /* some error, return original */ - return str; + /* some error, return original */ + return str; } + OBJ_INFECT(newstr, str); return newstr; } VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, - rb_encoding *from, int ecflags, VALUE ecopts) + rb_encoding *from, int ecflags, VALUE ecopts) { long olen; @@ -1205,14 +924,14 @@ rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, rb_raise(rb_eIndexError, "index %ld out of string", ofs); if (ofs < 0) ofs += olen; if (!from) { - STR_SET_LEN(newstr, ofs); - return rb_str_cat(newstr, ptr, len); + STR_SET_LEN(newstr, ofs); + return rb_str_cat(newstr, ptr, len); } rb_str_modify(newstr); return str_cat_conv_enc_opts(newstr, ofs, ptr, len, from, - rb_enc_get(newstr), - ecflags, ecopts); + rb_enc_get(newstr), + ecflags, ecopts); } VALUE @@ -1226,8 +945,8 @@ rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc) static VALUE str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, - rb_encoding *from, rb_encoding *to, - int ecflags, VALUE ecopts) + rb_encoding *from, rb_encoding *to, + int ecflags, VALUE ecopts) { rb_econv_t *ec; rb_econv_result_t ret; @@ -1248,36 +967,36 @@ str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, sp = (unsigned char*)ptr; 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); + (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_GC_GUARD(econv_wrapper); 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; + len = dp - (unsigned char*)RSTRING_PTR(newstr); + rb_str_set_len(newstr, len); + rb_enc_associate(newstr, to); + return newstr; default: - return Qnil; + return Qnil; } } @@ -1295,32 +1014,32 @@ rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc) const int eidx = rb_enc_to_index(eenc); if (!ptr) { - return rb_enc_str_new(ptr, len, eenc); + return rb_tainted_str_new_with_enc(ptr, len, eenc); } /* ASCII-8BIT case, no conversion */ if ((eidx == rb_ascii8bit_encindex()) || - (eidx == rb_usascii_encindex() && search_nonascii(ptr, ptr + len))) { - return rb_str_new(ptr, len); + (eidx == rb_usascii_encindex() && search_nonascii(ptr, ptr + len))) { + return rb_tainted_str_new(ptr, len); } /* no default_internal or same encoding, no conversion */ ienc = rb_default_internal_encoding(); if (!ienc || eenc == ienc) { - return rb_enc_str_new(ptr, len, eenc); + return rb_tainted_str_new_with_enc(ptr, len, eenc); } /* ASCII compatible, and ASCII only string, no conversion in * default_internal */ if ((eidx == rb_ascii8bit_encindex()) || - (eidx == rb_usascii_encindex()) || - (rb_enc_asciicompat(eenc) && !search_nonascii(ptr, ptr + len))) { - return rb_enc_str_new(ptr, len, ienc); + (eidx == rb_usascii_encindex()) || + (rb_enc_asciicompat(eenc) && !search_nonascii(ptr, ptr + len))) { + return rb_tainted_str_new_with_enc(ptr, len, ienc); } /* convert from the given encoding to default_internal */ - str = rb_enc_str_new(NULL, 0, ienc); + str = rb_tainted_str_new_with_enc(NULL, 0, ienc); /* when the conversion failed for some reason, just ignore the * default_internal and result in the given encoding as-is. */ if (NIL_P(rb_str_cat_conv_enc_opts(str, 0, ptr, len, eenc, 0, Qnil))) { - rb_str_initialize(str, ptr, len, eenc); + rb_str_initialize(str, ptr, len, eenc); } return str; } @@ -1330,9 +1049,9 @@ rb_external_str_with_enc(VALUE str, rb_encoding *eenc) { int eidx = rb_enc_to_index(eenc); if (eidx == rb_usascii_encindex() && - !is_ascii_string(str)) { - rb_enc_associate_index(str, rb_ascii8bit_encindex()); - return str; + rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) { + rb_enc_associate_index(str, rb_ascii8bit_encindex()); + return str; } rb_enc_associate_index(str, eidx); return rb_str_conv_enc(str, eenc, rb_default_internal_encoding()); @@ -1377,13 +1096,13 @@ rb_filesystem_str_new_cstr(const char *ptr) VALUE rb_str_export(VALUE str) { - return rb_str_export_to_enc(str, rb_default_external_encoding()); + return rb_str_conv_enc(str, STR_ENC_GET(str), rb_default_external_encoding()); } VALUE rb_str_export_locale(VALUE str) { - return rb_str_export_to_enc(str, rb_locale_encoding()); + return rb_str_conv_enc(str, STR_ENC_GET(str), rb_locale_encoding()); } VALUE @@ -1400,11 +1119,12 @@ str_replace_shared_without_enc(VALUE str2, VALUE str) long len; RSTRING_GETMEM(str, ptr, len); - if (str_embed_capa(str2) >= len + termlen) { - char *ptr2 = RSTRING(str2)->as.embed.ary; - STR_SET_EMBED(str2); - memcpy(ptr2, RSTRING_PTR(str), len); - TERM_FILL(ptr2+len, termlen); + if (STR_EMBEDDABLE_P(len, termlen)) { + char *ptr2 = RSTRING(str2)->as.ary; + STR_SET_EMBED(str2); + memcpy(ptr2, RSTRING_PTR(str), len); + STR_SET_EMBED_LEN(str2, len); + TERM_FILL(ptr2+len, termlen); } else { VALUE root; @@ -1416,24 +1136,11 @@ str_replace_shared_without_enc(VALUE str2, VALUE str) root = rb_str_new_frozen(str); RSTRING_GETMEM(root, ptr, len); } - RUBY_ASSERT(OBJ_FROZEN(root)); - - if (!STR_EMBED_P(str2) && !FL_TEST_RAW(str2, STR_SHARED|STR_NOFREE)) { - if (FL_TEST_RAW(str2, STR_SHARED_ROOT)) { - rb_fatal("about to free a possible shared root"); - } - char *ptr2 = STR_HEAP_PTR(str2); - if (ptr2 != ptr) { - ruby_sized_xfree(ptr2, STR_HEAP_SIZE(str2)); - } - } - FL_SET(str2, STR_NOEMBED); - RSTRING(str2)->as.heap.ptr = ptr; - STR_SET_SHARED(str2, root); + FL_SET(str2, STR_NOEMBED); + RSTRING(str2)->as.heap.len = len; + RSTRING(str2)->as.heap.ptr = ptr; + STR_SET_SHARED(str2, root); } - - STR_SET_LEN(str2, len); - return str2; } @@ -1448,177 +1155,121 @@ str_replace_shared(VALUE str2, VALUE str) static VALUE str_new_shared(VALUE klass, VALUE str) { - return str_replace_shared(str_alloc_heap(klass), str); + return str_replace_shared(str_alloc(klass), str); } VALUE rb_str_new_shared(VALUE str) { - return str_new_shared(rb_obj_class(str), str); + VALUE str2 = str_new_shared(rb_obj_class(str), str); + + OBJ_INFECT(str2, str); + return str2; } VALUE rb_str_new_frozen(VALUE orig) { - if (RB_FL_TEST_RAW(orig, FL_FREEZE | STR_CHILLED) == FL_FREEZE) return orig; - return str_new_frozen(rb_obj_class(orig), orig); -} + VALUE str; -static VALUE -rb_str_new_frozen_String(VALUE orig) -{ - if (OBJ_FROZEN(orig) && rb_obj_class(orig) == rb_cString) return orig; - return str_new_frozen(rb_cString, orig); -} + if (OBJ_FROZEN(orig)) return orig; -VALUE -rb_str_tmp_frozen_acquire(VALUE orig) -{ - if (OBJ_FROZEN_RAW(orig)) return orig; - return str_new_frozen_buffer(0, orig, FALSE); + str = str_new_frozen(rb_obj_class(orig), orig); + OBJ_INFECT(str, orig); + return str; } VALUE -rb_str_tmp_frozen_no_embed_acquire(VALUE orig) +rb_str_tmp_frozen_acquire(VALUE orig) { - if (OBJ_FROZEN_RAW(orig) && !STR_EMBED_P(orig) && !rb_str_reembeddable_p(orig)) return orig; - if (STR_SHARED_P(orig) && !STR_EMBED_P(RSTRING(orig)->as.heap.aux.shared)) return rb_str_tmp_frozen_acquire(orig); - - VALUE str = str_alloc_heap(0); - OBJ_FREEZE(str); - /* Always set the STR_SHARED_ROOT to ensure it does not get re-embedded. */ - FL_SET(str, STR_SHARED_ROOT); - - size_t capa = str_capacity(orig, TERM_LEN(orig)); + VALUE tmp; - /* If the string is embedded then we want to create a copy that is heap - * allocated. If the string is shared then the shared root must be - * embedded, so we want to create a copy. If the string is a shared root - * then it must be embedded, so we want to create a copy. */ - if (STR_EMBED_P(orig) || FL_TEST_RAW(orig, STR_SHARED | STR_SHARED_ROOT)) { - RSTRING(str)->as.heap.ptr = rb_xmalloc_mul_add_mul(sizeof(char), capa, sizeof(char), TERM_LEN(orig)); - memcpy(RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig), capa); - } - else { - /* orig must be heap allocated and not shared, so we can safely transfer - * the pointer to str. */ - RSTRING(str)->as.heap.ptr = RSTRING(orig)->as.heap.ptr; - RBASIC(str)->flags |= RBASIC(orig)->flags & STR_NOFREE; - RBASIC(orig)->flags &= ~STR_NOFREE; - STR_SET_SHARED(orig, str); - } + if (OBJ_FROZEN_RAW(orig)) return orig; - RSTRING(str)->len = RSTRING(orig)->len; - RSTRING(str)->as.heap.aux.capa = capa; + tmp = str_new_frozen(0, orig); + OBJ_INFECT(tmp, orig); - return str; + return tmp; } void rb_str_tmp_frozen_release(VALUE orig, VALUE tmp) { if (RBASIC_CLASS(tmp) != 0) - return; + return; if (STR_EMBED_P(tmp)) { - RUBY_ASSERT(OBJ_FROZEN_RAW(tmp)); + assert(OBJ_FROZEN_RAW(tmp)); + rb_gc_force_recycle(tmp); } else if (FL_TEST_RAW(orig, STR_SHARED) && - !FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) { - VALUE shared = RSTRING(orig)->as.heap.aux.shared; - - if (shared == tmp && !FL_TEST_RAW(tmp, STR_BORROWED)) { - RUBY_ASSERT(RSTRING(orig)->as.heap.ptr == RSTRING(tmp)->as.heap.ptr); - RUBY_ASSERT(RSTRING_LEN(orig) == RSTRING_LEN(tmp)); - - /* Unshare orig since the root (tmp) only has this one child. */ - FL_UNSET_RAW(orig, STR_SHARED); - RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa; - RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE; - RUBY_ASSERT(OBJ_FROZEN_RAW(tmp)); - - /* Make tmp embedded and empty so it is safe for sweeping. */ - STR_SET_EMBED(tmp); - STR_SET_LEN(tmp, 0); - } + !FL_TEST_RAW(orig, STR_TMPLOCK|RUBY_FL_FREEZE)) { + VALUE shared = RSTRING(orig)->as.heap.aux.shared; + + if (shared == tmp && !FL_TEST_RAW(tmp, STR_IS_SHARED_M)) { + FL_UNSET_RAW(orig, STR_SHARED); + assert(RSTRING(orig)->as.heap.ptr == RSTRING(tmp)->as.heap.ptr); + assert(RSTRING(orig)->as.heap.len == RSTRING(tmp)->as.heap.len); + RSTRING(orig)->as.heap.aux.capa = RSTRING(tmp)->as.heap.aux.capa; + RBASIC(orig)->flags |= RBASIC(tmp)->flags & STR_NOFREE; + assert(OBJ_FROZEN_RAW(tmp)); + rb_gc_force_recycle(tmp); + } } } static VALUE str_new_frozen(VALUE klass, VALUE orig) { - return str_new_frozen_buffer(klass, orig, TRUE); -} - -static VALUE -heap_str_make_shared(VALUE klass, VALUE orig) -{ - RUBY_ASSERT(!STR_EMBED_P(orig)); - RUBY_ASSERT(!STR_SHARED_P(orig)); - - VALUE str = str_alloc_heap(klass); - STR_SET_LEN(str, 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); - if (klass == 0) - FL_UNSET_RAW(str, STR_BORROWED); - return str; -} - -static VALUE -str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding) -{ VALUE str; - long len = RSTRING_LEN(orig); - rb_encoding *enc = copy_encoding ? STR_ENC_GET(orig) : rb_ascii8bit_encoding(); - int termlen = copy_encoding ? TERM_LEN(orig) : 1; - - if (STR_EMBED_P(orig) || STR_EMBEDDABLE_P(len, termlen)) { - str = str_enc_new(klass, RSTRING_PTR(orig), len, enc); - RUBY_ASSERT(STR_EMBED_P(str)); + if (STR_EMBED_P(orig)) { + str = str_new(klass, RSTRING_PTR(orig), RSTRING_LEN(orig)); } else { - if (FL_TEST_RAW(orig, STR_SHARED)) { - VALUE shared = RSTRING(orig)->as.heap.aux.shared; - long ofs = RSTRING(orig)->as.heap.ptr - RSTRING_PTR(shared); - long rest = RSTRING_LEN(shared) - ofs - RSTRING_LEN(orig); - RUBY_ASSERT(ofs >= 0); - RUBY_ASSERT(rest >= 0); - RUBY_ASSERT(ofs + rest <= RSTRING_LEN(shared)); - RUBY_ASSERT(OBJ_FROZEN(shared)); - - if ((ofs > 0) || (rest > 0) || - (klass != RBASIC(shared)->klass) || - ENCODING_GET(shared) != ENCODING_GET(orig)) { - str = str_new_shared(klass, shared); - RUBY_ASSERT(!STR_EMBED_P(str)); - RSTRING(str)->as.heap.ptr += ofs; - STR_SET_LEN(str, RSTRING_LEN(str) - (ofs + rest)); - } - else { - if (RBASIC_CLASS(shared) == 0) - FL_SET_RAW(shared, STR_BORROWED); - return shared; - } - } - else if (STR_EMBEDDABLE_P(RSTRING_LEN(orig), TERM_LEN(orig))) { - str = str_alloc_embed(klass, RSTRING_LEN(orig) + TERM_LEN(orig)); - STR_SET_EMBED(str); - memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig)); - STR_SET_LEN(str, RSTRING_LEN(orig)); - ENC_CODERANGE_SET(str, ENC_CODERANGE(orig)); - TERM_FILL(RSTRING_END(str), TERM_LEN(orig)); - } - else { - str = heap_str_make_shared(klass, orig); - } - } - - if (copy_encoding) rb_enc_cr_str_exact_copy(str, orig); + if (FL_TEST_RAW(orig, STR_SHARED)) { + VALUE shared = RSTRING(orig)->as.heap.aux.shared; + long ofs = RSTRING(orig)->as.heap.ptr - RSTRING(shared)->as.heap.ptr; + long rest = RSTRING(shared)->as.heap.len - ofs - RSTRING(orig)->as.heap.len; + assert(!STR_EMBED_P(shared)); + 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 { + if (RBASIC_CLASS(shared) == 0) + FL_SET_RAW(shared, STR_IS_SHARED_M); + return shared; + } + } + else if (STR_EMBEDDABLE_P(RSTRING_LEN(orig), TERM_LEN(orig))) { + str = str_alloc(klass); + STR_SET_EMBED(str); + memcpy(RSTRING_PTR(str), RSTRING_PTR(orig), RSTRING_LEN(orig)); + STR_SET_EMBED_LEN(str, RSTRING_LEN(orig)); + TERM_FILL(RSTRING_END(str), TERM_LEN(orig)); + } + 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); + if (klass == 0) + FL_UNSET_RAW(str, STR_IS_SHARED_M); + } + } + + rb_enc_cr_str_exact_copy(str, orig); OBJ_FREEZE(str); return str; } @@ -1626,28 +1277,30 @@ str_new_frozen_buffer(VALUE klass, VALUE orig, int copy_encoding) VALUE rb_str_new_with_class(VALUE obj, const char *ptr, long len) { - return str_enc_new(rb_obj_class(obj), ptr, len, STR_ENC_GET(obj)); + return str_new0(rb_obj_class(obj), ptr, len, TERM_LEN(obj)); } static VALUE -str_new_empty_String(VALUE str) +str_new_empty(VALUE str) { - VALUE v = rb_str_new(0, 0); + 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 63 +#define STR_BUF_MIN_SIZE 127 +STATIC_ASSERT(STR_BUF_MIN_SIZE, STR_BUF_MIN_SIZE > RSTRING_EMBED_LEN_MAX); VALUE rb_str_buf_new(long capa) { - if (STR_EMBEDDABLE_P(capa, 1)) { - return str_alloc_embed(rb_cString, capa + 1); - } - - VALUE str = str_alloc_heap(rb_cString); + 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, (size_t)capa + 1); RSTRING(str)->as.heap.ptr[0] = '\0'; @@ -1676,27 +1329,33 @@ rb_str_tmp_new(long len) 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); + RB_DEBUG_COUNTER_INC(obj_str_fstr); + } + if (STR_EMBED_P(str)) { - RB_DEBUG_COUNTER_INC(obj_str_embed); + RB_DEBUG_COUNTER_INC(obj_str_embed); } else if (FL_TEST(str, STR_SHARED | STR_NOFREE)) { - (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_SHARED)); - (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_NOFREE)); + (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_SHARED)); + (void)RB_DEBUG_COUNTER_INC_IF(obj_str_shared, FL_TEST(str, STR_NOFREE)); } else { - RB_DEBUG_COUNTER_INC(obj_str_ptr); - ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); + RB_DEBUG_COUNTER_INC(obj_str_ptr); + ruby_sized_xfree(STR_HEAP_PTR(str), STR_HEAP_SIZE(str)); } } -size_t +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); + return STR_HEAP_SIZE(str); } else { - return 0; + return 0; } } @@ -1726,58 +1385,48 @@ str_shared_replace(VALUE str, VALUE str2) enc = STR_ENC_GET(str2); cr = ENC_CODERANGE(str2); str_discard(str); + OBJ_INFECT(str, str2); termlen = rb_enc_mbminlen(enc); - STR_SET_LEN(str, RSTRING_LEN(str2)); - - if (str_embed_capa(str) >= RSTRING_LEN(str2) + termlen) { - STR_SET_EMBED(str); - memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), (size_t)RSTRING_LEN(str2) + termlen); + if (STR_EMBEDDABLE_P(RSTRING_LEN(str2), termlen)) { + STR_SET_EMBED(str); + memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), (size_t)RSTRING_LEN(str2) + termlen); + STR_SET_EMBED_LEN(str, RSTRING_LEN(str2)); rb_enc_associate(str, enc); ENC_CODERANGE_SET(str, cr); } else { - if (STR_EMBED_P(str2)) { - RUBY_ASSERT(!FL_TEST(str2, STR_SHARED)); - long len = RSTRING_LEN(str2); - RUBY_ASSERT(len + termlen <= str_embed_capa(str2)); - - char *new_ptr = ALLOC_N(char, len + termlen); - memcpy(new_ptr, RSTRING(str2)->as.embed.ary, len + termlen); - RSTRING(str2)->as.heap.ptr = new_ptr; - STR_SET_LEN(str2, len); - RSTRING(str2)->as.heap.aux.capa = len; - STR_SET_NOEMBED(str2); - } + 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); - STR_SET_NOEMBED(str); - FL_UNSET(str, STR_SHARED); - RSTRING(str)->as.heap.ptr = RSTRING_PTR(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; + } - 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_LEN(str2, 0); - rb_enc_associate(str, enc); - ENC_CODERANGE_SET(str, cr); + /* 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); } } +VALUE rb_obj_as_string_result(VALUE str, VALUE obj); + VALUE rb_obj_as_string(VALUE obj) { VALUE str; if (RB_TYPE_P(obj, T_STRING)) { - return obj; + return obj; } str = rb_funcall(obj, idTo_s, 0); return rb_obj_as_string_result(str, obj); @@ -1787,7 +1436,10 @@ VALUE rb_obj_as_string_result(VALUE str, VALUE obj) { if (!RB_TYPE_P(str, T_STRING)) - return rb_any_to_s(obj); + return rb_any_to_s(obj); + if (!FL_TEST_RAW(str, RSTRING_FSTR) && FL_ABLE(obj)) + /* fstring must not be tainted, at least */ + OBJ_INFECT_RAW(str, obj); return str; } @@ -1798,138 +1450,63 @@ str_replace(VALUE str, VALUE str2) len = RSTRING_LEN(str2); if (STR_SHARED_P(str2)) { - VALUE shared = RSTRING(str2)->as.heap.aux.shared; - RUBY_ASSERT(OBJ_FROZEN(shared)); - STR_SET_NOEMBED(str); - STR_SET_LEN(str, len); - RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); - STR_SET_SHARED(str, shared); - rb_enc_cr_str_exact_copy(str, 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); + rb_enc_cr_str_exact_copy(str, str2); } else { - str_replace_shared(str, str2); + str_replace_shared(str, str2); } + OBJ_INFECT(str, str2); return str; } static inline VALUE -ec_str_alloc_embed(struct rb_execution_context_struct *ec, VALUE klass, size_t capa) -{ - size_t size = rb_str_embed_size(capa); - RUBY_ASSERT(size > 0); - RUBY_ASSERT(rb_gc_size_allocatable_p(size)); - - NEWOBJ_OF(str, struct RString, klass, - T_STRING | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), size, ec); - - return (VALUE)str; -} - -static inline VALUE -ec_str_alloc_heap(struct rb_execution_context_struct *ec, VALUE klass) -{ - NEWOBJ_OF(str, struct RString, klass, - T_STRING | STR_NOEMBED | (RGENGC_WB_PROTECTED_STRING ? FL_WB_PROTECTED : 0), sizeof(struct RString), ec); - - return (VALUE)str; -} - -static inline VALUE -str_duplicate_setup_encoding(VALUE str, VALUE dup, VALUE flags) +str_duplicate(VALUE klass, VALUE str) { - int encidx = 0; - if ((flags & ENCODING_MASK) == (ENCODING_INLINE_MAX<<ENCODING_SHIFT)) { - encidx = rb_enc_get_index(str); - flags &= ~ENCODING_MASK; + enum {embed_size = RSTRING_EMBED_LEN_MAX + 1}; + const VALUE flag_mask = + RSTRING_NOEMBED | RSTRING_EMBED_LEN_MASK | + ENC_CODERANGE_MASK | ENCODING_MASK | + FL_TAINT | FL_FREEZE + ; + VALUE flags = FL_TEST_RAW(str, flag_mask); + VALUE dup = str_alloc(klass); + MEMCPY(RSTRING(dup)->as.ary, RSTRING(str)->as.ary, + char, embed_size); + if (flags & STR_NOEMBED) { + if (FL_TEST_RAW(str, STR_SHARED)) { + str = RSTRING(str)->as.heap.aux.shared; + } + else if (UNLIKELY(!(flags & FL_FREEZE))) { + str = str_new_frozen(klass, str); + FL_SET_RAW(str, flags & FL_TAINT); + flags = FL_TEST_RAW(str, flag_mask); + } + if (flags & STR_NOEMBED) { + RB_OBJ_WRITE(dup, &RSTRING(dup)->as.heap.aux.shared, str); + flags |= STR_SHARED; + } + else { + MEMCPY(RSTRING(dup)->as.ary, RSTRING(str)->as.ary, + char, embed_size); + } } FL_SET_RAW(dup, flags & ~FL_FREEZE); - if (encidx) rb_enc_associate_index(dup, encidx); return dup; } -static const VALUE flag_mask = ENC_CODERANGE_MASK | ENCODING_MASK | FL_FREEZE; - -static inline VALUE -str_duplicate_setup_embed(VALUE klass, VALUE str, VALUE dup) -{ - VALUE flags = FL_TEST_RAW(str, flag_mask); - long len = RSTRING_LEN(str); - - RUBY_ASSERT(STR_EMBED_P(dup)); - RUBY_ASSERT(str_embed_capa(dup) >= len + 1); - MEMCPY(RSTRING(dup)->as.embed.ary, RSTRING(str)->as.embed.ary, char, len + 1); - STR_SET_LEN(dup, RSTRING_LEN(str)); - return str_duplicate_setup_encoding(str, dup, flags); -} - -static inline VALUE -str_duplicate_setup_heap(VALUE klass, VALUE str, VALUE dup) -{ - VALUE flags = FL_TEST_RAW(str, flag_mask); - VALUE root = str; - if (FL_TEST_RAW(str, STR_SHARED)) { - root = RSTRING(str)->as.heap.aux.shared; - } - else if (UNLIKELY(!(flags & FL_FREEZE))) { - root = str = str_new_frozen(klass, str); - flags = FL_TEST_RAW(str, flag_mask); - } - RUBY_ASSERT(!STR_SHARED_P(root)); - RUBY_ASSERT(RB_OBJ_FROZEN_RAW(root)); - - RSTRING(dup)->as.heap.ptr = RSTRING_PTR(str); - FL_SET(root, STR_SHARED_ROOT); - RB_OBJ_WRITE(dup, &RSTRING(dup)->as.heap.aux.shared, root); - flags |= RSTRING_NOEMBED | STR_SHARED; - - STR_SET_LEN(dup, RSTRING_LEN(str)); - return str_duplicate_setup_encoding(str, dup, flags); -} - -static inline VALUE -str_duplicate_setup(VALUE klass, VALUE str, VALUE dup) -{ - if (STR_EMBED_P(str)) { - return str_duplicate_setup_embed(klass, str, dup); - } - else { - return str_duplicate_setup_heap(klass, str, dup); - } -} - -static inline VALUE -str_duplicate(VALUE klass, VALUE str) -{ - VALUE dup; - if (STR_EMBED_P(str)) { - dup = str_alloc_embed(klass, RSTRING_LEN(str) + TERM_LEN(str)); - } - else { - dup = str_alloc_heap(klass); - } - - return str_duplicate_setup(klass, str, dup); -} - VALUE rb_str_dup(VALUE str) { return str_duplicate(rb_obj_class(str), str); } -/* :nodoc: */ -VALUE -rb_str_dup_m(VALUE str) -{ - if (LIKELY(BARE_STRING_P(str))) { - return str_duplicate(rb_obj_class(str), str); - } - else { - return rb_obj_dup(str); - } -} - VALUE rb_str_resurrect(VALUE str) { @@ -1937,43 +1514,23 @@ rb_str_resurrect(VALUE str) return str_duplicate(rb_cString, str); } -VALUE -rb_ec_str_resurrect(struct rb_execution_context_struct *ec, VALUE str, bool chilled) -{ - RUBY_DTRACE_CREATE_HOOK(STRING, RSTRING_LEN(str)); - VALUE new_str, klass = rb_cString; - - if (!(chilled && RTEST(rb_ivar_defined(str, id_debug_created_info))) && STR_EMBED_P(str)) { - new_str = ec_str_alloc_embed(ec, klass, RSTRING_LEN(str) + TERM_LEN(str)); - str_duplicate_setup_embed(klass, str, new_str); - } - else { - new_str = ec_str_alloc_heap(ec, klass); - str_duplicate_setup_heap(klass, str, new_str); - } - if (chilled) { - FL_SET_RAW(new_str, STR_CHILLED_LITERAL); - } - return new_str; -} - -VALUE -rb_str_with_debug_created_info(VALUE str, VALUE path, int line) -{ - VALUE debug_info = rb_ary_new_from_args(2, path, INT2FIX(line)); - if (OBJ_FROZEN_RAW(str)) str = rb_str_dup(str); - rb_ivar_set(str, id_debug_created_info, rb_ary_freeze(debug_info)); - FL_SET_RAW(str, STR_CHILLED_LITERAL); - return rb_str_freeze(str); -} - /* - * * call-seq: - * String.new(string = '', **opts) -> new_string + * String.new(str="") -> new_str + * String.new(str="", encoding: enc) -> new_str + * String.new(str="", capacity: size) -> new_str * - * :include: doc/string/new.rdoc + * Returns a new string object containing a copy of <i>str</i>. * + * The optional <i>encoding</i> keyword argument specifies the encoding + * of the new string. + * If not specified, the encoding of <i>str</i> is used + * (or ASCII-8BIT, if <i>str</i> is not specified). + * + * The optional <i>capacity</i> keyword argument specifies the size + * of the internal buffer. + * This may improve performance, when the string will be concatenated many + * times (causing many realloc calls). */ static VALUE @@ -1986,159 +1543,81 @@ rb_str_init(int argc, VALUE *argv, VALUE str) int n; if (!keyword_ids[0]) { - keyword_ids[0] = rb_id_encoding(); - CONST_ID(keyword_ids[1], "capacity"); + keyword_ids[0] = rb_id_encoding(); + CONST_ID(keyword_ids[1], "capacity"); } n = rb_scan_args(argc, argv, "01:", &orig, &opt); if (!NIL_P(opt)) { - rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs); - venc = kwargs[0]; - vcapa = kwargs[1]; - if (!UNDEF_P(venc) && !NIL_P(venc)) { - enc = rb_to_encoding(venc); - } - if (!UNDEF_P(vcapa) && !NIL_P(vcapa)) { - long capa = NUM2LONG(vcapa); - long len = 0; - int termlen = enc ? rb_enc_mbminlen(enc) : 1; - - if (capa < STR_BUF_MIN_SIZE) { - capa = STR_BUF_MIN_SIZE; - } - if (n == 1) { - StringValue(orig); - len = RSTRING_LEN(orig); - if (capa < len) { - capa = len; - } - if (orig == str) n = 0; + rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs); + venc = kwargs[0]; + vcapa = kwargs[1]; + if (venc != Qundef && !NIL_P(venc)) { + enc = rb_to_encoding(venc); + } + if (vcapa != Qundef && !NIL_P(vcapa)) { + long capa = NUM2LONG(vcapa); + long len = 0; + int termlen = enc ? rb_enc_mbminlen(enc) : 1; + + if (capa < STR_BUF_MIN_SIZE) { + capa = STR_BUF_MIN_SIZE; + } + if (n == 1) { + StringValue(orig); + len = RSTRING_LEN(orig); + if (capa < len) { + capa = len; + } + if (orig == str) n = 0; + } + str_modifiable(str); + if (STR_EMBED_P(str)) { /* make noembed always */ + char *new_ptr = ALLOC_N(char, (size_t)capa + termlen); + memcpy(new_ptr, RSTRING(str)->as.ary, RSTRING_EMBED_LEN_MAX + 1); + RSTRING(str)->as.heap.ptr = new_ptr; } - str_modifiable(str); - if (STR_EMBED_P(str) || FL_TEST(str, STR_SHARED|STR_NOFREE)) { - /* make noembed always */ + else if (FL_TEST(str, STR_SHARED|STR_NOFREE)) { const size_t size = (size_t)capa + termlen; const char *const old_ptr = RSTRING_PTR(str); - const size_t osize = RSTRING_LEN(str) + TERM_LEN(str); - char *new_ptr = ALLOC_N(char, size); - if (STR_EMBED_P(str)) RUBY_ASSERT((long)osize <= str_embed_capa(str)); + const size_t osize = RSTRING(str)->as.heap.len + TERM_LEN(str); + char *new_ptr = ALLOC_N(char, (size_t)capa + termlen); memcpy(new_ptr, old_ptr, osize < size ? osize : size); - FL_UNSET_RAW(str, STR_SHARED|STR_NOFREE); + FL_UNSET_RAW(str, STR_SHARED); RSTRING(str)->as.heap.ptr = new_ptr; - } - else if (STR_HEAP_SIZE(str) != (size_t)capa + termlen) { - SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, - (size_t)capa + termlen, STR_HEAP_SIZE(str)); - } - STR_SET_LEN(str, len); - TERM_FILL(&RSTRING(str)->as.heap.ptr[len], termlen); - if (n == 1) { - memcpy(RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig), len); - rb_enc_cr_str_exact_copy(str, orig); - } - FL_SET(str, STR_NOEMBED); - RSTRING(str)->as.heap.aux.capa = capa; - } - else if (n == 1) { - rb_str_replace(str, orig); - } - if (enc) { - rb_enc_associate(str, enc); - ENC_CODERANGE_CLEAR(str); - } + } + else if (STR_HEAP_SIZE(str) != (size_t)capa + termlen) { + REALLOC_N(RSTRING(str)->as.heap.ptr, char, (size_t)capa + termlen); + } + RSTRING(str)->as.heap.len = len; + TERM_FILL(&RSTRING(str)->as.heap.ptr[len], termlen); + if (n == 1) { + memcpy(RSTRING(str)->as.heap.ptr, RSTRING_PTR(orig), len); + rb_enc_cr_str_exact_copy(str, orig); + } + FL_SET(str, STR_NOEMBED); + RSTRING(str)->as.heap.aux.capa = capa; + } + else if (n == 1) { + rb_str_replace(str, orig); + } + if (enc) { + rb_enc_associate(str, enc); + ENC_CODERANGE_CLEAR(str); + } } else if (n == 1) { - rb_str_replace(str, orig); + rb_str_replace(str, orig); } return str; } -/* :nodoc: */ -static VALUE -rb_str_s_new(int argc, VALUE *argv, VALUE klass) -{ - if (klass != rb_cString) { - return rb_class_new_instance_pass_kw(argc, argv, klass); - } - - static ID keyword_ids[2]; - VALUE orig, opt, encoding = Qnil, capacity = Qnil; - VALUE kwargs[2]; - rb_encoding *enc = NULL; - - int n = rb_scan_args(argc, argv, "01:", &orig, &opt); - if (NIL_P(opt)) { - return rb_class_new_instance_pass_kw(argc, argv, klass); - } - - keyword_ids[0] = rb_id_encoding(); - CONST_ID(keyword_ids[1], "capacity"); - rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs); - encoding = kwargs[0]; - capacity = kwargs[1]; - - if (n == 1) { - orig = StringValue(orig); - } - else { - orig = Qnil; - } - - if (UNDEF_P(encoding)) { - if (!NIL_P(orig)) { - encoding = rb_obj_encoding(orig); - } - } - - if (!UNDEF_P(encoding)) { - enc = rb_to_encoding(encoding); - } - - // If capacity is nil, we're basically just duping `orig`. - if (UNDEF_P(capacity)) { - if (NIL_P(orig)) { - VALUE empty_str = str_new(klass, "", 0); - if (enc) { - rb_enc_associate(empty_str, enc); - } - return empty_str; - } - VALUE copy = str_duplicate(klass, orig); - rb_enc_associate(copy, enc); - ENC_CODERANGE_CLEAR(copy); - return copy; - } - - long capa = 0; - capa = NUM2LONG(capacity); - if (capa < 0) { - capa = 0; - } - - if (!NIL_P(orig)) { - long orig_capa = rb_str_capacity(orig); - if (orig_capa > capa) { - capa = orig_capa; - } - } - - VALUE str = str_enc_new(klass, NULL, capa, enc); - STR_SET_LEN(str, 0); - TERM_FILL(RSTRING_PTR(str), enc ? rb_enc_mbmaxlen(enc) : 1); - - if (!NIL_P(orig)) { - rb_str_buf_append(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 https://en.wikipedia.org/wiki/UTF-8) + * bit representation. (see http://en.wikipedia.org/wiki/UTF-8) * Therefore, the following pseudocode can detect UTF-8 leading bytes. * * if (!(byte & 0x80)) @@ -2180,62 +1659,62 @@ enc_strlen(const char *p, const char *e, rb_encoding *enc, int cr) const char *q; if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { - long diff = (long)(e - p); - return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc)); + long diff = (long)(e - p); + return diff / rb_enc_mbminlen(enc) + !!(diff % 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; + 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 (ENC_CODERANGE_CLEAN_P(cr)) { - 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++; - } - } + if (ENC_CODERANGE_CLEAN_P(cr)) { + 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; } @@ -2263,49 +1742,49 @@ rb_enc_strlen_cr(const char *p, const char *e, rb_encoding *enc, int *cr) *cr = 0; if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { - long diff = (long)(e - p); - return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc)); + long diff = (long)(e - p); + return diff / rb_enc_mbminlen(enc) + !!(diff % rb_enc_mbminlen(enc)); } else if (rb_enc_asciicompat(enc)) { - c = 0; - while (p < e) { - if (ISASCII(*p)) { - q = search_nonascii(p, e); - if (!q) { - if (!*cr) *cr = ENC_CODERANGE_7BIT; - return c + (e - p); - } - c += q - p; - p = q; - } - ret = rb_enc_precise_mbclen(p, e, enc); - if (MBCLEN_CHARFOUND_P(ret)) { - *cr |= ENC_CODERANGE_VALID; - p += MBCLEN_CHARFOUND_LEN(ret); - } - else { - *cr = ENC_CODERANGE_BROKEN; - p++; - } - c++; - } - if (!*cr) *cr = ENC_CODERANGE_7BIT; - return c; + c = 0; + while (p < e) { + if (ISASCII(*p)) { + q = search_nonascii(p, e); + if (!q) { + if (!*cr) *cr = ENC_CODERANGE_7BIT; + return c + (e - p); + } + c += q - p; + p = q; + } + ret = rb_enc_precise_mbclen(p, e, enc); + if (MBCLEN_CHARFOUND_P(ret)) { + *cr |= ENC_CODERANGE_VALID; + p += MBCLEN_CHARFOUND_LEN(ret); + } + else { + *cr = ENC_CODERANGE_BROKEN; + p++; + } + c++; + } + if (!*cr) *cr = ENC_CODERANGE_7BIT; + return c; } for (c=0; p<e; c++) { - ret = rb_enc_precise_mbclen(p, e, enc); - if (MBCLEN_CHARFOUND_P(ret)) { - *cr |= ENC_CODERANGE_VALID; - p += MBCLEN_CHARFOUND_LEN(ret); - } - else { - *cr = ENC_CODERANGE_BROKEN; + ret = rb_enc_precise_mbclen(p, e, enc); + if (MBCLEN_CHARFOUND_P(ret)) { + *cr |= ENC_CODERANGE_VALID; + p += MBCLEN_CHARFOUND_LEN(ret); + } + else { + *cr = ENC_CODERANGE_BROKEN; if (p + rb_enc_mbminlen(enc) <= e) p += rb_enc_mbminlen(enc); else p = e; - } + } } if (!*cr) *cr = ENC_CODERANGE_7BIT; return c; @@ -2325,12 +1804,12 @@ str_strlen(VALUE str, rb_encoding *enc) cr = ENC_CODERANGE(str); if (cr == ENC_CODERANGE_UNKNOWN) { - long n = rb_enc_strlen_cr(p, e, enc, &cr); - if (cr) ENC_CODERANGE_SET(str, cr); - return n; + long n = rb_enc_strlen_cr(p, e, enc, &cr); + if (cr) ENC_CODERANGE_SET(str, cr); + return n; } else { - return enc_strlen(p, e, enc, cr); + return enc_strlen(p, e, enc, cr); } } @@ -2342,10 +1821,10 @@ rb_str_strlen(VALUE str) /* * call-seq: - * length -> integer - * - * :include: doc/string/length.rdoc + * str.length -> integer + * str.size -> integer * + * Returns the character length of <i>str</i>. */ VALUE @@ -2356,13 +1835,15 @@ rb_str_length(VALUE str) /* * call-seq: - * bytesize -> integer + * str.bytesize -> integer * - * :include: doc/string/bytesize.rdoc + * Returns the length of +str+ in bytes. * + * "\x80\u3042".bytesize #=> 4 + * "hello".bytesize #=> 5 */ -VALUE +static VALUE rb_str_bytesize(VALUE str) { return LONG2NUM(RSTRING_LEN(str)); @@ -2370,30 +1851,31 @@ rb_str_bytesize(VALUE str) /* * call-seq: - * empty? -> true or false + * str.empty? -> true or false * - * Returns +true+ if the length of +self+ is zero, +false+ otherwise: - * - * "hello".empty? # => false - * " ".empty? # => false - * "".empty? # => true + * Returns <code>true</code> if <i>str</i> has a length of zero. * + * "hello".empty? #=> false + * " ".empty? #=> false + * "".empty? #=> true */ static VALUE rb_str_empty(VALUE str) { - return RBOOL(RSTRING_LEN(str) == 0); + if (RSTRING_LEN(str) == 0) + return Qtrue; + return Qfalse; } /* * call-seq: - * string + other_string -> new_string + * str + other_str -> new_str * - * Returns a new +String+ containing +other_string+ concatenated to +self+: - * - * "Hello from " + self.to_s # => "Hello from main" + * Concatenation---Returns a new <code>String</code> containing + * <i>other_str</i> concatenated to <i>str</i>. * + * "Hello from " + self.to_s #=> "Hello from main" */ VALUE @@ -2411,61 +1893,31 @@ rb_str_plus(VALUE str1, VALUE str2) RSTRING_GETMEM(str2, ptr2, len2); termlen = rb_enc_mbminlen(enc); if (len1 > LONG_MAX - len2) { - rb_raise(rb_eArgError, "string size too big"); + rb_raise(rb_eArgError, "string size too big"); } - str3 = str_enc_new(rb_cString, 0, len1+len2, enc); + str3 = str_new0(rb_cString, 0, len1+len2, termlen); ptr3 = RSTRING_PTR(str3); memcpy(ptr3, ptr1, len1); memcpy(ptr3+len1, ptr2, len2); TERM_FILL(&ptr3[len1+len2], termlen); + FL_SET_RAW(str3, OBJ_TAINTED_RAW(str1) | OBJ_TAINTED_RAW(str2)); ENCODING_CODERANGE_SET(str3, rb_enc_to_index(enc), - ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2))); + ENC_CODERANGE_AND(ENC_CODERANGE(str1), ENC_CODERANGE(str2))); RB_GC_GUARD(str1); RB_GC_GUARD(str2); return str3; } -/* A variant of rb_str_plus that does not raise but return Qundef instead. */ -VALUE -rb_str_opt_plus(VALUE str1, VALUE str2) -{ - RUBY_ASSERT(RBASIC_CLASS(str1) == rb_cString); - RUBY_ASSERT(RBASIC_CLASS(str2) == rb_cString); - long len1, len2; - MAYBE_UNUSED(char) *ptr1, *ptr2; - RSTRING_GETMEM(str1, ptr1, len1); - RSTRING_GETMEM(str2, ptr2, len2); - int enc1 = rb_enc_get_index(str1); - int enc2 = rb_enc_get_index(str2); - - if (enc1 < 0) { - return Qundef; - } - else if (enc2 < 0) { - return Qundef; - } - else if (enc1 != enc2) { - return Qundef; - } - else if (len1 > LONG_MAX - len2) { - return Qundef; - } - else { - return rb_str_plus(str1, str2); - } - -} - /* * call-seq: - * string * integer -> new_string - * - * Returns a new +String+ containing +integer+ copies of +self+: + * str * integer -> new_str * - * "Ho! " * 3 # => "Ho! Ho! Ho! " - * "Ho! " * 0 # => "" + * 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 @@ -2477,38 +1929,37 @@ rb_str_times(VALUE str, VALUE times) int termlen; if (times == INT2FIX(1)) { - return str_duplicate(rb_cString, str); + return rb_str_dup(str); } if (times == INT2FIX(0)) { - str2 = str_alloc_embed(rb_cString, 0); - rb_enc_copy(str2, str); - return str2; + str2 = str_alloc(rb_obj_class(str)); + rb_enc_copy(str2, str); + OBJ_INFECT(str2, str); + return str2; } len = NUM2LONG(times); if (len < 0) { - rb_raise(rb_eArgError, "negative argument"); + rb_raise(rb_eArgError, "negative argument"); } if (RSTRING_LEN(str) == 1 && RSTRING_PTR(str)[0] == 0) { - if (STR_EMBEDDABLE_P(len, 1)) { - str2 = str_alloc_embed(rb_cString, len + 1); - memset(RSTRING_PTR(str2), 0, len + 1); - } - else { - str2 = str_alloc_heap(rb_cString); - RSTRING(str2)->as.heap.aux.capa = len; - RSTRING(str2)->as.heap.ptr = ZALLOC_N(char, (size_t)len + 1); - } - STR_SET_LEN(str2, len); - rb_enc_copy(str2, str); - return str2; + str2 = str_alloc(rb_obj_class(str)); + if (!STR_EMBEDDABLE_P(len, 1)) { + RSTRING(str2)->as.heap.aux.capa = len; + RSTRING(str2)->as.heap.ptr = ZALLOC_N(char, (size_t)len + 1); + STR_SET_NOEMBED(str2); + } + STR_SET_LEN(str2, len); + rb_enc_copy(str2, str); + OBJ_INFECT(str2, str); + return str2; } if (len && LONG_MAX/len < RSTRING_LEN(str)) { - rb_raise(rb_eArgError, "argument too big"); + rb_raise(rb_eArgError, "argument too big"); } len *= RSTRING_LEN(str); termlen = TERM_LEN(str); - str2 = str_enc_new(rb_cString, 0, len, STR_ENC_GET(str)); + str2 = str_new0(rb_obj_class(str), 0, len, termlen); ptr2 = RSTRING_PTR(str2); if (len) { n = RSTRING_LEN(str); @@ -2521,6 +1972,7 @@ rb_str_times(VALUE str, VALUE times) } 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; @@ -2528,20 +1980,17 @@ rb_str_times(VALUE str, VALUE times) /* * call-seq: - * string % object -> new_string - * - * Returns the result of formatting +object+ into the format specification +self+ - * (see Kernel#sprintf for formatting details): - * - * "%05d" % 123 # => "00123" + * str % arg -> new_str * - * If +self+ contains multiple substitutions, +object+ must be - * an Array or Hash containing the values to be substituted: - * - * "%-5s: %016x" % [ "ID", self.object_id ] # => "ID : 00002b054ec93168" - * "foo = %{foo}" % {foo: 'bar'} # => "foo = bar" - * "foo = %{foo}, baz = %{baz}" % {foo: 'bar', baz: 'bat'} # => "foo = bar, baz = bat" + * Format---Uses <i>str</i> as a format specification, and returns the result + * of applying it to <i>arg</i>. If the format specification contains more than + * one substitution, then <i>arg</i> must be an <code>Array</code> or <code>Hash</code> + * containing the values to be substituted. See <code>Kernel::sprintf</code> 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 @@ -2550,7 +1999,9 @@ rb_str_format_m(VALUE str, VALUE arg) VALUE tmp = rb_check_array_type(arg); if (!NIL_P(tmp)) { - return rb_str_format(RARRAY_LENINT(tmp), RARRAY_CONST_PTR(tmp), str); + 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); } @@ -2559,47 +2010,33 @@ static inline void rb_check_lockedtmp(VALUE str) { if (FL_TEST(str, STR_TMPLOCK)) { - rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked"); + rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked"); } } -// If none of these flags are set, we know we have an modifiable string. -// If any is set, we need to do more detailed checks. -#define STR_UNMODIFIABLE_MASK (FL_FREEZE | STR_TMPLOCK | STR_CHILLED) static inline void str_modifiable(VALUE str) { - if (RB_UNLIKELY(FL_ANY_RAW(str, STR_UNMODIFIABLE_MASK))) { - if (CHILLED_STRING_P(str)) { - CHILLED_STRING_MUTATED(str); - } - rb_check_lockedtmp(str); - rb_check_frozen(str); - } + rb_check_lockedtmp(str); + rb_check_frozen(str); } static inline int str_dependent_p(VALUE str) { if (STR_EMBED_P(str) || !FL_TEST(str, STR_SHARED|STR_NOFREE)) { - return FALSE; + return 0; } else { - return TRUE; + return 1; } } -// If none of these flags are set, we know we have an independent string. -// If any is set, we need to do more detailed checks. -#define STR_DEPENDANT_MASK (STR_UNMODIFIABLE_MASK | STR_SHARED | STR_NOFREE) static inline int str_independent(VALUE str) { - if (RB_UNLIKELY(FL_ANY_RAW(str, STR_DEPENDANT_MASK))) { - str_modifiable(str); - return !str_dependent_p(str); - } - return TRUE; + str_modifiable(str); + return !str_dependent_p(str); } static void @@ -2611,19 +2048,19 @@ str_make_independent_expand(VALUE str, long len, long expand, const int termlen) if (len > capa) len = capa; - if (!STR_EMBED_P(str) && str_embed_capa(str) >= capa + termlen) { - ptr = RSTRING(str)->as.heap.ptr; - STR_SET_EMBED(str); - memcpy(RSTRING(str)->as.embed.ary, ptr, len); - TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen); - STR_SET_LEN(str, len); - return; + if (!STR_EMBED_P(str) && STR_EMBEDDABLE_P(capa, termlen)) { + 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, (size_t)capa + termlen); oldptr = RSTRING_PTR(str); if (oldptr) { - memcpy(ptr, oldptr, len); + memcpy(ptr, oldptr, len); } if (FL_TEST_RAW(str, STR_NOEMBED|STR_NOFREE|STR_SHARED) == STR_NOEMBED) { xfree(oldptr); @@ -2632,7 +2069,7 @@ str_make_independent_expand(VALUE str, long len, long expand, const int termlen) FL_UNSET(str, STR_SHARED|STR_NOFREE); TERM_FILL(ptr + len, termlen); RSTRING(str)->as.heap.ptr = ptr; - STR_SET_LEN(str, len); + RSTRING(str)->as.heap.len = len; RSTRING(str)->as.heap.aux.capa = capa; } @@ -2640,7 +2077,7 @@ void rb_str_modify(VALUE str) { if (!str_independent(str)) - str_make_independent(str); + str_make_independent(str); ENC_CODERANGE_CLEAR(str); } @@ -2651,17 +2088,17 @@ rb_str_modify_expand(VALUE str, long expand) long len = RSTRING_LEN(str); if (expand < 0) { - rb_raise(rb_eArgError, "negative expanding string size"); + rb_raise(rb_eArgError, "negative expanding string size"); } - if (expand >= LONG_MAX - len) { - rb_raise(rb_eArgError, "string size too big"); + if (expand > LONG_MAX - len) { + rb_raise(rb_eArgError, "string size too big"); } if (!str_independent(str)) { - str_make_independent_expand(str, len, expand, termlen); + str_make_independent_expand(str, len, expand, termlen); } else if (expand > 0) { - RESIZE_CAPA_TERM(str, len + expand, termlen); + RESIZE_CAPA_TERM(str, len + expand, termlen); } ENC_CODERANGE_CLEAR(str); } @@ -2671,10 +2108,10 @@ static void str_modify_keep_cr(VALUE str) { if (!str_independent(str)) - str_make_independent(str); + str_make_independent(str); if (ENC_CODERANGE(str) == ENC_CODERANGE_BROKEN) - /* Force re-scan later */ - ENC_CODERANGE_CLEAR(str); + /* Force re-scan later */ + ENC_CODERANGE_CLEAR(str); } static inline void @@ -2682,28 +2119,18 @@ 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; - STR_SET_LEN(str, 0); + 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) { - int encindex = rb_enc_get_index(str); - - if (RB_UNLIKELY(encindex == -1)) { - rb_raise(rb_eTypeError, "not encoding capable object"); - } - - if (RB_LIKELY(str_encindex_fastpath(encindex))) { - return; - } - - rb_encoding *enc = rb_enc_from_index(encindex); + rb_encoding *enc = rb_enc_get(str); if (!rb_enc_asciicompat(enc)) { - rb_raise(rb_eEncCompatError, "ASCII incompatible encoding: %s", rb_enc_name(enc)); + rb_raise(rb_eEncCompatError, "ASCII incompatible encoding: %s", rb_enc_name(enc)); } } @@ -2712,8 +2139,8 @@ rb_string_value(volatile VALUE *ptr) { VALUE s = *ptr; if (!RB_TYPE_P(s, T_STRING)) { - s = rb_str_to_str(s); - *ptr = s; + s = rb_str_to_str(s); + *ptr = s; } return s; } @@ -2729,7 +2156,7 @@ static int zero_filled(const char *s, int n) { for (; n > 0; --n) { - if (*s++) return 0; + if (*s++) return 0; } return 1; } @@ -2740,7 +2167,7 @@ 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; + if (zero_filled(s, minlen)) return s; } return 0; } @@ -2752,12 +2179,12 @@ str_fill_term(VALUE str, char *s, long len, int termlen) * is allocated, like many other functions in this file. */ if (str_dependent_p(str)) { - if (!zero_filled(s + len, termlen)) - str_make_independent_expand(str, len, 0L, termlen); + if (!zero_filled(s + len, termlen)) + str_make_independent_expand(str, len, 0L, termlen); } else { - TERM_FILL(s + len, termlen); - return s; + TERM_FILL(s + len, termlen); + return s; } return RSTRING_PTR(str); } @@ -2768,24 +2195,24 @@ rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int terml long capa = str_capacity(str, oldtermlen) + oldtermlen; long len = RSTRING_LEN(str); - RUBY_ASSERT(capa >= len); + assert(capa >= len); if (capa - len < termlen) { - rb_check_lockedtmp(str); - str_make_independent_expand(str, len, 0L, termlen); + rb_check_lockedtmp(str); + str_make_independent_expand(str, len, 0L, termlen); } else if (str_dependent_p(str)) { - if (termlen > oldtermlen) - str_make_independent_expand(str, len, 0L, termlen); + if (termlen > oldtermlen) + str_make_independent_expand(str, len, 0L, termlen); } else { - if (!STR_EMBED_P(str)) { - /* modify capa instead of realloc */ - RUBY_ASSERT(!FL_TEST((str), STR_SHARED)); - RSTRING(str)->as.heap.aux.capa = capa - termlen; - } - if (termlen > oldtermlen) { - TERM_FILL(RSTRING_PTR(str) + len, termlen); - } + if (!STR_EMBED_P(str)) { + /* modify capa instead of realloc */ + assert(!FL_TEST((str), STR_SHARED)); + RSTRING(str)->as.heap.aux.capa = capa - termlen; + } + if (termlen > oldtermlen) { + TERM_FILL(RSTRING_PTR(str) + len, termlen); + } } return; @@ -2800,18 +2227,18 @@ str_null_check(VALUE str, int *w) const int minlen = rb_enc_mbminlen(enc); if (minlen > 1) { - *w = 1; - if (str_null_char(s, len, minlen, enc)) { - return NULL; - } - return str_fill_term(str, s, len, minlen); + *w = 1; + if (str_null_char(s, len, minlen, enc)) { + return NULL; + } + return str_fill_term(str, s, len, minlen); } *w = 0; if (!s || memchr(s, 0, len)) { - return NULL; + return NULL; } if (s[len]) { - s = str_fill_term(str, s, len, minlen); + s = str_fill_term(str, s, len, minlen); } return s; } @@ -2830,10 +2257,10 @@ rb_string_value_cstr(volatile VALUE *ptr) int w; char *s = str_null_check(str, &w); if (!s) { - if (w) { - rb_raise(rb_eArgError, "string contains null char"); - } - rb_raise(rb_eArgError, "string contains null byte"); + if (w) { + rb_raise(rb_eArgError, "string contains null char"); + } + rb_raise(rb_eArgError, "string contains null byte"); } return s; } @@ -2855,16 +2282,14 @@ rb_check_string_type(VALUE str) /* * call-seq: - * String.try_convert(object) -> object, new_string, or nil - * - * If +object+ is a +String+ object, returns +object+. + * String.try_convert(obj) -> string or nil * - * Otherwise if +object+ responds to <tt>:to_str</tt>, - * calls <tt>object.to_str</tt> and returns the result. + * Try to convert <i>obj</i> into a String, using to_str method. + * Returns converted string or nil if <i>obj</i> cannot be converted + * for any reason. * - * Returns +nil+ if +object+ does not respond to <tt>:to_str</tt>. - * - * Raises an exception unless <tt>object.to_str</tt> returns a +String+ object. + * String.try_convert("str") #=> "str" + * String.try_convert(/re/) #=> nil */ static VALUE rb_str_s_try_convert(VALUE dummy, VALUE str) @@ -2895,8 +2320,8 @@ str_nth_len(const char *p, const char *e, long *nthp, rb_encoding *enc) if (ISASCII(*p)) { p2 = search_nonascii(p, e2); if (!p2) { - nth -= e2 - p; - *nthp = nth; + nth -= e2 - p; + *nthp = nth; return (char *)e2; } nth -= p2 - p; @@ -2932,9 +2357,9 @@ static char* str_nth(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte) { if (singlebyte) - p += nth; + p += nth; else { - p = str_nth_len(p, e, &nth, enc); + p = str_nth_len(p, e, &nth, enc); } if (!p) return 0; if (p > e) p = e; @@ -2954,7 +2379,7 @@ 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)); + STR_ENC_GET(str), single_byte_optimizable(str)); } #ifdef NONASCII_MASK @@ -2963,26 +2388,26 @@ 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; + 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++; + if (is_utf8_lead_byte(*p)) { + if (nth == 0) break; + nth--; + } + p++; } *nthp = nth; return (char *)p; @@ -3003,55 +2428,32 @@ rb_str_sublen(VALUE str, long pos) if (single_byte_optimizable(str) || pos < 0) return pos; else { - char *p = RSTRING_PTR(str); + char *p = RSTRING_PTR(str); return enc_strlen(p, p + pos, STR_ENC_GET(str), ENC_CODERANGE(str)); } } -static VALUE -str_subseq(VALUE str, long beg, long len) +VALUE +rb_str_subseq(VALUE str, long beg, long len) { VALUE str2; - RUBY_ASSERT(beg >= 0); - RUBY_ASSERT(len >= 0); - RUBY_ASSERT(beg+len <= RSTRING_LEN(str)); - - const int termlen = TERM_LEN(str); - if (!SHARABLE_SUBSTRING_P(beg, len, RSTRING_LEN(str))) { - str2 = rb_str_new(RSTRING_PTR(str) + beg, len); - RB_GC_GUARD(str); - return str2; - } - - str2 = str_alloc_heap(rb_cString); - if (str_embed_capa(str2) >= len + termlen) { - char *ptr2 = RSTRING(str2)->as.embed.ary; - STR_SET_EMBED(str2); - memcpy(ptr2, RSTRING_PTR(str) + beg, len); - TERM_FILL(ptr2+len, termlen); - - STR_SET_LEN(str2, len); - RB_GC_GUARD(str); + if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) && + 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 { - str_replace_shared(str2, str); - RUBY_ASSERT(!STR_EMBED_P(str2)); - ENC_CODERANGE_CLEAR(str2); - RSTRING(str2)->as.heap.ptr += beg; - if (RSTRING_LEN(str2) > len) { - STR_SET_LEN(str2, len); - } + str2 = rb_str_new_with_class(str, RSTRING_PTR(str)+beg, len); + RB_GC_GUARD(str); } - return str2; -} - -VALUE -rb_str_subseq(VALUE str, long beg, long len) -{ - VALUE str2 = str_subseq(str, beg, len); rb_enc_cr_str_copy_for_substr(str2, str); + OBJ_INFECT(str2, str); + return str2; } @@ -3060,54 +2462,52 @@ rb_str_subpos(VALUE str, long beg, long *lenp) { long len = *lenp; long slen = -1L; - const long blen = RSTRING_LEN(str); + 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 (beg < 0 && -beg < 0) return 0; if (!blen) { - len = 0; + len = 0; } if (single_byte_optimizable(str)) { - if (beg > blen) return 0; - if (beg < 0) { - beg += blen; - if (beg < 0) return 0; - } - if (len > blen - beg) - len = blen - beg; - if (len < 0) return 0; - p = s + beg; - goto end; + if (beg > blen) return 0; + if (beg < 0) { + beg += blen; + if (beg < 0) return 0; + } + if (len > blen - beg) + len = blen - beg; + if (len < 0) return 0; + p = s + beg; + goto end; } if (beg < 0) { - if (len > -beg) len = -beg; - if ((ENC_CODERANGE(str) == ENC_CODERANGE_VALID) && - (-beg * rb_enc_mbmaxlen(enc) < blen / 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 > blen) { - return 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; + 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 && @@ -3118,23 +2518,23 @@ rb_str_subpos(VALUE str, long beg, long *lenp) } #endif else if (rb_enc_mbmaxlen(enc) == rb_enc_mbminlen(enc)) { - int char_sz = rb_enc_mbmaxlen(enc); + int char_sz = rb_enc_mbmaxlen(enc); - p = s + beg * char_sz; - if (p > e) { - return 0; - } + p = s + beg * char_sz; + if (p > e) { + return 0; + } else if (len * char_sz > e - p) len = e - p; else - len *= char_sz; + len *= char_sz; } else if ((p = str_nth_len(s, e, &beg, enc)) == e) { - if (beg > 0) return 0; - len = 0; + if (beg > 0) return 0; + len = 0; } else { - len = str_offset(p, e, len, enc, 0); + len = str_offset(p, e, len, enc, 0); } end: *lenp = len; @@ -3150,88 +2550,79 @@ rb_str_substr(VALUE str, long beg, long len) return str_substr(str, beg, len, TRUE); } -VALUE -rb_str_substr_two_fixnums(VALUE str, VALUE beg, VALUE len, int empty) -{ - return str_substr(str, NUM2LONG(beg), NUM2LONG(len), empty); -} - static VALUE str_substr(VALUE str, long beg, long len, int empty) { + VALUE str2; char *p = rb_str_subpos(str, beg, &len); if (!p) return Qnil; - if (!len && !empty) return Qnil; - - beg = p - RSTRING_PTR(str); - - VALUE str2 = str_subseq(str, beg, len); + if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) && + 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; + ENC_CODERANGE_CLEAR(str2); + } + else { + if (!len && !empty) return Qnil; + 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; } -/* :nodoc: */ VALUE rb_str_freeze(VALUE str) { - if (CHILLED_STRING_P(str)) { - FL_UNSET_RAW(str, STR_CHILLED); - } - if (OBJ_FROZEN(str)) return str; rb_str_resize(str, RSTRING_LEN(str)); return rb_obj_freeze(str); } + /* * call-seq: - * +string -> new_string or self + * +str -> str (mutable) * - * Returns +self+ if +self+ is not frozen and can be mutated - * without warning issuance. + * If the string is frozen, then return duplicated mutable string. * - * Otherwise returns <tt>self.dup</tt>, which is not frozen. + * If the string is not frozen, then return the string itself. */ static VALUE str_uplus(VALUE str) { - if (OBJ_FROZEN(str) || CHILLED_STRING_P(str)) { - return rb_str_dup(str); + if (OBJ_FROZEN(str)) { + return rb_str_dup(str); } else { - return str; + return str; } } /* * call-seq: - * -string -> frozen_string - * dedup -> frozen_string - * - * Returns a frozen, possibly pre-existing copy of the string. - * - * The returned +String+ will be deduplicated as long as it does not have - * any instance variables set on it and is not a String subclass. - * - * Note that <tt>-string</tt> variant is more convenient for defining - * constants: - * - * FILENAME = -'config/database.yml' + * -str -> str (frozen) * - * while +dedup+ is better suitable for using the method in chains - * of calculations: - * - * @url_list.concat(urls.map(&:dedup)) + * If the string is frozen, then return the string itself. * + * If the string is not frozen, return a frozen, possibly pre-existing + * copy of it. */ static VALUE str_uminus(VALUE str) { - if (!BARE_STRING_P(str) && !rb_obj_frozen_p(str)) { - str = rb_str_dup(str); + if (OBJ_FROZEN(str)) { + return str; + } + else { + return rb_fstring(str); } - return rb_fstring(str); } RUBY_ALIAS_FUNCTION(rb_str_dup_frozen(VALUE str), rb_str_new_frozen, (str)) @@ -3241,7 +2632,7 @@ VALUE rb_str_locktmp(VALUE str) { if (FL_TEST(str, STR_TMPLOCK)) { - rb_raise(rb_eRuntimeError, "temporal locking already locked string"); + rb_raise(rb_eRuntimeError, "temporal locking already locked string"); } FL_SET(str, STR_TMPLOCK); return str; @@ -3251,13 +2642,13 @@ VALUE rb_str_unlocktmp(VALUE str) { if (!FL_TEST(str, STR_TMPLOCK)) { - rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string"); + rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string"); } FL_UNSET(str, STR_TMPLOCK); return str; } -VALUE +RUBY_FUNC_EXPORTED VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg) { rb_str_locktmp(str); @@ -3272,42 +2663,11 @@ rb_str_set_len(VALUE str, long len) str_modifiable(str); if (STR_SHARED_P(str)) { - rb_raise(rb_eRuntimeError, "can't set length of shared string"); + rb_raise(rb_eRuntimeError, "can't set length of shared string"); } if (len > (capa = (long)str_capacity(str, termlen)) || len < 0) { - rb_bug("probable buffer overflow: %ld for %ld", len, capa); + rb_bug("probable buffer overflow: %ld for %ld", len, capa); } - - int cr = ENC_CODERANGE(str); - if (len == 0) { - /* Empty string does not contain non-ASCII */ - ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); - } - else if (cr == ENC_CODERANGE_UNKNOWN) { - /* Leave unknown. */ - } - else if (len > RSTRING_LEN(str)) { - if (ENC_CODERANGE_CLEAN_P(cr)) { - /* Update the coderange regarding the extended part. */ - const char *const prev_end = RSTRING_END(str); - const char *const new_end = RSTRING_PTR(str) + len; - rb_encoding *enc = rb_enc_get(str); - rb_str_coderange_scan_restartable(prev_end, new_end, enc, &cr); - ENC_CODERANGE_SET(str, cr); - } - else if (cr == ENC_CODERANGE_BROKEN) { - /* May be valid now, by appended part. */ - ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN); - } - } - else if (len < RSTRING_LEN(str)) { - if (cr != ENC_CODERANGE_7BIT) { - /* ASCII-only string is keeping after truncated. Valid - * and broken may be invalid or valid, leave unknown. */ - ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN); - } - } - STR_SET_LEN(str, len); TERM_FILL(&RSTRING_PTR(str)[len], termlen); } @@ -3315,117 +2675,92 @@ rb_str_set_len(VALUE str, long len) 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)"); + rb_raise(rb_eArgError, "negative string size (or size too big)"); } - int independent = str_independent(str); - long slen = RSTRING_LEN(str); - const int termlen = TERM_LEN(str); - - if (slen > len || (termlen != 1 && slen < len)) { - ENC_CODERANGE_CLEAR(str); - } + independent = str_independent(str); + ENC_CODERANGE_CLEAR(str); + slen = RSTRING_LEN(str); { - long capa; - if (STR_EMBED_P(str)) { - if (len == slen) return str; - if (str_embed_capa(str) >= len + termlen) { - STR_SET_LEN(str, len); - TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen); - return str; - } - str_make_independent_expand(str, slen, len - slen, termlen); - } - else if (str_embed_capa(str) >= len + termlen) { - char *ptr = STR_HEAP_PTR(str); - STR_SET_EMBED(str); - if (slen > len) slen = len; - if (slen > 0) MEMCPY(RSTRING(str)->as.embed.ary, ptr, char, slen); - TERM_FILL(RSTRING(str)->as.embed.ary + len, termlen); - STR_SET_LEN(str, len); - if (independent) ruby_xfree(ptr); - return str; - } - else if (!independent) { - if (len == slen) return str; - str_make_independent_expand(str, slen, len - slen, termlen); - } - else if ((capa = RSTRING(str)->as.heap.aux.capa) < len || - (capa - len) > (len < 1024 ? len : 1024)) { - SIZED_REALLOC_N(RSTRING(str)->as.heap.ptr, char, - (size_t)len + termlen, STR_HEAP_SIZE(str)); - RSTRING(str)->as.heap.aux.capa = len; - } - else if (len == slen) return str; - STR_SET_LEN(str, len); - TERM_FILL(RSTRING(str)->as.heap.ptr + len, termlen); /* sentinel */ + long capa; + const int termlen = TERM_LEN(str); + if (STR_EMBED_P(str)) { + if (len == slen) return str; + if (STR_EMBEDDABLE_P(len, termlen)) { + STR_SET_EMBED_LEN(str, len); + TERM_FILL(RSTRING(str)->as.ary + len, termlen); + return str; + } + str_make_independent_expand(str, slen, len - slen, termlen); + } + else if (STR_EMBEDDABLE_P(len, termlen)) { + 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, slen, len - slen, termlen); + } + else if ((capa = RSTRING(str)->as.heap.aux.capa) < len || + (capa - len) > (len < 1024 ? len : 1024)) { + REALLOC_N(RSTRING(str)->as.heap.ptr, char, (size_t)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 void -str_ensure_available_capa(VALUE str, long len) -{ - str_modify_keep_cr(str); - - const int termlen = TERM_LEN(str); - long olen = RSTRING_LEN(str); - - if (RB_UNLIKELY(olen > LONG_MAX - len)) { - rb_raise(rb_eArgError, "string sizes too big"); - } - - long total = olen + len; - long capa = str_capacity(str, termlen); - - if (capa < total) { - if (total >= LONG_MAX / 2) { - capa = total; - } - while (total > capa) { - capa = 2 * capa + termlen; /* == 2*(capa+termlen)-termlen */ - } - RESIZE_CAPA_TERM(str, capa, termlen); - } -} - static VALUE -str_buf_cat4(VALUE str, const char *ptr, long len, bool keep_cr) +str_buf_cat(VALUE str, const char *ptr, long len) { - if (keep_cr) { - str_modify_keep_cr(str); - } - else { - rb_str_modify(str); - } - if (len == 0) return 0; - - long total, olen, off = -1; + long capa, total, olen, off = -1; char *sptr; const int termlen = TERM_LEN(str); + assert(termlen < RSTRING_EMBED_LEN_MAX + 1); /* < (LONG_MAX/2) */ RSTRING_GETMEM(str, sptr, olen); if (ptr >= sptr && ptr <= sptr + olen) { off = ptr - sptr; } - - long capa = str_capacity(str, termlen); - + rb_str_modify(str); + if (len == 0) return 0; + if (STR_EMBED_P(str)) { + capa = RSTRING_EMBED_LEN_MAX + 1 - termlen; + 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"); + rb_raise(rb_eArgError, "string sizes too big"); } total = olen + len; if (capa < total) { - if (total >= LONG_MAX / 2) { - capa = total; - } - while (total > capa) { - capa = 2 * capa + termlen; /* == 2*(capa+termlen)-termlen */ - } - RESIZE_CAPA_TERM(str, capa, termlen); - sptr = RSTRING_PTR(str); + if (total >= LONG_MAX / 2) { + capa = total; + } + while (total > capa) { + capa = 2 * capa + termlen; /* == 2*(capa+termlen)-termlen */ + } + RESIZE_CAPA_TERM(str, capa, termlen); + sptr = RSTRING_PTR(str); } if (off != -1) { ptr = sptr + off; @@ -3437,15 +2772,14 @@ str_buf_cat4(VALUE str, const char *ptr, long len, bool keep_cr) return str; } -#define str_buf_cat(str, ptr, len) str_buf_cat4((str), (ptr), len, false) -#define str_buf_cat2(str, ptr) str_buf_cat4((str), (ptr), rb_strlen_lit(ptr), false) +#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)"); + rb_raise(rb_eArgError, "negative string size (or size too big)"); } return str_buf_cat(str, ptr, len); } @@ -3457,62 +2791,6 @@ rb_str_cat_cstr(VALUE str, const char *ptr) return rb_str_buf_cat(str, ptr, strlen(ptr)); } -static void -rb_str_buf_cat_byte(VALUE str, unsigned char byte) -{ - RUBY_ASSERT(RB_ENCODING_GET_INLINED(str) == ENCINDEX_ASCII_8BIT || RB_ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII); - - // We can't write directly to shared strings without impacting others, so we must make the string independent. - if (UNLIKELY(!str_independent(str))) { - str_make_independent(str); - } - - long string_length = -1; - const int null_terminator_length = 1; - char *sptr; - RSTRING_GETMEM(str, sptr, string_length); - - // Ensure the resulting string wouldn't be too long. - if (UNLIKELY(string_length > LONG_MAX - 1)) { - rb_raise(rb_eArgError, "string sizes too big"); - } - - long string_capacity = str_capacity(str, null_terminator_length); - - // Get the code range before any modifications since those might clear the code range. - int cr = ENC_CODERANGE(str); - - // Check if the string has spare string_capacity to write the new byte. - if (LIKELY(string_capacity >= string_length + 1)) { - // In fast path we can write the new byte and note the string's new length. - sptr[string_length] = byte; - STR_SET_LEN(str, string_length + 1); - TERM_FILL(sptr + string_length + 1, null_terminator_length); - } - else { - // If there's not enough string_capacity, make a call into the general string concatenation function. - str_buf_cat(str, (char *)&byte, 1); - } - - // If the code range is already known, we can derive the resulting code range cheaply by looking at the byte we - // just appended. If the code range is unknown, but the string was empty, then we can also derive the code range - // by looking at the byte we just appended. Otherwise, we'd have to scan the bytes to determine the code range so - // we leave it as unknown. It cannot be broken for binary strings so we don't need to handle that option. - if (cr == ENC_CODERANGE_7BIT || string_length == 0) { - if (ISASCII(byte)) { - ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); - } - else { - ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); - - // Promote a US-ASCII string to ASCII-8BIT when a non-ASCII byte is appended. - if (UNLIKELY(RB_ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII)) { - rb_enc_associate_index(str, ENCINDEX_ASCII_8BIT); - } - } - } -} - 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)) @@ -3529,27 +2807,26 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, 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) { + 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); + 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); - rb_str_change_terminator_length(str, rb_enc_mbminlen(str_enc), rb_enc_mbminlen(ptr_enc)); return str; } goto incompatible; } - if (ptr_cr == ENC_CODERANGE_UNKNOWN) { - ptr_cr = coderange_scan(ptr, len, ptr_enc); - } + 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); @@ -3562,9 +2839,11 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, 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); - goto incompatible; + 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) { @@ -3583,10 +2862,10 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, } else if (str_cr == ENC_CODERANGE_VALID) { res_encindex = str_encindex; - if (ENC_CODERANGE_CLEAN_P(ptr_cr)) - res_cr = str_cr; - else - res_cr = ptr_cr; + if (ENC_CODERANGE_CLEAN_P(ptr_cr)) + res_cr = str_cr; + else + res_cr = ptr_cr; } else { /* str_cr == ENC_CODERANGE_BROKEN */ res_encindex = str_encindex; @@ -3595,16 +2874,11 @@ rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, } if (len < 0) { - rb_raise(rb_eArgError, "negative string size (or size too big)"); + 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; - - incompatible: - rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", - rb_enc_inspect_name(str_enc), rb_enc_inspect_name(ptr_enc)); - UNREACHABLE_RETURN(Qundef); } VALUE @@ -3641,32 +2915,14 @@ rb_str_buf_cat_ascii(VALUE str, const char *ptr) VALUE rb_str_buf_append(VALUE str, VALUE str2) { - int str2_cr = rb_enc_str_coderange(str2); - - if (str_enc_fastpath(str)) { - switch (str2_cr) { - case ENC_CODERANGE_7BIT: - // If RHS is 7bit we can do simple concatenation - str_buf_cat4(str, RSTRING_PTR(str2), RSTRING_LEN(str2), true); - RB_GC_GUARD(str2); - return str; - case ENC_CODERANGE_VALID: - // If RHS is valid, we can do simple concatenation if encodings are the same - if (ENCODING_GET_INLINED(str) == ENCODING_GET_INLINED(str2)) { - str_buf_cat4(str, RSTRING_PTR(str2), RSTRING_LEN(str2), true); - int str_cr = ENC_CODERANGE(str); - if (UNLIKELY(str_cr != ENC_CODERANGE_VALID)) { - ENC_CODERANGE_SET(str, RB_ENC_CODERANGE_AND(str_cr, str2_cr)); - } - RB_GC_GUARD(str2); - return str; - } - } - } + 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; @@ -3679,50 +2935,63 @@ rb_str_append(VALUE str, VALUE str2) return rb_str_buf_append(str, str2); } +#define MIN_PRE_ALLOC_SIZE 48 + VALUE rb_str_concat_literals(size_t num, const VALUE *strary) { VALUE str; - size_t i, s = 0; - unsigned long len = 1; + size_t i, s; + long len = 1; if (UNLIKELY(!num)) return rb_str_new(0, 0); if (UNLIKELY(num == 1)) return rb_str_resurrect(strary[0]); for (i = 0; i < num; ++i) { len += RSTRING_LEN(strary[i]); } - str = rb_str_buf_new(len); - str_enc_copy_direct(str, strary[0]); + if (LIKELY(len < MIN_PRE_ALLOC_SIZE)) { + str = rb_str_resurrect(strary[0]); + s = 1; + } + else { + str = rb_str_buf_new(len); + rb_enc_copy(str, strary[0]); + s = 0; + } for (i = s; i < num; ++i) { - const VALUE v = strary[i]; - int encidx = ENCODING_GET(v); + const VALUE v = strary[i]; + int encidx = ENCODING_GET(v); - rb_str_buf_append(str, v); - if (encidx != ENCINDEX_US_ASCII) { - if (ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII) - rb_enc_set_index(str, encidx); - } + rb_enc_cr_str_buf_cat(str, RSTRING_PTR(v), RSTRING_LEN(v), + encidx, ENC_CODERANGE(v), NULL); + OBJ_INFECT_RAW(str, v); + if (encidx != ENCINDEX_US_ASCII) { + if (ENCODING_GET_INLINED(str) == ENCINDEX_US_ASCII) + rb_enc_set_index(str, encidx); + } } return str; } /* * call-seq: - * concat(*objects) -> string + * str.concat(obj1, obj2,...) -> str * - * Concatenates each object in +objects+ to +self+ and returns +self+: + * Concatenates the given object(s) to <i>str</i>. If an object is an + * <code>Integer</code>, it is considered a codepoint and converted + * to a character before concatenation. * - * s = 'foo' - * s.concat('bar', 'baz') # => "foobarbaz" - * s # => "foobarbaz" + * +concat+ can take multiple arguments, and all the arguments are + * concatenated in order. * - * For each given object +object+ that is an Integer, - * the value is considered a codepoint and converted to a character before concatenation: + * a = "hello " + * a.concat("world", 33) #=> "hello world!" + * a #=> "hello world!" * - * s = 'foo' - * s.concat(32, 'bar', 32, 'baz') # => "foo bar baz" + * b = "sn" + * b.concat("_", b, "_", b) #=> "sn_sn_sn" * - * Related: String#<<, which takes a single argument. + * See also String#<<, which takes a single argument. */ static VALUE rb_str_concat_multi(int argc, VALUE *argv, VALUE str) @@ -3730,189 +2999,35 @@ rb_str_concat_multi(int argc, VALUE *argv, VALUE str) str_modifiable(str); if (argc == 1) { - return rb_str_concat(str, argv[0]); + return rb_str_concat(str, argv[0]); } else if (argc > 1) { - int i; - VALUE arg_str = rb_str_tmp_new(0); - rb_enc_copy(arg_str, str); - for (i = 0; i < argc; i++) { - rb_str_concat(arg_str, argv[i]); - } - rb_str_buf_append(str, arg_str); - } - - return str; -} - -/* - * call-seq: - * append_as_bytes(*objects) -> string - * - * Concatenates each object in +objects+ into +self+ without any encoding - * validation or conversion and returns +self+: - * - * s = 'foo' - * s.append_as_bytes(" \xE2\x82") # => "foo \xE2\x82" - * s.valid_encoding? # => false - * s.append_as_bytes("\xAC 12") - * s.valid_encoding? # => true - * - * For each given object +object+ that is an Integer, - * the value is considered a Byte. If the Integer is bigger - * than one byte, only the lower byte is considered, similar to String#setbyte: - * - * s = "" - * s.append_as_bytes(0, 257) # => "\u0000\u0001" - * - * Related: String#<<, String#concat, which do an encoding aware concatenation. - */ - -VALUE -rb_str_append_as_bytes(int argc, VALUE *argv, VALUE str) -{ - long needed_capacity = 0; - volatile VALUE t0; - enum ruby_value_type *types = ALLOCV_N(enum ruby_value_type, t0, argc); - - for (int index = 0; index < argc; index++) { - VALUE obj = argv[index]; - enum ruby_value_type type = types[index] = rb_type(obj); - switch (type) { - case T_FIXNUM: - case T_BIGNUM: - needed_capacity++; - break; - case T_STRING: - needed_capacity += RSTRING_LEN(obj); - break; - default: - rb_raise( - rb_eTypeError, - "wrong argument type %"PRIsVALUE" (expected String or Integer)", - rb_obj_class(obj) - ); - break; - } - } - - str_ensure_available_capa(str, needed_capacity); - char *sptr = RSTRING_END(str); - - for (int index = 0; index < argc; index++) { - VALUE obj = argv[index]; - enum ruby_value_type type = types[index]; - switch (type) { - case T_FIXNUM: - case T_BIGNUM: { - argv[index] = obj = rb_int_and(obj, INT2FIX(0xff)); - char byte = (char)(NUM2INT(obj) & 0xFF); - *sptr = byte; - sptr++; - break; - } - case T_STRING: { - const char *ptr; - long len; - RSTRING_GETMEM(obj, ptr, len); - memcpy(sptr, ptr, len); - sptr += len; - break; - } - default: - rb_bug("append_as_bytes arguments should have been validated"); - } - } - - STR_SET_LEN(str, RSTRING_LEN(str) + needed_capacity); - TERM_FILL(sptr, TERM_LEN(str)); /* sentinel */ - - int cr = ENC_CODERANGE(str); - switch (cr) { - case ENC_CODERANGE_7BIT: { - for (int index = 0; index < argc; index++) { - VALUE obj = argv[index]; - enum ruby_value_type type = types[index]; - switch (type) { - case T_FIXNUM: - case T_BIGNUM: { - if (!ISASCII(NUM2INT(obj))) { - goto clear_cr; - } - break; - } - case T_STRING: { - if (ENC_CODERANGE(obj) != ENC_CODERANGE_7BIT) { - goto clear_cr; - } - break; - } - default: - rb_bug("append_as_bytes arguments should have been validated"); - } - } - break; - } - case ENC_CODERANGE_VALID: - if (ENCODING_GET_INLINED(str) == ENCINDEX_ASCII_8BIT) { - goto keep_cr; - } - else { - goto clear_cr; - } - break; - default: - goto clear_cr; - break; + int i; + VALUE arg_str = rb_str_tmp_new(0); + rb_enc_copy(arg_str, str); + for (i = 0; i < argc; i++) { + rb_str_concat(arg_str, argv[i]); + } + rb_str_buf_append(str, arg_str); } - RB_GC_GUARD(t0); - - clear_cr: - // If no fast path was hit, we clear the coderange. - // append_as_bytes is predominently meant to be used in - // buffering situation, hence it's likely the coderange - // will never be scanned, so it's not worth spending time - // precomputing the coderange except for simple and common - // situations. - ENC_CODERANGE_CLEAR(str); - keep_cr: return str; } /* * call-seq: - * string << object -> string - * - * Concatenates +object+ to +self+ and returns +self+: - * - * s = 'foo' - * s << 'bar' # => "foobar" - * s # => "foobar" + * str << obj -> str + * str << integer -> str * - * If +object+ is an Integer, - * the value is considered a codepoint and converted to a character before concatenation: + * Appends the given object to <i>str</i>. If the object is an + * <code>Integer</code>, it is considered a codepoint and converted + * to a character before being appended. * - * s = 'foo' - * s << 33 # => "foo!" + * a = "hello " + * a << "world" #=> "hello world" + * a << 33 #=> "hello world!" * - * If that codepoint is not representable in the encoding of - * _string_, RangeError is raised. - * - * s = 'foo' - * s.encoding # => <Encoding:UTF-8> - * s << 0x00110000 # 1114112 out of char range (RangeError) - * s = 'foo'.encode('EUC-JP') - * s << 0x00800080 # invalid codepoint 0x800080 in EUC-JP (RangeError) - * - * If the encoding is US-ASCII and the codepoint is 0..0xff, _string_ - * is automatically promoted to ASCII-8BIT. - * - * s = 'foo'.encode('US-ASCII') - * s << 0xff - * s.encoding # => #<Encoding:BINARY (ASCII-8BIT)> - * - * Related: String#concat, which takes multiple arguments. + * See also String#concat, which takes multiple arguments. */ VALUE rb_str_concat(VALUE str1, VALUE str2) @@ -3922,88 +3037,73 @@ rb_str_concat(VALUE str1, VALUE str2) int encidx; if (RB_INTEGER_TYPE_P(str2)) { - 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"); - } + 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); + return rb_str_append(str1, str2); } - encidx = rb_ascii8bit_appendable_encoding_index(enc, code); - - if (encidx >= 0) { - rb_str_buf_cat_byte(str1, (unsigned char)code); + encidx = rb_enc_to_index(enc); + if (encidx == ENCINDEX_ASCII || encidx == ENCINDEX_US_ASCII) { + /* 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 (encidx == ENCINDEX_US_ASCII && code > 127) { + rb_enc_associate_index(str1, ENCINDEX_ASCII); + 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; - } - else if (cr == ENC_CODERANGE_BROKEN) { - cr = ENC_CODERANGE_UNKNOWN; - } - ENC_CODERANGE_SET(str1, cr); + 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; } -int -rb_ascii8bit_appendable_encoding_index(rb_encoding *enc, unsigned int code) -{ - int encidx = rb_enc_to_index(enc); - - if (encidx == ENCINDEX_ASCII_8BIT || encidx == ENCINDEX_US_ASCII) { - /* US-ASCII automatically extended to ASCII-8BIT */ - if (code > 0xFF) { - rb_raise(rb_eRangeError, "%u out of char range", code); - } - if (encidx == ENCINDEX_US_ASCII && code > 127) { - return ENCINDEX_ASCII_8BIT; - } - return encidx; - } - else { - return -1; - } -} - /* * call-seq: - * prepend(*other_strings) -> string + * str.prepend(other_str1, other_str2,...) -> str * - * Prepends each string in +other_strings+ to +self+ and returns +self+: + * Prepend---Prepend the given strings to <i>str</i>. * - * s = 'foo' - * s.prepend('bar', 'baz') # => "barbazfoo" - * s # => "barbazfoo" + * a = "!" + * a.prepend("hello ", "world") #=> "hello world!" + * a #=> "hello world!" * - * Related: String#concat. + * See also String#concat. */ static VALUE @@ -4012,16 +3112,16 @@ rb_str_prepend_multi(int argc, VALUE *argv, VALUE str) str_modifiable(str); if (argc == 1) { - rb_str_update(str, 0L, 0L, argv[0]); + rb_str_update(str, 0L, 0L, argv[0]); } else if (argc > 1) { - int i; - VALUE arg_str = rb_str_tmp_new(0); - rb_enc_copy(arg_str, str); - for (i = 0; i < argc; i++) { - rb_str_append(arg_str, argv[i]); - } - rb_str_update(str, 0L, 0L, arg_str); + int i; + VALUE arg_str = rb_str_tmp_new(0); + rb_enc_copy(arg_str, str); + for (i = 0; i < argc; i++) { + rb_str_append(arg_str, argv[i]); + } + rb_str_update(str, 0L, 0L, arg_str); } return str; @@ -4030,15 +3130,11 @@ rb_str_prepend_multi(int argc, VALUE *argv, VALUE str) st_index_t rb_str_hash(VALUE str) { - if (FL_TEST_RAW(str, STR_PRECOMPUTED_HASH)) { - st_index_t precomputed_hash; - memcpy(&precomputed_hash, RSTRING_END(str) + TERM_LEN(str), sizeof(precomputed_hash)); - - RUBY_ASSERT(precomputed_hash == str_do_hash(str)); - return precomputed_hash; + int e = ENCODING_GET(str); + if (e && rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) { + e = 0; } - - return str_do_hash(str); + return rb_memhash((const void *)RSTRING_PTR(str), RSTRING_LEN(str)) ^ e; } int @@ -4049,18 +3145,17 @@ rb_str_hash_cmp(VALUE str1, VALUE str2) RSTRING_GETMEM(str1, ptr1, len1); RSTRING_GETMEM(str2, ptr2, len2); return (len1 != len2 || - !rb_str_comparable(str1, str2) || - memcmp(ptr1, ptr2, len1) != 0); + !rb_str_comparable(str1, str2) || + memcmp(ptr1, ptr2, len1) != 0); } /* * call-seq: - * hash -> integer + * str.hash -> integer * - * Returns the integer hash value for +self+. - * The value is based on the length, content and encoding of +self+. + * Return a hash based on the string's length, content and encoding. * - * Related: Object#hash. + * See also Object#hash. */ static VALUE @@ -4086,13 +3181,13 @@ rb_str_comparable(VALUE str1, VALUE str2) 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) 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; + if (rb_enc_asciicompat(rb_enc_from_index(idx1))) + return TRUE; } return FALSE; } @@ -4108,39 +3203,48 @@ rb_str_cmp(VALUE str1, VALUE str2) 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 (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: - * string == object -> true or false - * string === object -> true or false - * - * Returns +true+ if +object+ has the same length and content; - * as +self+; +false+ otherwise: + * str == obj -> true or false + * str === obj -> true or false * - * s = 'foo' - * s == 'foo' # => true - * s == 'food' # => false - * s == 'FOO' # => false + * Equality---Returns whether +str+ == +obj+, similar to Object#==. * - * Returns +false+ if the two strings' encodings are not compatible: - * "\u{e4 f6 fc}".encode("ISO-8859-1") == ("\u{c4 d6 dc}") # => false + * If +obj+ is not an instance of String but responds to +to_str+, then the + * two strings are compared using <code>obj.==</code>. * - * If +object+ is not an instance of +String+ but responds to +to_str+, then the - * two strings are compared using <code>object.==</code>. + * Otherwise, returns similarly to String#eql?, comparing length and content. */ VALUE @@ -4148,30 +3252,19 @@ rb_str_equal(VALUE str1, VALUE str2) { if (str1 == str2) return Qtrue; if (!RB_TYPE_P(str2, T_STRING)) { - if (!rb_respond_to(str2, idTo_str)) { - return Qfalse; - } - return rb_equal(str2, str1); + if (!rb_respond_to(str2, idTo_str)) { + return Qfalse; + } + return rb_equal(str2, str1); } - return rb_str_eql_internal(str1, str2); + return str_eql(str1, str2); } /* * call-seq: - * eql?(object) -> true or false - * - * Returns +true+ if +object+ has the same length and content; - * as +self+; +false+ otherwise: - * - * s = 'foo' - * s.eql?('foo') # => true - * s.eql?('food') # => false - * s.eql?('FOO') # => false - * - * Returns +false+ if the two strings' encodings are not compatible: - * - * "\u{e4 f6 fc}".encode("ISO-8859-1").eql?("\u{c4 d6 dc}") # => false + * str.eql?(other) -> true or false * + * Two strings are equal if they have the same length and content. */ VALUE @@ -4179,29 +3272,32 @@ rb_str_eql(VALUE str1, VALUE str2) { if (str1 == str2) return Qtrue; if (!RB_TYPE_P(str2, T_STRING)) return Qfalse; - return rb_str_eql_internal(str1, str2); + return str_eql(str1, str2); } /* * call-seq: - * string <=> other_string -> -1, 0, 1, or nil + * string <=> other_string -> -1, 0, +1, or nil * - * Compares +self+ and +other_string+, returning: + * Comparison---Returns -1, 0, +1, or +nil+ depending on whether +string+ is + * less than, equal to, or greater than +other_string+. * - * - -1 if +other_string+ is larger. - * - 0 if the two are equal. - * - 1 if +other_string+ is smaller. - * - +nil+ if the two are incomparable. + * +nil+ is returned if the two values are incomparable. * - * Examples: + * 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. * - * 'foo' <=> 'foo' # => 0 - * 'foo' <=> 'food' # => -1 - * 'food' <=> 'foo' # => 1 - * 'FOO' <=> 'foo' # => -1 - * 'foo' <=> 'FOO' # => 1 - * 'foo' <=> 1 # => nil + * <code><=></code> is the basis for the methods <code><</code>, + * <code><=</code>, <code>></code>, <code>>=</code>, and + * <code>between?</code>, included from module Comparable. The method + * String#== does not use Comparable#==. * + * "abcdef" <=> "abcde" #=> 1 + * "abcdef" <=> "abcdef" #=> 0 + * "abcdef" <=> "abcdefg" #=> -1 + * "abcdef" <=> "ABCDEF" #=> 1 + * "abcdef" <=> 1 #=> nil */ static VALUE @@ -4210,7 +3306,7 @@ rb_str_cmp_m(VALUE str1, VALUE str2) int result; VALUE s = rb_check_string_type(str2); if (NIL_P(s)) { - return rb_invcmp(str1, str2); + return rb_invcmp(str1, str2); } result = rb_str_cmp(str1, s); return INT2FIX(result); @@ -4221,28 +3317,22 @@ static VALUE str_casecmp_p(VALUE str1, VALUE str2); /* * call-seq: - * casecmp(other_string) -> -1, 0, 1, or nil - * - * Compares <tt>self.downcase</tt> and <tt>other_string.downcase</tt>; returns: - * - * - -1 if <tt>other_string.downcase</tt> is larger. - * - 0 if the two are equal. - * - 1 if <tt>other_string.downcase</tt> is smaller. - * - +nil+ if the two are incomparable. + * str.casecmp(other_str) -> -1, 0, +1, or nil * - * Examples: + * Case-insensitive version of <code>String#<=></code>. + * Currently, case-insensitivity only works on characters A-Z/a-z, + * not all of Unicode. This is different from String#casecmp?. * - * 'foo'.casecmp('foo') # => 0 - * 'foo'.casecmp('food') # => -1 - * 'food'.casecmp('foo') # => 1 - * 'FOO'.casecmp('foo') # => 0 - * 'foo'.casecmp('FOO') # => 0 - * 'foo'.casecmp(1) # => nil + * "aBcDeF".casecmp("abcde") #=> 1 + * "aBcDeF".casecmp("abcdef") #=> 0 + * "aBcDeF".casecmp("abcdefg") #=> -1 + * "abcdef".casecmp("ABCDEF") #=> 0 * - * See {Case Mapping}[rdoc-ref:case_mapping.rdoc]. - * - * Related: String#casecmp?. + * +nil+ is returned if the two strings have incompatible encodings, + * or if +other_str+ is not a string. * + * "foo".casecmp(2) #=> nil + * "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp("\u{c4 d6 dc}") #=> nil */ static VALUE @@ -4250,7 +3340,7 @@ rb_str_casecmp(VALUE str1, VALUE str2) { VALUE s = rb_check_string_type(str2); if (NIL_P(s)) { - return Qnil; + return Qnil; } return str_casecmp(str1, s); } @@ -4260,35 +3350,35 @@ str_casecmp(VALUE str1, VALUE str2) { long len; rb_encoding *enc; - const char *p1, *p1end, *p2, *p2end; + char *p1, *p1end, *p2, *p2end; enc = rb_enc_compatible(str1, str2); if (!enc) { - return Qnil; + 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 = TOLOWER(*p1 & 0xff); - unsigned int c2 = TOLOWER(*p2 & 0xff); + 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++; - } + } + p1++; + p2++; + } } else { - while (p1 < p1end && p2 < p2end) { + 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 = TOLOWER(c1); - c2 = TOLOWER(c2); + c1 = TOUPPER(c1); + c2 = TOUPPER(c2); if (c1 != c2) return INT2FIX(c1 < c2 ? -1 : 1); } @@ -4303,9 +3393,9 @@ str_casecmp(VALUE str1, VALUE str2) if (l1 != l2) return INT2FIX(l1 < l2 ? -1 : 1); } - p1 += l1; - p2 += l2; - } + p1 += l1; + p2 += l2; + } } if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0); if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1); @@ -4314,25 +3404,22 @@ str_casecmp(VALUE str1, VALUE str2) /* * call-seq: - * casecmp?(other_string) -> true, false, or nil + * str.casecmp?(other_str) -> true, false, or nil * - * Returns +true+ if +self+ and +other_string+ are equal after - * Unicode case folding, otherwise +false+: + * Returns +true+ if +str+ and +other_str+ are equal after + * Unicode case folding, +false+ if they are not equal. * - * 'foo'.casecmp?('foo') # => true - * 'foo'.casecmp?('food') # => false - * 'food'.casecmp?('foo') # => false - * 'FOO'.casecmp?('foo') # => true - * 'foo'.casecmp?('FOO') # => true + * "aBcDeF".casecmp?("abcde") #=> false + * "aBcDeF".casecmp?("abcdef") #=> true + * "aBcDeF".casecmp?("abcdefg") #=> false + * "abcdef".casecmp?("ABCDEF") #=> true + * "\u{e4 f6 fc}".casecmp?("\u{c4 d6 dc}") #=> true * - * Returns +nil+ if the two values are incomparable: - * - * 'foo'.casecmp?(1) # => nil - * - * See {Case Mapping}[rdoc-ref:case_mapping.rdoc]. - * - * Related: String#casecmp. + * +nil+ is returned if the two strings have incompatible encodings, + * or if +other_str+ is not a string. * + * "foo".casecmp?(2) #=> nil + * "\u{e4 f6 fc}".encode("ISO-8859-1").casecmp?("\u{c4 d6 dc}") #=> nil */ static VALUE @@ -4340,7 +3427,7 @@ rb_str_casecmp_p(VALUE str1, VALUE str2) { VALUE s = rb_check_string_type(str2); if (NIL_P(s)) { - return Qnil; + return Qnil; } return str_casecmp_p(str1, s); } @@ -4354,7 +3441,7 @@ str_casecmp_p(VALUE str1, VALUE str2) enc = rb_enc_compatible(str1, str2); if (!enc) { - return Qnil; + return Qnil; } folded_str1 = rb_str_downcase(1, &fold_opt, str1); @@ -4365,34 +3452,33 @@ str_casecmp_p(VALUE str1, VALUE str2) static long strseq_core(const char *str_ptr, const char *str_ptr_end, long str_len, - const char *sub_ptr, long sub_len, long offset, rb_encoding *enc) + const char *sub_ptr, long sub_len, long offset, rb_encoding *enc) { const char *search_start = str_ptr; long pos, search_len = str_len - offset; for (;;) { - const char *t; - pos = rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc); - if (pos < 0) return pos; - t = rb_enc_right_char_head(search_start, search_start+pos, str_ptr_end, enc); - if (t == search_start + pos) break; - search_len -= t - search_start; - if (search_len <= 0) return -1; - offset += t - search_start; - search_start = t; + const char *t; + pos = rb_memsearch(sub_ptr, sub_len, search_start, search_len, enc); + if (pos < 0) return pos; + t = rb_enc_right_char_head(search_start, search_start+pos, str_ptr_end, enc); + if (t == search_start + pos) break; + search_len -= t - search_start; + if (search_len <= 0) return -1; + offset += t - search_start; + search_start = t; } return pos + offset; } -/* found index in byte */ #define rb_str_index(str, sub, offset) rb_strseq_index(str, sub, offset, 0) -#define rb_str_byteindex(str, sub, offset) rb_strseq_index(str, sub, offset, 1) static long rb_strseq_index(VALUE str, VALUE sub, long offset, int in_byte) { const char *str_ptr, *str_ptr_end, *sub_ptr; long str_len, sub_len; + int single_byte = single_byte_optimizable(str); rb_encoding *enc; enc = rb_enc_check(str, sub); @@ -4407,17 +3493,16 @@ rb_strseq_index(VALUE str, VALUE sub, long offset, int in_byte) if (str_len < sub_len) return -1; if (offset != 0) { - long str_len_char, sub_len_char; - int single_byte = single_byte_optimizable(str); - str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc); - sub_len_char = in_byte ? sub_len : str_strlen(sub, enc); - if (offset < 0) { - offset += str_len_char; - if (offset < 0) return -1; - } - if (str_len_char - offset < sub_len_char) return -1; - if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte); - str_ptr += offset; + long str_len_char, sub_len_char; + str_len_char = (in_byte || single_byte) ? str_len : str_strlen(str, enc); + sub_len_char = in_byte ? sub_len : str_strlen(sub, enc); + if (offset < 0) { + offset += str_len_char; + if (offset < 0) return -1; + } + if (str_len_char - offset < sub_len_char) return -1; + if (!in_byte) offset = str_offset(str_ptr, str_ptr_end, offset, enc, single_byte); + str_ptr += offset; } if (sub_len == 0) return offset; @@ -4428,11 +3513,19 @@ rb_strseq_index(VALUE str, VALUE sub, long offset, int in_byte) /* * call-seq: - * index(substring, offset = 0) -> integer or nil - * index(regexp, offset = 0) -> integer or nil + * str.index(substring [, offset]) -> integer or nil + * str.index(regexp [, offset]) -> integer or nil * - * :include: doc/string/index.rdoc + * Returns the index of the first occurrence of the given <i>substring</i> or + * pattern (<i>regexp</i>) in <i>str</i>. Returns <code>nil</code> 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 @@ -4440,338 +3533,128 @@ rb_str_index_m(int argc, VALUE *argv, VALUE str) { VALUE sub; VALUE initpos; - rb_encoding *enc = STR_ENC_GET(str); long pos; if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) { - long slen = str_strlen(str, enc); /* str's enc */ - pos = NUM2LONG(initpos); - if (pos < 0 ? (pos += slen) < 0 : pos > slen) { - if (RB_TYPE_P(sub, T_REGEXP)) { - rb_backref_set(Qnil); - } - return Qnil; - } + pos = NUM2LONG(initpos); } else { - pos = 0; + pos = 0; } - - if (RB_TYPE_P(sub, T_REGEXP)) { - pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos, - enc, single_byte_optimizable(str)); - - if (rb_reg_search(sub, str, pos, 0) >= 0) { - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - pos = rb_str_sublen(str, BEG(0)); - return LONG2NUM(pos); - } + if (pos < 0) { + pos += str_strlen(str, NULL); + if (pos < 0) { + if (RB_TYPE_P(sub, T_REGEXP)) { + rb_backref_set(Qnil); + } + return Qnil; + } } - else { - StringValue(sub); - pos = rb_str_index(str, sub, pos); - if (pos >= 0) { - pos = rb_str_sublen(str, pos); - return LONG2NUM(pos); - } - } - return Qnil; -} - -/* Ensure that the given pos is a valid character boundary. - * Note that in this function, "character" means a code point - * (Unicode scalar value), not a grapheme cluster. - */ -static void -str_ensure_byte_pos(VALUE str, long pos) -{ - if (!single_byte_optimizable(str)) { - const char *s = RSTRING_PTR(str); - const char *e = RSTRING_END(str); - const char *p = s + pos; - if (!at_char_boundary(s, p, e, rb_enc_get(str))) { - rb_raise(rb_eIndexError, - "offset %ld does not land on character boundary", pos); - } - } -} - -/* - * call-seq: - * byteindex(substring, offset = 0) -> integer or nil - * byteindex(regexp, offset = 0) -> integer or nil - * - * Returns the Integer byte-based index of the first occurrence of the given +substring+, - * or +nil+ if none found: - * - * 'foo'.byteindex('f') # => 0 - * 'foo'.byteindex('o') # => 1 - * 'foo'.byteindex('oo') # => 1 - * 'foo'.byteindex('ooo') # => nil - * - * Returns the Integer byte-based index of the first match for the given Regexp +regexp+, - * or +nil+ if none found: - * - * 'foo'.byteindex(/f/) # => 0 - * 'foo'.byteindex(/o/) # => 1 - * 'foo'.byteindex(/oo/) # => 1 - * 'foo'.byteindex(/ooo/) # => nil - * - * Integer argument +offset+, if given, specifies the byte-based position in the - * string to begin the search: - * - * 'foo'.byteindex('o', 1) # => 1 - * 'foo'.byteindex('o', 2) # => 2 - * 'foo'.byteindex('o', 3) # => nil - * - * If +offset+ is negative, counts backward from the end of +self+: - * - * 'foo'.byteindex('o', -1) # => 2 - * 'foo'.byteindex('o', -2) # => 1 - * 'foo'.byteindex('o', -3) # => 1 - * 'foo'.byteindex('o', -4) # => nil - * - * If +offset+ does not land on character (codepoint) boundary, +IndexError+ is - * raised. - * - * Related: String#index, String#byterindex. - */ -static VALUE -rb_str_byteindex_m(int argc, VALUE *argv, VALUE str) -{ - VALUE sub; - VALUE initpos; - long pos; - - if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) { - long slen = RSTRING_LEN(str); - pos = NUM2LONG(initpos); - if (pos < 0 ? (pos += slen) < 0 : pos > slen) { - if (RB_TYPE_P(sub, T_REGEXP)) { - rb_backref_set(Qnil); - } - return Qnil; - } - } - else { - pos = 0; - } - - str_ensure_byte_pos(str, pos); - - if (RB_TYPE_P(sub, T_REGEXP)) { - if (rb_reg_search(sub, str, pos, 0) >= 0) { - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - pos = BEG(0); - return LONG2NUM(pos); - } - } - else { - StringValue(sub); - pos = rb_str_byteindex(str, sub, pos); - if (pos >= 0) return LONG2NUM(pos); - } - return Qnil; -} - -#ifndef HAVE_MEMRCHR -static void* -memrchr(const char *search_str, int chr, long search_len) -{ - const char *ptr = search_str + search_len; - while (ptr > search_str) { - if ((unsigned char)*(--ptr) == chr) return (void *)ptr; + 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; } - return ((void *)0); + if (pos == -1) return Qnil; + return LONG2NUM(pos); } -#endif +#ifdef HAVE_MEMRCHR static long -str_rindex(VALUE str, VALUE sub, const char *s, rb_encoding *enc) +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; - sbeg = RSTRING_PTR(str); slen = RSTRING_LEN(sub); - if (slen == 0) return s - sbeg; + if (slen == 0) return pos; + sbeg = RSTRING_PTR(str); e = RSTRING_END(str); t = RSTRING_PTR(sub); c = *t & 0xff; searchlen = s - sbeg + 1; - if (memcmp(s, t, slen) == 0) { - return s - sbeg; - } - 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 hit - sbeg; - searchlen = adjusted - sbeg; + 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; } - -/* found index in byte */ +#else static long -rb_str_rindex(VALUE str, VALUE sub, long pos) +str_rindex(VALUE str, VALUE sub, const char *s, long pos, rb_encoding *enc) { - 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; + long slen; + char *sbeg, *e, *t; sbeg = RSTRING_PTR(str); + e = RSTRING_END(str); + t = RSTRING_PTR(sub); + slen = RSTRING_LEN(sub); - 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, enc); -} - -/* - * call-seq: - * rindex(substring, offset = self.length) -> integer or nil - * rindex(regexp, offset = self.length) -> integer or nil - * - * Returns the Integer index of the _last_ occurrence of the given +substring+, - * or +nil+ if none found: - * - * 'foo'.rindex('f') # => 0 - * 'foo'.rindex('o') # => 2 - * 'foo'.rindex('oo') # => 1 - * 'foo'.rindex('ooo') # => nil - * - * Returns the Integer index of the _last_ match for the given Regexp +regexp+, - * or +nil+ if none found: - * - * 'foo'.rindex(/f/) # => 0 - * 'foo'.rindex(/o/) # => 2 - * 'foo'.rindex(/oo/) # => 1 - * 'foo'.rindex(/ooo/) # => nil - * - * The _last_ match means starting at the possible last position, not - * the last of longest matches. - * - * 'foo'.rindex(/o+/) # => 2 - * $~ #=> #<MatchData "o"> - * - * To get the last longest match, needs to combine with negative - * lookbehind. - * - * 'foo'.rindex(/(?<!o)o+/) # => 1 - * $~ #=> #<MatchData "oo"> - * - * Or String#index with negative lookforward. - * - * 'foo'.index(/o+(?!.*o)/) # => 1 - * $~ #=> #<MatchData "oo"> - * - * Integer argument +offset+, if given and non-negative, specifies the maximum starting position in the - * string to _end_ the search: - * - * 'foo'.rindex('o', 0) # => nil - * 'foo'.rindex('o', 1) # => 1 - * 'foo'.rindex('o', 2) # => 2 - * 'foo'.rindex('o', 3) # => 2 - * - * If +offset+ is a negative Integer, the maximum starting position in the - * string to _end_ the search is the sum of the string's length and +offset+: - * - * 'foo'.rindex('o', -1) # => 2 - * 'foo'.rindex('o', -2) # => 1 - * 'foo'.rindex('o', -3) # => nil - * 'foo'.rindex('o', -4) # => nil - * - * Related: String#index. - */ - -static VALUE -rb_str_rindex_m(int argc, VALUE *argv, VALUE str) -{ - VALUE sub; - VALUE initpos; - 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, &initpos) == 2) { - pos = NUM2LONG(initpos); - if (pos < 0 && (pos += len) < 0) { - if (RB_TYPE_P(sub, T_REGEXP)) { - rb_backref_set(Qnil); - } - return Qnil; - } - if (pos > len) pos = len; - } - else { - pos = len; + while (s) { + if (memcmp(s, t, slen) == 0) { + return pos; + } + if (pos == 0) break; + pos--; + s = rb_enc_prev_char(sbeg, s, e, enc); } - if (RB_TYPE_P(sub, T_REGEXP)) { - /* enc = rb_enc_check(str, sub); */ - pos = str_offset(RSTRING_PTR(str), RSTRING_END(str), pos, - enc, single_byte_optimizable(str)); - - if (rb_reg_search(sub, str, pos, 1) >= 0) { - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - pos = rb_str_sublen(str, BEG(0)); - return LONG2NUM(pos); - } - } - else { - StringValue(sub); - pos = rb_str_rindex(str, sub, pos); - if (pos >= 0) { - pos = rb_str_sublen(str, pos); - return LONG2NUM(pos); - } - } - return Qnil; + return -1; } +#endif static long -rb_str_byterindex(VALUE str, VALUE sub, long pos) +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; - len = RSTRING_LEN(str); - slen = RSTRING_LEN(sub); + 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; @@ -4781,156 +3664,124 @@ rb_str_byterindex(VALUE str, VALUE sub, long pos) sbeg = RSTRING_PTR(str); if (pos == 0) { - if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0) - return 0; - else - return -1; + if (memcmp(sbeg, RSTRING_PTR(sub), RSTRING_LEN(sub)) == 0) + return 0; + else + return -1; } - s = sbeg + pos; - return str_rindex(str, sub, s, enc); + s = str_nth(sbeg, RSTRING_END(str), pos, enc, singlebyte); + return str_rindex(str, sub, s, pos, enc); } /* * call-seq: - * byterindex(substring, offset = self.bytesize) -> integer or nil - * byterindex(regexp, offset = self.bytesize) -> integer or nil - * - * Returns the Integer byte-based index of the _last_ occurrence of the given +substring+, - * or +nil+ if none found: - * - * 'foo'.byterindex('f') # => 0 - * 'foo'.byterindex('o') # => 2 - * 'foo'.byterindex('oo') # => 1 - * 'foo'.byterindex('ooo') # => nil - * - * Returns the Integer byte-based index of the _last_ match for the given Regexp +regexp+, - * or +nil+ if none found: - * - * 'foo'.byterindex(/f/) # => 0 - * 'foo'.byterindex(/o/) # => 2 - * 'foo'.byterindex(/oo/) # => 1 - * 'foo'.byterindex(/ooo/) # => nil - * - * The _last_ match means starting at the possible last position, not - * the last of longest matches. - * - * 'foo'.byterindex(/o+/) # => 2 - * $~ #=> #<MatchData "o"> - * - * To get the last longest match, needs to combine with negative - * lookbehind. - * - * 'foo'.byterindex(/(?<!o)o+/) # => 1 - * $~ #=> #<MatchData "oo"> + * str.rindex(substring [, integer]) -> integer or nil + * str.rindex(regexp [, integer]) -> integer or nil * - * Or String#byteindex with negative lookforward. + * Returns the index of the last occurrence of the given <i>substring</i> or + * pattern (<i>regexp</i>) in <i>str</i>. Returns <code>nil</code> 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. * - * 'foo'.byteindex(/o+(?!.*o)/) # => 1 - * $~ #=> #<MatchData "oo"> - * - * Integer argument +offset+, if given and non-negative, specifies the maximum starting byte-based position in the - * string to _end_ the search: - * - * 'foo'.byterindex('o', 0) # => nil - * 'foo'.byterindex('o', 1) # => 1 - * 'foo'.byterindex('o', 2) # => 2 - * 'foo'.byterindex('o', 3) # => 2 - * - * If +offset+ is a negative Integer, the maximum starting position in the - * string to _end_ the search is the sum of the string's length and +offset+: - * - * 'foo'.byterindex('o', -1) # => 2 - * 'foo'.byterindex('o', -2) # => 1 - * 'foo'.byterindex('o', -3) # => nil - * 'foo'.byterindex('o', -4) # => nil - * - * If +offset+ does not land on character (codepoint) boundary, +IndexError+ is - * raised. - * - * Related: String#byteindex. + * "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_byterindex_m(int argc, VALUE *argv, VALUE str) +rb_str_rindex_m(int argc, VALUE *argv, VALUE str) { VALUE sub; - VALUE initpos; - long pos, len = RSTRING_LEN(str); + 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, &initpos) == 2) { - pos = NUM2LONG(initpos); - if (pos < 0 && (pos += len) < 0) { - if (RB_TYPE_P(sub, T_REGEXP)) { - rb_backref_set(Qnil); - } - return Qnil; - } - if (pos > len) pos = len; + 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; + pos = len; } - str_ensure_byte_pos(str, pos); - - if (RB_TYPE_P(sub, T_REGEXP)) { - if (rb_reg_search(sub, str, pos, 1) >= 0) { - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - pos = BEG(0); - return LONG2NUM(pos); - } - } - else { - StringValue(sub); - pos = rb_str_byterindex(str, sub, pos); - if (pos >= 0) return LONG2NUM(pos); + 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)); + + 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: - * string =~ regexp -> integer or nil - * string =~ object -> integer or nil - * - * Returns the Integer index of the first substring that matches - * the given +regexp+, or +nil+ if no match found: + * str =~ obj -> integer or nil * - * 'foo' =~ /f/ # => 0 - * 'foo' =~ /o/ # => 1 - * 'foo' =~ /x/ # => nil + * Match---If <i>obj</i> is a <code>Regexp</code>, use it as a pattern to match + * against <i>str</i>,and returns the position the match starts, or + * <code>nil</code> if there is no match. Otherwise, invokes + * <i>obj.=~</i>, passing <i>str</i> as an argument. The default + * <code>=~</code> in <code>Object</code> returns <code>nil</code>. * - * Note: also updates Regexp@Global+Variables. - * - * If the given +object+ is not a Regexp, returns the value - * returned by <tt>object =~ self</tt>. - * - * Note that <tt>string =~ regexp</tt> is different from <tt>regexp =~ string</tt> - * (see Regexp#=~): - * - * number= nil - * "no. 9" =~ /(?<number>\d+)/ - * number # => nil (not assigned) - * /(?<number>\d+)/ =~ "no. 9" - * number #=> "9" + * Note: <code>str =~ regexp</code> is not the same as + * <code>regexp =~ str</code>. 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) { - switch (OBJ_BUILTIN_TYPE(y)) { + if (SPECIAL_CONST_P(y)) goto generic; + switch (BUILTIN_TYPE(y)) { case T_STRING: - rb_raise(rb_eTypeError, "type mismatch: String given"); + rb_raise(rb_eTypeError, "type mismatch: String given"); case T_REGEXP: - return rb_reg_match(y, x); + return rb_reg_match(y, x); + generic: default: - return rb_funcall(y, idEqTilde, 1, x); + return rb_funcall(y, idEqTilde, 1, x); } } @@ -4940,37 +3791,32 @@ static VALUE get_pat(VALUE); /* * call-seq: - * match(pattern, offset = 0) -> matchdata or nil - * match(pattern, offset = 0) {|matchdata| ... } -> object - * - * Returns a MatchData object (or +nil+) based on +self+ and the given +pattern+. + * str.match(pattern) -> matchdata or nil + * str.match(pattern, pos) -> matchdata or nil * - * Note: also updates Regexp@Global+Variables. + * Converts <i>pattern</i> to a <code>Regexp</code> (if it isn't already one), + * then invokes its <code>match</code> method on <i>str</i>. If the second + * parameter is present, it specifies the position in the string to begin the + * search. * - * - Computes +regexp+ by converting +pattern+ (if not already a Regexp). - * regexp = Regexp.new(pattern) - * - Computes +matchdata+, which will be either a MatchData object or +nil+ - * (see Regexp#match): - * matchdata = <tt>regexp.match(self) + * 'hello'.match('(.)\1') #=> #<MatchData "ll" 1:"l"> + * 'hello'.match('(.)\1')[0] #=> "ll" + * 'hello'.match(/(.)\1/)[0] #=> "ll" + * 'hello'.match(/(.)\1/, 3) #=> nil + * 'hello'.match('xx') #=> nil * - * With no block given, returns the computed +matchdata+: + * If a block is given, invoke the block with MatchData if match succeed, so + * that you can write * - * 'foo'.match('f') # => #<MatchData "f"> - * 'foo'.match('o') # => #<MatchData "o"> - * 'foo'.match('x') # => nil + * str.match(pat) {|m| ...} * - * If Integer argument +offset+ is given, the search begins at index +offset+: + * instead of * - * 'foo'.match('f', 1) # => nil - * 'foo'.match('o', 1) # => #<MatchData "o"> - * - * With a block given, calls the block with the computed +matchdata+ - * and returns the block's return value: - * - * 'foo'.match(/o/) {|matchdata| matchdata } # => #<MatchData "o"> - * 'foo'.match(/x/) {|matchdata| matchdata } # => nil - * 'foo'.match(/f/, 1) {|matchdata| matchdata } # => nil + * if m = str.match(pat) + * ... + * end * + * The return value is a value from block execution in this case. */ static VALUE @@ -4978,38 +3824,31 @@ rb_str_match_m(int argc, VALUE *argv, VALUE str) { VALUE re, result; if (argc < 1) - rb_check_arity(argc, 1, 2); + rb_check_arity(argc, 1, 2); re = argv[0]; argv[0] = str; result = rb_funcallv(get_pat(re), rb_intern("match"), argc, argv); if (!NIL_P(result) && rb_block_given_p()) { - return rb_yield(result); + return rb_yield(result); } return result; } /* * call-seq: - * match?(pattern, offset = 0) -> true or false - * - * Returns +true+ or +false+ based on whether a match is found for +self+ and +pattern+. - * - * Note: does not update Regexp@Global+Variables. + * str.match?(pattern) -> true or false + * str.match?(pattern, pos) -> true or false * - * Computes +regexp+ by converting +pattern+ (if not already a Regexp). - * regexp = Regexp.new(pattern) - * - * Returns +true+ if <tt>self+.match(regexp)</tt> returns a MatchData object, - * +false+ otherwise: - * - * 'foo'.match?(/o/) # => true - * 'foo'.match?('o') # => true - * 'foo'.match?(/x/) # => false - * - * If Integer argument +offset+ is given, the search begins at index +offset+: - * 'foo'.match?('f', 1) # => false - * 'foo'.match?('o', 1) # => true + * Converts _pattern_ to a +Regexp+ (if it isn't already one), then + * returns a +true+ or +false+ indicates whether the regexp is + * matched _str_ or not without updating <code>$~</code> and other + * related variables. If the second parameter is present, it + * specifies the position in the string to begin the search. * + * "Ruby".match?(/R.../) #=> true + * "Ruby".match?(/R.../, 1) #=> false + * "Ruby".match?(/P.../) #=> false + * $& #=> nil */ static VALUE @@ -5034,21 +3873,21 @@ enc_succ_char(char *p, long len, rb_encoding *enc) 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; + /* 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--) @@ -5085,23 +3924,23 @@ 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; + /* 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--) @@ -5164,12 +4003,12 @@ enc_succ_alnum_char(char *p, long len, rb_encoding *enc, char *carry) MEMCPY(save, p, char, len); for (try = 0; try <= max_gaps; ++try) { - 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; - } + 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; @@ -5208,68 +4047,36 @@ static VALUE str_succ(VALUE str); /* * call-seq: - * succ -> new_str - * - * Returns the successor to +self+. The successor is calculated by - * incrementing characters. - * - * The first character to be incremented is the rightmost alphanumeric: - * or, if no alphanumerics, the rightmost character: + * str.succ -> new_str + * str.next -> new_str * - * 'THX1138'.succ # => "THX1139" - * '<<koala>>'.succ # => "<<koalb>>" - * '***'.succ # => '**+' + * Returns the successor to <i>str</i>. 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. * - * The successor to a digit is another digit, "carrying" to the next-left - * character for a "rollover" from 9 to 0, and prepending another digit - * if necessary: - * - * '00'.succ # => "01" - * '09'.succ # => "10" - * '99'.succ # => "100" - * - * The successor to a letter is another letter of the same case, - * carrying to the next-left character for a rollover, - * and prepending another same-case letter if necessary: - * - * 'aa'.succ # => "ab" - * 'az'.succ # => "ba" - * 'zz'.succ # => "aaa" - * 'AA'.succ # => "AB" - * 'AZ'.succ # => "BA" - * 'ZZ'.succ # => "AAA" - * - * The successor to a non-alphanumeric character is the next character - * in the underlying character set's collating sequence, - * carrying to the next-left character for a rollover, - * and prepending another character if necessary: - * - * s = 0.chr * 3 - * s # => "\x00\x00\x00" - * s.succ # => "\x00\x00\x01" - * s = 255.chr * 3 - * s # => "\xFF\xFF\xFF" - * s.succ # => "\x01\x00\x00\x00" - * - * Carrying can occur between and among mixtures of alphanumeric characters: - * - * s = 'zz99zz99' - * s.succ # => "aaa00aa00" - * s = '99zz99zz' - * s.succ # => "100aa00aa" - * - * The successor to an empty +String+ is a new empty +String+: - * - * ''.succ # => "" + * 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" + * "<<koala>>".succ #=> "<<koalb>>" + * "1999zzz".succ #=> "2000aaa" + * "ZZZ9999".succ #=> "AAAA0000" + * "***".succ #=> "**+" */ VALUE rb_str_succ(VALUE orig) { VALUE str; - str = rb_str_new(RSTRING_PTR(orig), RSTRING_LEN(orig)); + 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); } @@ -5278,7 +4085,7 @@ str_succ(VALUE str) { rb_encoding *enc; char *sbeg, *s, *e, *last_alnum = 0; - int found_alnum = 0; + int c = -1; long l, slen; char carry[ONIGENC_CODE_TO_MBC_MAXLEN] = "\1"; long carry_pos = 0, carry_len = 1; @@ -5292,50 +4099,51 @@ str_succ(VALUE 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) { - break; - } - } - l = rb_enc_precise_mbclen(s, e, enc); - if (!ONIGENC_MBCLEN_CHARFOUND_P(l)) continue; - l = ONIGENC_MBCLEN_CHARFOUND_LEN(l); + 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; - } - found_alnum = 1; + 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 (!found_alnum) { /* str contains no alnum */ - s = e; - while ((s = rb_enc_prev_char(sbeg, s, e, enc)) != 0) { + 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); + 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; - } + 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); @@ -5345,8 +4153,8 @@ str_succ(VALUE str) carry_len = l; } carry_pos = s - sbeg; - } - ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN); + } + ENC_CODERANGE_SET(str, ENC_CODERANGE_UNKNOWN); } RESIZE_CAPA(str, slen + carry_len); sbeg = RSTRING_PTR(str); @@ -5363,9 +4171,11 @@ str_succ(VALUE str) /* * call-seq: - * succ! -> self + * str.succ! -> str + * str.next! -> str * - * Equivalent to String#succ, but modifies +self+ in place; returns +self+. + * Equivalent to <code>String#succ</code>, but modifies the receiver in + * place. */ static VALUE @@ -5380,12 +4190,14 @@ static int all_digits_p(const char *s, long len) { while (len-- > 0) { - if (!ISDIGIT(*s)) return 0; - s++; + if (!ISDIGIT(*s)) return 0; + s++; } return 1; } +static VALUE str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALUE); + static int str_upto_i(VALUE str, VALUE arg) { @@ -5395,37 +4207,34 @@ str_upto_i(VALUE str, VALUE arg) /* * call-seq: - * upto(other_string, exclusive = false) {|string| ... } -> self - * upto(other_string, exclusive = false) -> new_enumerator - * - * With a block given, calls the block with each +String+ value - * returned by successive calls to String#succ; - * the first value is +self+, the next is <tt>self.succ</tt>, and so on; - * the sequence terminates when value +other_string+ is reached; - * returns +self+: - * - * 'a8'.upto('b6') {|s| print s, ' ' } # => "a8" - * Output: + * str.upto(other_str, exclusive=false) {|s| block } -> str + * str.upto(other_str, exclusive=false) -> an_enumerator * - * a8 a9 b0 b1 b2 b3 b4 b5 b6 + * Iterates through successive values, starting at <i>str</i> and + * ending at <i>other_str</i> inclusive, passing each value in turn to + * the block. The <code>String#succ</code> 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 argument +exclusive+ is given as a truthy object, the last value is omitted: + * If no block is given, an enumerator is returned instead. * - * 'a8'.upto('b6', true) {|s| print s, ' ' } # => "a8" - * - * Output: - * - * a8 a9 b0 b1 b2 b3 b4 b5 - * - * If +other_string+ would not be reached, does not call the block: + * "a8".upto("b6") {|s| print s, ' ' } + * for s in "a8".."b6" + * print s, ' ' + * end * - * '25'.upto('5') {|s| fail s } - * 'aa'.upto('a') {|s| fail s } + * <em>produces:</em> * - * With no block given, returns a new Enumerator: + * a8 a9 b0 b1 b2 b3 b4 b5 b6 + * a8 a9 b0 b1 b2 b3 b4 b5 b6 * - * 'a8'.upto('b6') # => #<Enumerator: "a8":upto("b6")> + * If <i>str</i> and <i>other_str</i> 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 @@ -5435,11 +4244,11 @@ rb_str_upto(int argc, VALUE *argv, VALUE beg) rb_scan_args(argc, argv, "11", &end, &exclusive); RETURN_ENUMERATOR(beg, argc, argv); - return rb_str_upto_each(beg, end, RTEST(exclusive), str_upto_i, Qnil); + return str_upto_each(beg, end, RTEST(exclusive), str_upto_i, Qnil); } -VALUE -rb_str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALUE arg) +static VALUE +str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALUE arg) { VALUE current, after_end; ID succ; @@ -5452,115 +4261,69 @@ rb_str_upto_each(VALUE beg, VALUE end, int excl, int (*each)(VALUE, VALUE), VALU 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 (;;) { - VALUE str = rb_enc_str_new(&c, 1, enc); - ENC_CODERANGE_SET(str, RUBY_ENC_CODERANGE_7BIT); - if ((*each)(str, arg)) break; - if (!excl && c == e) break; - c++; - if (excl && c == e) break; - } - return beg; + char c = RSTRING_PTR(beg)[0]; + char e = RSTRING_PTR(end)[0]; + + if (c > e || (excl && c == e)) return beg; + for (;;) { + if ((*each)(rb_enc_str_new(&c, 1, enc), arg)) break; + 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]) && - all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) && - all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) { - VALUE b, e; - int width; - - width = RSTRING_LENINT(beg); - 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; - if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break; - bi++; - } - } - else { - ID op = excl ? '<' : idLE; - VALUE args[2], fmt = rb_fstring_lit("%.*d"); - - args[0] = INT2FIX(width); - while (rb_funcall(b, op, 1, e)) { - args[1] = b; - if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break; - b = rb_funcallv(b, succ, 0, 0); - } - } - return beg; + all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg)) && + all_digits_p(RSTRING_PTR(end), RSTRING_LEN(end))) { + VALUE b, e; + int width; + + width = RSTRING_LENINT(beg); + 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; + if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break; + bi++; + } + } + else { + ID op = excl ? '<' : idLE; + VALUE args[2], fmt = rb_fstring_cstr("%.*d"); + + args[0] = INT2FIX(width); + while (rb_funcall(b, op, 1, e)) { + args[1] = b; + if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break; + b = rb_funcallv(b, succ, 0, 0); + } + } + return beg; } /* normal case */ n = rb_str_cmp(beg, end); if (n > 0 || (excl && n == 0)) return beg; after_end = rb_funcallv(end, succ, 0, 0); - current = str_duplicate(rb_cString, beg); + current = rb_str_dup(beg); while (!rb_str_equal(current, after_end)) { - VALUE next = Qnil; - if (excl || !rb_str_equal(current, end)) - next = rb_funcallv(current, succ, 0, 0); - if ((*each)(current, arg)) break; - 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; -} - -VALUE -rb_str_upto_endless_each(VALUE beg, int (*each)(VALUE, VALUE), VALUE arg) -{ - VALUE current; - ID succ; - - CONST_ID(succ, "succ"); - /* both edges are all digits */ - if (is_ascii_string(beg) && ISDIGIT(RSTRING_PTR(beg)[0]) && - all_digits_p(RSTRING_PTR(beg), RSTRING_LEN(beg))) { - VALUE b, args[2], fmt = rb_fstring_lit("%.*d"); - int width = RSTRING_LENINT(beg); - b = rb_str_to_inum(beg, 10, FALSE); - if (FIXNUM_P(b)) { - long bi = FIX2LONG(b); - rb_encoding *usascii = rb_usascii_encoding(); - - while (FIXABLE(bi)) { - if ((*each)(rb_enc_sprintf(usascii, "%.*ld", width, bi), arg)) break; - bi++; - } - b = LONG2NUM(bi); - } - args[0] = INT2FIX(width); - while (1) { - args[1] = b; - if ((*each)(rb_str_format(numberof(args), args, fmt), arg)) break; - b = rb_funcallv(b, succ, 0, 0); - } - } - /* normal case */ - current = str_duplicate(rb_cString, beg); - while (1) { - VALUE next = rb_funcallv(current, succ, 0, 0); - if ((*each)(current, arg)) break; - current = next; - StringValue(current); - if (RSTRING_LEN(current) == 0) - break; + VALUE next = Qnil; + if (excl || !rb_str_equal(current, end)) + next = rb_funcallv(current, succ, 0, 0); + if ((*each)(current, arg)) break; + 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; @@ -5585,37 +4348,38 @@ rb_str_include_range_p(VALUE beg, VALUE end, VALUE val, VALUE exclusive) val = rb_check_string_type(val); if (NIL_P(val)) return Qfalse; if (rb_enc_asciicompat(STR_ENC_GET(beg)) && - rb_enc_asciicompat(STR_ENC_GET(end)) && - rb_enc_asciicompat(STR_ENC_GET(val))) { - const char *bp = RSTRING_PTR(beg); - const char *ep = RSTRING_PTR(end); - const char *vp = RSTRING_PTR(val); - if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) { - if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1) - return Qfalse; - else { - char b = *bp; - char e = *ep; - char v = *vp; - - if (ISASCII(b) && ISASCII(e) && ISASCII(v)) { - if (b <= v && v < e) return Qtrue; - return RBOOL(!RTEST(exclusive) && v == e); - } - } - } + rb_enc_asciicompat(STR_ENC_GET(end)) && + rb_enc_asciicompat(STR_ENC_GET(val))) { + const char *bp = RSTRING_PTR(beg); + const char *ep = RSTRING_PTR(end); + const char *vp = RSTRING_PTR(val); + if (RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) { + if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1) + return Qfalse; + else { + char b = *bp; + char e = *ep; + char v = *vp; + + if (ISASCII(b) && ISASCII(e) && ISASCII(v)) { + if (b <= v && v < e) return Qtrue; + if (!RTEST(exclusive) && v == e) return Qtrue; + return Qfalse; + } + } + } #if 0 - /* both edges are all digits */ - if (ISDIGIT(*bp) && ISDIGIT(*ep) && - all_digits_p(bp, RSTRING_LEN(beg)) && - all_digits_p(ep, RSTRING_LEN(end))) { - /* TODO */ - } + /* both edges are all digits */ + if (ISDIGIT(*bp) && ISDIGIT(*ep) && + all_digits_p(bp, RSTRING_LEN(beg)) && + all_digits_p(ep, RSTRING_LEN(end))) { + /* TODO */ + } #endif } - rb_str_upto_each(beg, end, RTEST(exclusive), include_range_i, (VALUE)&val); + str_upto_each(beg, end, RTEST(exclusive), include_range_i, (VALUE)&val); - return RBOOL(NIL_P(val)); + return NIL_P(val) ? Qtrue : Qfalse; } static VALUE @@ -5624,7 +4388,7 @@ 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 rb_reg_nth_match(nth, match); } return Qnil; } @@ -5635,28 +4399,28 @@ rb_str_aref(VALUE str, VALUE indx) long idx; if (FIXNUM_P(indx)) { - idx = FIX2LONG(indx); + idx = FIX2LONG(indx); } else if (RB_TYPE_P(indx, T_REGEXP)) { - return rb_str_subpat(str, indx, INT2FIX(0)); + return rb_str_subpat(str, indx, INT2FIX(0)); } else if (RB_TYPE_P(indx, T_STRING)) { - if (rb_str_index(str, indx, 0) != -1) - return str_duplicate(rb_cString, indx); - return Qnil; + if (rb_str_index(str, indx, 0) != -1) + return rb_str_dup(indx); + return Qnil; } else { - /* check if indx is Range */ - long beg, len = str_strlen(str, NULL); - switch (rb_range_beg_len(indx, &beg, &len, len, 0)) { - case Qfalse: - break; - case Qnil: - return Qnil; - default: - return rb_str_substr(str, beg, len); - } - idx = NUM2LONG(indx); + /* check if indx is Range */ + long beg, len = str_strlen(str, NULL); + switch (rb_range_beg_len(indx, &beg, &len, len, 0)) { + case Qfalse: + break; + case Qnil: + return Qnil; + default: + return rb_str_substr(str, beg, len); + } + idx = NUM2LONG(indx); } return str_substr(str, idx, 1, FALSE); @@ -5665,28 +4429,85 @@ rb_str_aref(VALUE str, VALUE indx) /* * call-seq: - * string[index] -> new_string or nil - * string[start, length] -> new_string or nil - * string[range] -> new_string or nil - * string[regexp, capture = 0] -> new_string or nil - * string[substring] -> new_string or nil + * 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 + * +start+ 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 the substring of +self+ specified by the arguments. - * See examples at {String Slices}[rdoc-ref:String@String+Slices]. + * 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[/(?<vowel>[aeiou])(?<non_vowel>[^aeiou])/, "non_vowel"] #=> "l" + * a[/(?<vowel>[aeiou])(?<non_vowel>[^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]); - } - else { - return rb_str_substr_two_fixnums(str, argv[0], argv[1], TRUE); - } + if (RB_TYPE_P(argv[0], T_REGEXP)) { + return rb_str_subpat(str, argv[0], argv[1]); + } + else { + long beg = NUM2LONG(argv[0]); + long len = NUM2LONG(argv[1]); + return rb_str_substr(str, beg, len); + } } rb_check_arity(argc, 1, 2); return rb_str_aref(str, argv[0]); @@ -5701,79 +4522,69 @@ rb_str_drop_bytes(VALUE str, long len) str_modifiable(str); if (len > olen) len = olen; nlen = olen - len; - if (str_embed_capa(str) >= nlen + TERM_LEN(str)) { - char *oldptr = ptr; - int fl = (int)(RBASIC(str)->flags & (STR_NOEMBED|STR_SHARED|STR_NOFREE)); - STR_SET_EMBED(str); - ptr = RSTRING(str)->as.embed.ary; - memmove(ptr, oldptr + len, nlen); - if (fl == STR_NOEMBED) xfree(oldptr); + if (STR_EMBEDDABLE_P(nlen, TERM_LEN(str))) { + 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)) { - VALUE shared = heap_str_make_shared(rb_obj_class(str), str); - rb_enc_cr_str_exact_copy(shared, str); - OBJ_FREEZE(shared); - } - ptr = RSTRING(str)->as.heap.ptr += len; - } - STR_SET_LEN(str, nlen); - - if (!SHARABLE_MIDDLE_SUBSTRING) { - TERM_FILL(ptr + nlen, TERM_LEN(str)); + 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_update_1(VALUE str, long beg, long len, VALUE val, long vbeg, long vlen) +rb_str_splice_0(VALUE str, long beg, long len, VALUE val) { char *sptr; - long slen; + long slen, vlen = RSTRING_LEN(val); int cr; if (beg == 0 && vlen == 0) { - rb_str_drop_bytes(str, len); - return; + rb_str_drop_bytes(str, len); + OBJ_INFECT(str, val); + return; } str_modify_keep_cr(str); RSTRING_GETMEM(str, sptr, slen); if (len < vlen) { - /* expand string */ - RESIZE_CAPA(str, slen + vlen - len); - sptr = RSTRING_PTR(str); + /* expand string */ + RESIZE_CAPA(str, slen + vlen - len); + sptr = RSTRING_PTR(str); } if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT) - cr = rb_enc_str_coderange(val); + cr = rb_enc_str_coderange(val); else - cr = ENC_CODERANGE_UNKNOWN; + cr = ENC_CODERANGE_UNKNOWN; if (vlen != len) { - memmove(sptr + beg + vlen, - sptr + beg + len, - slen - (beg + len)); + memmove(sptr + beg + vlen, + sptr + beg + len, + slen - (beg + len)); } if (vlen < beg && len < 0) { - MEMZERO(sptr + slen, char, -len); + MEMZERO(sptr + slen, char, -len); } if (vlen > 0) { - memmove(sptr + beg, RSTRING_PTR(val) + vbeg, vlen); + 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); ENC_CODERANGE_SET(str, cr); } -static inline void -rb_str_update_0(VALUE str, long beg, long len, VALUE val) -{ - rb_str_update_1(str, beg, len, val, 0, RSTRING_LEN(val)); -} - void rb_str_update(VALUE str, long beg, long len, VALUE val) { @@ -5789,18 +4600,22 @@ rb_str_update(VALUE str, long beg, long len, VALUE val) enc = rb_enc_check(str, val); slen = str_strlen(str, enc); /* rb_enc_check */ - if ((slen < beg) || ((beg < 0) && (beg + slen < 0))) { - rb_raise(rb_eIndexError, "index %ld out of string", beg); + if (slen < beg) { + out_of_range: + rb_raise(rb_eIndexError, "index %ld out of string", beg); } if (beg < 0) { - beg += slen; + if (beg + slen < 0) { + goto out_of_range; + } + beg += slen; } - RUBY_ASSERT(beg >= 0); - RUBY_ASSERT(beg <= slen); - + assert(beg >= 0); + assert(beg <= slen); if (len > slen - beg) { - len = slen - beg; + 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); @@ -5808,13 +4623,15 @@ rb_str_update(VALUE str, long beg, long len, VALUE val) /* error check */ beg = p - RSTRING_PTR(str); /* physical position */ len = e - p; /* physical length */ - rb_str_update_0(str, beg, len, val); + 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); + 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) { @@ -5825,27 +4642,31 @@ rb_str_subpat_set(VALUE str, VALUE re, VALUE backref, VALUE val) struct re_registers *regs; if (rb_reg_search(re, str, 0, 0) < 0) { - rb_raise(rb_eIndexError, "regexp not matched"); + 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) || ((nth < 0) && (-nth >= regs->num_regs))) { - rb_raise(rb_eIndexError, "index %d out of regexp", nth); + if (nth >= regs->num_regs) { + out_of_range: + rb_raise(rb_eIndexError, "index %d out of regexp", nth); } if (nth < 0) { - nth += regs->num_regs; + 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); + rb_raise(rb_eIndexError, "regexp group %d not matched", nth); } end = END(nth); len = end - start; StringValue(val); enc = rb_enc_check_str(str, val); - rb_str_update_0(str, start, len, val); + rb_str_splice_0(str, start, len, val); rb_enc_associate(str, enc); } @@ -5854,76 +4675,79 @@ 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; + 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_update(str, beg, str_strlen(indx, NULL), val); - return val; - + 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_update(str, beg, len, val); - return val; - } - } - /* FALLTHROUGH */ - - case T_FIXNUM: - idx = NUM2LONG(indx); - rb_str_update(str, idx, 1, val); - return val; + /* 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: - * string[index] = new_string - * string[start, length] = new_string - * string[range] = new_string - * string[regexp, capture = 0] = new_string - * string[substring] = new_string - * - * Replaces all, some, or none of the contents of +self+; returns +new_string+. - * See {String Slices}[rdoc-ref:String@String+Slices]. - * - * A few examples: - * - * s = 'foo' - * s[2] = 'rtune' # => "rtune" - * s # => "fortune" - * s[1, 5] = 'init' # => "init" - * s # => "finite" - * s[3..4] = 'al' # => "al" - * s # => "finale" - * s[/e$/] = 'ly' # => "ly" - * s # => "finally" - * s['lly'] = 'ncial' # => "ncial" - * s # => "financial" + * str[integer] = new_str + * str[integer, integer] = new_str + * str[range] = aString + * str[regexp] = new_str + * str[regexp, integer] = new_str + * str[regexp, name] = new_str + * str[other_str] = new_str * + * Element Assignment---Replaces some or all of the content of <i>str</i>. The + * portion of the string affected is determined using the same criteria as + * <code>String#[]</code>. 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, <code>IndexError</code> is raised. If the regular expression + * form is used, the optional second <code>Integer</code> allows you to specify + * which portion of the match to replace (effectively using the + * <code>MatchData</code> indexing rules. The forms that take an + * <code>Integer</code> will raise an <code>IndexError</code> if the value is + * out of range; the <code>Range</code> form will raise a + * <code>RangeError</code>, and the <code>Regexp</code> and <code>String</code> + * will raise an <code>IndexError</code> 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_update(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]); - } - return argv[2]; + 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]); @@ -5931,20 +4755,19 @@ rb_str_aset_m(int argc, VALUE *argv, VALUE str) /* * call-seq: - * insert(index, other_string) -> self + * str.insert(index, other_str) -> str * - * Inserts the given +other_string+ into +self+; returns +self+. - * - * If the Integer +index+ is positive, inserts +other_string+ at offset +index+: - * - * 'foo'.insert(1, 'bar') # => "fbaroo" - * - * If the Integer +index+ is negative, counts backward from the end of +self+ - * and inserts +other_string+ at offset <tt>index+1</tt> - * (that is, _after_ <tt>self[index]</tt>): - * - * 'foo'.insert(-2, 'bar') # => "fobaro" + * Inserts <i>other_str</i> before the character at the given + * <i>index</i>, modifying <i>str</i>. Negative indices count from the + * end of the string, and insert <em>after</em> the given character. + * The intent is insert <i>aString</i> so that it starts at the given + * <i>index</i>. * + * "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 @@ -5953,121 +4776,51 @@ rb_str_insert(VALUE str, VALUE idx, VALUE str2) long pos = NUM2LONG(idx); if (pos == -1) { - return rb_str_append(str, str2); + return rb_str_append(str, str2); } else if (pos < 0) { - pos++; + pos++; } - rb_str_update(str, pos, 0, str2); + rb_str_splice(str, pos, 0, str2); return str; } /* * call-seq: - * slice!(index) -> new_string or nil - * slice!(start, length) -> new_string or nil - * slice!(range) -> new_string or nil - * slice!(regexp, capture = 0) -> new_string or nil - * slice!(substring) -> new_string or nil - * - * Removes and returns the substring of +self+ specified by the arguments. - * See {String Slices}[rdoc-ref:String@String+Slices]. + * str.slice!(integer) -> new_str or nil + * str.slice!(integer, integer) -> 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 * - * A few examples: + * Deletes the specified portion from <i>str</i>, and returns the portion + * deleted. * - * string = "This is a string" + * 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" - * + * string #=> "thing" */ static VALUE rb_str_slice_bang(int argc, VALUE *argv, VALUE str) { - VALUE result = Qnil; - VALUE indx; - long beg, len = 1; - char *p; + VALUE result; + VALUE buf[3]; + int i; rb_check_arity(argc, 1, 2); - str_modify_keep_cr(str); - indx = argv[0]; - if (RB_TYPE_P(indx, T_REGEXP)) { - if (rb_reg_search(indx, str, 0, 0) < 0) return Qnil; - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - int nth = 0; - if (argc > 1 && (nth = rb_reg_backref_number(match, argv[1])) < 0) { - if ((nth += regs->num_regs) <= 0) return Qnil; - } - else if (nth >= regs->num_regs) return Qnil; - beg = BEG(nth); - len = END(nth) - beg; - goto subseq; - } - else if (argc == 2) { - beg = NUM2LONG(indx); - len = NUM2LONG(argv[1]); - goto num_index; - } - else if (FIXNUM_P(indx)) { - beg = FIX2LONG(indx); - if (!(p = rb_str_subpos(str, beg, &len))) return Qnil; - if (!len) return Qnil; - beg = p - RSTRING_PTR(str); - goto subseq; - } - else if (RB_TYPE_P(indx, T_STRING)) { - beg = rb_str_index(str, indx, 0); - if (beg == -1) return Qnil; - len = RSTRING_LEN(indx); - result = str_duplicate(rb_cString, indx); - goto squash; - } - else { - switch (rb_range_beg_len(indx, &beg, &len, str_strlen(str, NULL), 0)) { - case Qnil: - return Qnil; - case Qfalse: - beg = NUM2LONG(indx); - if (!(p = rb_str_subpos(str, beg, &len))) return Qnil; - if (!len) return Qnil; - beg = p - RSTRING_PTR(str); - goto subseq; - default: - goto num_index; - } + for (i=0; i<argc; i++) { + buf[i] = argv[i]; } - - num_index: - if (!(p = rb_str_subpos(str, beg, &len))) return Qnil; - beg = p - RSTRING_PTR(str); - - subseq: - result = rb_str_new(RSTRING_PTR(str)+beg, len); - rb_enc_cr_str_copy_for_substr(result, str); - - squash: - if (len > 0) { - if (beg == 0) { - rb_str_drop_bytes(str, len); - } - else { - char *sptr = RSTRING_PTR(str); - long slen = RSTRING_LEN(str); - if (beg + len > slen) /* pathological check */ - len = slen - beg; - memmove(sptr + beg, - sptr + beg + len, - slen - (beg + len)); - slen -= len; - STR_SET_LEN(str, slen); - TERM_FILL(&sptr[slen], TERM_LEN(str)); - } + str_modify_keep_cr(str); + result = rb_str_aref_m(argc, buf, str); + if (!NIL_P(result)) { + buf[i] = rb_str_new(0,0); + rb_str_aset_m(argc+1, buf, str); } return result; } @@ -6077,19 +4830,21 @@ get_pat(VALUE pat) { VALUE val; - switch (OBJ_BUILTIN_TYPE(pat)) { + if (SPECIAL_CONST_P(pat)) goto to_string; + switch (BUILTIN_TYPE(pat)) { case T_REGEXP: - return pat; + return pat; case T_STRING: - break; + break; default: - val = rb_check_string_type(pat); - if (NIL_P(val)) { - Check_Type(pat, T_REGEXP); - } - pat = val; + to_string: + val = rb_check_string_type(pat); + if (NIL_P(val)) { + Check_Type(pat, T_REGEXP); + } + pat = val; } return rb_reg_regcomp(pat); @@ -6100,22 +4855,24 @@ get_pat_quoted(VALUE pat, int check) { VALUE val; - switch (OBJ_BUILTIN_TYPE(pat)) { + if (SPECIAL_CONST_P(pat)) goto to_string; + switch (BUILTIN_TYPE(pat)) { case T_REGEXP: - return pat; + return pat; case T_STRING: - break; + break; default: - val = rb_check_string_type(pat); - if (NIL_P(val)) { - Check_Type(pat, T_REGEXP); - } - pat = val; + to_string: + val = rb_check_string_type(pat); + if (NIL_P(val)) { + Check_Type(pat, T_REGEXP); + } + pat = val; } if (check && is_broken_string(pat)) { - rb_exc_raise(rb_reg_check_preprocess(pat)); + rb_exc_raise(rb_reg_check_preprocess(pat)); } return pat; } @@ -6124,36 +4881,36 @@ static long rb_pat_search(VALUE pat, VALUE str, long pos, int set_backref_str) { if (BUILTIN_TYPE(pat) == T_STRING) { - pos = rb_str_byteindex(str, pat, pos); - if (set_backref_str) { - if (pos >= 0) { - str = rb_str_new_frozen_String(str); - rb_backref_set_string(str, pos, RSTRING_LEN(pat)); - } - else { - rb_backref_set(Qnil); - } - } - return pos; + pos = rb_strseq_index(str, pat, pos, 1); + if (set_backref_str) { + if (pos >= 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); + return rb_reg_search0(pat, str, pos, 0, set_backref_str); } } /* * call-seq: - * sub!(pattern, replacement) -> self or nil - * sub!(pattern) {|match| ... } -> self or nil - * - * Replaces the first occurrence (not all occurrences) of the given +pattern+ - * on +self+; returns +self+ if a replacement occurred, +nil+ otherwise. + * str.sub!(pattern, replacement) -> str or nil + * str.sub!(pattern) {|match| block } -> str or nil * - * See {Substitution Methods}[rdoc-ref:String@Substitution+Methods]. - * - * Related: String#sub, String#gsub, String#gsub!. + * 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 @@ -6161,20 +4918,22 @@ 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; + iter = 1; } else { - repl = argv[1]; - hash = rb_check_hash_type(argv[1]); - if (NIL_P(hash)) { - StringValue(repl); - } + repl = argv[1]; + hash = rb_check_hash_type(argv[1]); + if (NIL_P(hash)) { + StringValue(repl); + } + tainted = OBJ_TAINTED_RAW(repl); } pat = get_pat_quoted(argv[0], 1); @@ -6182,29 +4941,29 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str) 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); + 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)); @@ -6213,55 +4972,55 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str) 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); - } + 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) { + 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_inspect_name(str_enc), - rb_enc_inspect_name(STR_ENC_GET(repl))); + 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 (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) { - int cr2 = ENC_CODERANGE(repl); + rb_str_modify(str); + rb_enc_associate(str, enc); + tainted |= OBJ_TAINTED_RAW(repl); + 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; - 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); - } - rp = RSTRING_PTR(repl); - memmove(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); - - RB_GC_GUARD(match); - - return str; + } + plen = end0 - beg0; + 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); + } + rp = RSTRING_PTR(repl); + memmove(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); + FL_SET_RAW(str, tainted); + + return str; } return Qnil; } @@ -6269,22 +5028,50 @@ rb_str_sub_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * sub(pattern, replacement) -> new_string - * sub(pattern) {|match| ... } -> new_string + * 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. <code>'\\\d'</code> will match a backslash + * 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 + * <code>"\\d"</code>, where <i>d</i> is a group number, or + * <code>"\\k<n>"</code>, where <i>n</i> 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 <code>$&</code>, will not refer to the current match. + * If +replacement+ is a String that looks like a pattern's capture group but + * is actually not a pattern capture group e.g. <code>"\\'"</code>, then it + * will have to be preceded by two backslashes like so <code>"\\\\'"</code>. * - * Returns a copy of +self+ with only the first occurrence - * (not all occurrences) of the given +pattern+ replaced. + * If the second argument is a Hash, and the matched text is one of its keys, + * the corresponding value is the replacement string. * - * See {Substitution Methods}[rdoc-ref:String@Substitution+Methods]. + * In the block form, the current match string is passed in as a parameter, + * and variables such as <code>$1</code>, <code>$2</code>, <code>$`</code>, + * <code>$&</code>, and <code>$'</code> will be set appropriately. The value + * returned by the block will be substituted for the match on each call. * - * Related: String#sub!, String#gsub, String#gsub!. + * The result inherits any tainting in the original string or any supplied + * replacement string. * + * "hello".sub(/[aeiou]/, '*') #=> "h*llo" + * "hello".sub(/([aeiou])/, '<\1>') #=> "h<e>llo" + * "hello".sub(/./) {|s| s.ord.to_s + ' ' } #=> "104 ello" + * "hello".sub(/(?<foo>[aeiou])/, '*\k<foo>*') #=> "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 = str_duplicate(rb_cString, str); + str = rb_str_dup(str); rb_str_sub_bang(argc, argv, str); return str; } @@ -6292,38 +5079,41 @@ rb_str_sub(int argc, VALUE *argv, VALUE str) static VALUE str_gsub(int argc, VALUE *argv, VALUE str, int bang) { - VALUE pat, val = Qnil, repl, match0 = Qnil, dest, hash = Qnil; + VALUE pat, val = Qnil, repl, match, match0 = Qnil, dest, hash = Qnil; + struct re_registers *regs; long beg, 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; + 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; - } - break; + repl = argv[1]; + hash = rb_check_hash_type(argv[1]); + if (NIL_P(hash)) { + StringValue(repl); + } + else { + mode = MAP; + } + tainted = OBJ_TAINTED_RAW(repl); + break; default: - rb_error_arity(argc, 1, 2); + 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 str_duplicate(rb_cString, str); + if (bang) return Qnil; /* no match, no substitution */ + return rb_str_dup(str); } offset = 0; @@ -6337,20 +5127,20 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang) ENC_CODERANGE_SET(dest, rb_enc_asciicompat(str_enc) ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID); do { - VALUE match = rb_backref_get(); - struct re_registers *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) { + 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)); } @@ -6358,45 +5148,45 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang) 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; - } - - len = beg0 - offset; /* copy pre-match substr */ + 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; + } + + tainted |= OBJ_TAINTED_RAW(val); + + 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); + 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); - - RB_GC_GUARD(match); + 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); @@ -6406,28 +5196,26 @@ str_gsub(int argc, VALUE *argv, VALUE str, int bang) str_shared_replace(str, dest); } else { - str = dest; + RBASIC_SET_CLASS(dest, rb_obj_class(str)); + tainted |= OBJ_TAINTED_RAW(str); + str = dest; } + FL_SET_RAW(str, tainted); return str; } /* * call-seq: - * gsub!(pattern, replacement) -> self or nil - * gsub!(pattern) {|match| ... } -> self or nil - * gsub!(pattern) -> an_enumerator - * - * Performs the specified substring replacement(s) on +self+; - * returns +self+ if any replacement occurred, +nil+ otherwise. - * - * See {Substitution Methods}[rdoc-ref:String@Substitution+Methods]. - * - * Returns an Enumerator if no +replacement+ and no block given. - * - * Related: String#sub, String#gsub, String#sub!. + * str.gsub!(pattern, replacement) -> str or nil + * str.gsub!(pattern, hash) -> str or nil + * str.gsub!(pattern) {|match| block } -> str or nil + * str.gsub!(pattern) -> an_enumerator * + * Performs the substitutions of <code>String#gsub</code> in place, returning + * <i>str</i>, or <code>nil</code> if no substitutions were performed. + * If no block and no <i>replacement</i> is given, an enumerator is returned instead. */ static VALUE @@ -6440,18 +5228,45 @@ rb_str_gsub_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * gsub(pattern, replacement) -> new_string - * gsub(pattern) {|match| ... } -> new_string - * gsub(pattern) -> enumerator + * 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 <i>str</i> with <em>all</em> occurrences of + * <i>pattern</i> substituted for the second argument. The <i>pattern</i> is + * typically a <code>Regexp</code>; if given as a <code>String</code>, any + * regular expression metacharacters it contains will be interpreted + * literally, e.g. <code>'\\\d'</code> will match a backslash followed by 'd', + * instead of a digit. * - * Returns a copy of +self+ with all occurrences of the given +pattern+ replaced. + * If <i>replacement</i> is a <code>String</code> it will be substituted for + * the matched text. It may contain back-references to the pattern's capture + * groups of the form <code>\\\d</code>, where <i>d</i> is a group number, or + * <code>\\\k<n></code>, where <i>n</i> is a group name. If it is a + * double-quoted string, both back-references must be preceded by an + * additional backslash. However, within <i>replacement</i> the special match + * variables, such as <code>$&</code>, will not refer to the current match. * - * See {Substitution Methods}[rdoc-ref:String@Substitution+Methods]. + * If the second argument is a <code>Hash</code>, and the matched text is one + * of its keys, the corresponding value is the replacement string. * - * Returns an Enumerator if no +replacement+ and no block given. + * In the block form, the current match string is passed in as a parameter, + * and variables such as <code>$1</code>, <code>$2</code>, <code>$`</code>, + * <code>$&</code>, and <code>$'</code> will be set appropriately. The value + * returned by the block will be substituted for the match on each call. * - * Related: String#sub, String#sub!, String#gsub!. + * 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 + * <code>Enumerator</code> is returned. + * + * "hello".gsub(/[aeiou]/, '*') #=> "h*ll*" + * "hello".gsub(/([aeiou])/, '<\1>') #=> "h<e>ll<o>" + * "hello".gsub(/./) {|s| s.ord.to_s + ' '} #=> "104 101 108 108 111 " + * "hello".gsub(/(?<foo>[aeiou])/, '{\k<foo>}') #=> "h{e}ll{o}" + * 'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*') #=> "h3ll*" */ static VALUE @@ -6463,13 +5278,13 @@ rb_str_gsub(int argc, VALUE *argv, VALUE str) /* * call-seq: - * replace(other_string) -> self - * - * Replaces the contents of +self+ with the contents of +other_string+: + * str.replace(other_str) -> str * - * s = 'foo' # => "foo" - * s.replace('bar') # => "bar" + * Replaces the contents and taintedness of <i>str</i> with the corresponding + * values in <i>other_str</i>. * + * s = "hello" #=> "hello" + * s.replace "world" #=> "world" */ VALUE @@ -6485,13 +5300,12 @@ rb_str_replace(VALUE str, VALUE str2) /* * call-seq: - * clear -> self + * string.clear -> string * - * Removes the contents of +self+: - * - * s = 'foo' # => "foo" - * s.clear # => "" + * Makes string empty. * + * a = "abcde" + * a.clear #=> "" */ static VALUE @@ -6499,24 +5313,23 @@ rb_str_clear(VALUE str) { str_discard(str); STR_SET_EMBED(str); - STR_SET_LEN(str, 0); + 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); + ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); else - ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); + ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); return str; } /* * call-seq: - * chr -> string + * string.chr -> string * - * Returns a string containing the first character of +self+: - * - * s = 'foo' # => "foo" - * s.chr # => "f" + * Returns a one-character string at the beginning of the string. * + * a = "abcde" + * a.chr #=> "a" */ static VALUE @@ -6527,18 +5340,11 @@ rb_str_chr(VALUE str) /* * call-seq: - * getbyte(index) -> integer or nil - * - * Returns the byte at zero-based +index+ as an integer, or +nil+ if +index+ is out of range: + * str.getbyte(index) -> 0 .. 255 * - * s = 'abcde' # => "abcde" - * s.getbyte(0) # => 97 - * s.getbyte(-1) # => 101 - * s.getbyte(5) # => nil - * - * Related: String#setbyte. + * returns the <i>index</i>th byte as an integer. */ -VALUE +static VALUE rb_str_getbyte(VALUE str, VALUE index) { long pos = NUM2LONG(index); @@ -6553,22 +5359,17 @@ rb_str_getbyte(VALUE str, VALUE index) /* * call-seq: - * setbyte(index, integer) -> integer - * - * Sets the byte at zero-based +index+ to +integer+; returns +integer+: + * str.setbyte(index, integer) -> integer * - * s = 'abcde' # => "abcde" - * s.setbyte(0, 98) # => 98 - * s # => "bbcde" - * - * Related: String#getbyte. + * modifies the <i>index</i>th byte as <i>integer</i>. */ -VALUE +static VALUE rb_str_setbyte(VALUE str, VALUE index, VALUE value) { long pos = NUM2LONG(index); + int byte = NUM2INT(value); long len = RSTRING_LEN(str); - char *ptr, *head, *left = 0; + char *head, *ptr, *left = 0; rb_encoding *enc; int cr = ENC_CODERANGE_UNKNOWN, width, nlen; @@ -6577,39 +5378,35 @@ rb_str_setbyte(VALUE str, VALUE index, VALUE value) if (pos < 0) pos += len; - VALUE v = rb_to_int(value); - VALUE w = rb_int_and(v, INT2FIX(0xff)); - char byte = (char)(NUM2INT(w) & 0xFF); - if (!str_independent(str)) - str_make_independent(str); + str_make_independent(str); enc = STR_ENC_GET(str); head = RSTRING_PTR(str); ptr = &head[pos]; if (!STR_EMBED_P(str)) { - cr = ENC_CODERANGE(str); - switch (cr) { - case ENC_CODERANGE_7BIT: - left = ptr; - *ptr = byte; - if (ISASCII(byte)) goto end; - nlen = rb_enc_precise_mbclen(left, head+len, enc); - if (!MBCLEN_CHARFOUND_P(nlen)) - ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN); - else - ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); - goto end; - case ENC_CODERANGE_VALID: - left = rb_enc_left_char_head(head, ptr, head+len, enc); - width = rb_enc_precise_mbclen(left, head+len, enc); - *ptr = byte; - nlen = rb_enc_precise_mbclen(left, head+len, enc); - if (!MBCLEN_CHARFOUND_P(nlen)) - ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN); - else if (MBCLEN_CHARFOUND_LEN(nlen) != width || ISASCII(byte)) - ENC_CODERANGE_CLEAR(str); - goto end; - } + cr = ENC_CODERANGE(str); + switch (cr) { + case ENC_CODERANGE_7BIT: + left = ptr; + *ptr = byte; + if (ISASCII(byte)) goto end; + nlen = rb_enc_precise_mbclen(left, head+len, enc); + if (!MBCLEN_CHARFOUND_P(nlen)) + ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN); + else + ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); + goto end; + case ENC_CODERANGE_VALID: + left = rb_enc_left_char_head(head, ptr, head+len, enc); + width = rb_enc_precise_mbclen(left, head+len, enc); + *ptr = byte; + nlen = rb_enc_precise_mbclen(left, head+len, enc); + if (!MBCLEN_CHARFOUND_P(nlen)) + ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN); + else if (MBCLEN_CHARFOUND_LEN(nlen) != width || ISASCII(byte)) + ENC_CODERANGE_CLEAR(str); + goto end; + } } ENC_CODERANGE_CLEAR(str); *ptr = byte; @@ -6621,48 +5418,57 @@ rb_str_setbyte(VALUE str, VALUE index, VALUE value) static VALUE str_byte_substr(VALUE str, long beg, long len, int empty) { + 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; + beg += n; + if (beg < 0) return Qnil; } if (len > n - beg) - len = n - beg; + len = n - beg; if (len <= 0) { - if (!empty) return Qnil; - len = 0; + if (!empty) return Qnil; + len = 0; + p = 0; } + else + p = s + beg; - VALUE str2 = str_subseq(str, beg, len); + if (!STR_EMBEDDABLE_P(len, TERM_LEN(str)) && 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_direct(str2, str); + 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); + 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; - } + 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; + } } - return str2; -} + OBJ_INFECT_RAW(str2, str); -VALUE -rb_str_byte_substr(VALUE str, VALUE beg, VALUE len) -{ - return str_byte_substr(str, NUM2LONG(beg), NUM2LONG(len), TRUE); + return str2; } static VALUE @@ -6670,195 +5476,68 @@ str_byte_aref(VALUE str, VALUE indx) { long idx; if (FIXNUM_P(indx)) { - idx = FIX2LONG(indx); + idx = FIX2LONG(indx); } else { - /* check if indx is Range */ - long beg, len = RSTRING_LEN(str); + /* 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, TRUE); - } + 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, TRUE); + } - idx = NUM2LONG(indx); + idx = NUM2LONG(indx); } return str_byte_substr(str, idx, 1, FALSE); } /* * call-seq: - * byteslice(index, length = 1) -> string or nil - * byteslice(range) -> string or nil - * - * Returns a substring of +self+, or +nil+ if the substring cannot be constructed. - * - * With integer arguments +index+ and +length+ given, - * returns the substring beginning at the given +index+ - * of the given +length+ (if possible), - * or +nil+ if +length+ is negative or +index+ falls outside of +self+: - * - * s = '0123456789' # => "0123456789" - * s.byteslice(2) # => "2" - * s.byteslice(200) # => nil - * s.byteslice(4, 3) # => "456" - * s.byteslice(4, 30) # => "456789" - * s.byteslice(4, -1) # => nil - * s.byteslice(40, 2) # => nil - * - * In either case above, counts backwards from the end of +self+ - * if +index+ is negative: - * - * s = '0123456789' # => "0123456789" - * s.byteslice(-4) # => "6" - * s.byteslice(-4, 3) # => "678" - * - * With Range argument +range+ given, returns - * <tt>byteslice(range.begin, range.size)</tt>: - * - * s = '0123456789' # => "0123456789" - * s.byteslice(4..6) # => "456" - * s.byteslice(-6..-4) # => "456" - * s.byteslice(5..2) # => "" # range.size is zero. - * s.byteslice(40..42) # => nil + * str.byteslice(integer) -> new_str or nil + * str.byteslice(integer, integer) -> new_str or nil + * str.byteslice(range) -> new_str or nil * - * In all cases, a returned string has the same encoding as +self+: - * - * s.encoding # => #<Encoding:UTF-8> - * s.byteslice(4).encoding # => #<Encoding:UTF-8> + * Byte Reference---If passed a single <code>Integer</code>, returns a + * substring of one byte at that position. If passed two <code>Integer</code> + * objects, returns a substring starting at the offset given by the first, and + * a length given by the second. If given a <code>Range</code>, 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 <i>str</i>. Returns + * <code>nil</code> 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) { - long beg = NUM2LONG(argv[0]); - long len = NUM2LONG(argv[1]); - return str_byte_substr(str, beg, len, TRUE); + long beg = NUM2LONG(argv[0]); + long end = NUM2LONG(argv[1]); + return str_byte_substr(str, beg, end, TRUE); } rb_check_arity(argc, 1, 2); return str_byte_aref(str, argv[0]); } -static void -str_check_beg_len(VALUE str, long *beg, long *len) -{ - long end, slen = RSTRING_LEN(str); - - if (*len < 0) rb_raise(rb_eIndexError, "negative length %ld", *len); - if ((slen < *beg) || ((*beg < 0) && (*beg + slen < 0))) { - rb_raise(rb_eIndexError, "index %ld out of string", *beg); - } - if (*beg < 0) { - *beg += slen; - } - RUBY_ASSERT(*beg >= 0); - RUBY_ASSERT(*beg <= slen); - - if (*len > slen - *beg) { - *len = slen - *beg; - } - end = *beg + *len; - str_ensure_byte_pos(str, *beg); - str_ensure_byte_pos(str, end); -} - -/* - * call-seq: - * bytesplice(index, length, str) -> string - * bytesplice(index, length, str, str_index, str_length) -> string - * bytesplice(range, str) -> string - * bytesplice(range, str, str_range) -> string - * - * Replaces some or all of the content of +self+ with +str+, and returns +self+. - * The portion of the string affected is determined using - * the same criteria as String#byteslice, except that +length+ cannot be omitted. - * If the replacement string is not the same length as the text it is replacing, - * the string will be adjusted accordingly. - * - * If +str_index+ and +str_length+, or +str_range+ are given, the content of +self+ is replaced by str.byteslice(str_index, str_length) or str.byteslice(str_range); however the substring of +str+ is not allocated as a new string. - * - * The form that take an Integer will raise an IndexError if the value is out - * of range; the Range form will raise a RangeError. - * If the beginning or ending offset does not land on character (codepoint) - * boundary, an IndexError will be raised. - */ - -static VALUE -rb_str_bytesplice(int argc, VALUE *argv, VALUE str) -{ - long beg, len, vbeg, vlen; - VALUE val; - int cr; - - rb_check_arity(argc, 2, 5); - if (!(argc == 2 || argc == 3 || argc == 5)) { - rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2, 3, or 5)", argc); - } - if (argc == 2 || (argc == 3 && !RB_INTEGER_TYPE_P(argv[0]))) { - if (!rb_range_beg_len(argv[0], &beg, &len, RSTRING_LEN(str), 2)) { - rb_raise(rb_eTypeError, "wrong argument type %s (expected Range)", - rb_builtin_class_name(argv[0])); - } - val = argv[1]; - StringValue(val); - if (argc == 2) { - /* bytesplice(range, str) */ - vbeg = 0; - vlen = RSTRING_LEN(val); - } - else { - /* bytesplice(range, str, str_range) */ - if (!rb_range_beg_len(argv[2], &vbeg, &vlen, RSTRING_LEN(val), 2)) { - rb_raise(rb_eTypeError, "wrong argument type %s (expected Range)", - rb_builtin_class_name(argv[2])); - } - } - } - else { - beg = NUM2LONG(argv[0]); - len = NUM2LONG(argv[1]); - val = argv[2]; - StringValue(val); - if (argc == 3) { - /* bytesplice(index, length, str) */ - vbeg = 0; - vlen = RSTRING_LEN(val); - } - else { - /* bytesplice(index, length, str, str_index, str_length) */ - vbeg = NUM2LONG(argv[3]); - vlen = NUM2LONG(argv[4]); - } - } - str_check_beg_len(str, &beg, &len); - str_check_beg_len(val, &vbeg, &vlen); - str_modify_keep_cr(str); - - if (RB_UNLIKELY(ENCODING_GET_INLINED(str) != ENCODING_GET_INLINED(val))) { - rb_enc_associate(str, rb_enc_check(str, val)); - } - - rb_str_update_1(str, beg, len, val, vbeg, vlen); - cr = ENC_CODERANGE_AND(ENC_CODERANGE(str), ENC_CODERANGE(val)); - if (cr != ENC_CODERANGE_BROKEN) - ENC_CODERANGE_SET(str, cr); - return str; -} - /* * call-seq: - * reverse -> string - * - * Returns a new string with the characters from +self+ in reverse order. + * str.reverse -> new_str * - * 'stressed'.reverse # => "desserts" + * Returns a new string with the characters from <i>str</i> in reverse order. * + * "stressed".reverse #=> "desserts" */ static VALUE @@ -6869,43 +5548,44 @@ rb_str_reverse(VALUE str) char *s, *e, *p; int cr; - if (RSTRING_LEN(str) <= 1) return str_duplicate(rb_cString, str); + if (RSTRING_LEN(str) <= 1) return rb_str_dup(str); enc = STR_ENC_GET(str); - rev = rb_str_new(0, RSTRING_LEN(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; - } - } + 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)); - str_enc_copy_direct(rev, str); + OBJ_INFECT_RAW(rev, str); + str_enc_copy(rev, str); ENC_CODERANGE_SET(rev, cr); return rev; @@ -6914,38 +5594,33 @@ rb_str_reverse(VALUE str) /* * call-seq: - * reverse! -> self - * - * Returns +self+ with its characters reversed: - * - * s = 'stressed' - * s.reverse! # => "desserts" - * s # => "desserts" + * str.reverse! -> str * + * Reverses <i>str</i> 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 { - str_shared_replace(str, rb_str_reverse(str)); - } + 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 { + str_shared_replace(str, rb_str_reverse(str)); + } } else { - str_modify_keep_cr(str); + str_modify_keep_cr(str); } return str; } @@ -6953,18 +5628,17 @@ rb_str_reverse_bang(VALUE str) /* * call-seq: - * include?(other_string) -> true or false - * - * Returns +true+ if +self+ contains +other_string+, +false+ otherwise: + * str.include? other_str -> true or false * - * s = 'foo' - * s.include?('f') # => true - * s.include?('fo') # => true - * s.include?('food') # => false + * Returns <code>true</code> if <i>str</i> contains the given string or + * character. * + * "hello".include? "lo" #=> true + * "hello".include? "ol" #=> false + * "hello".include? ?h #=> true */ -VALUE +static VALUE rb_str_include(VALUE str, VALUE arg) { long i; @@ -6972,49 +5646,46 @@ rb_str_include(VALUE str, VALUE arg) StringValue(arg); i = rb_str_index(str, arg, 0); - return RBOOL(i != -1); + if (i == -1) return Qfalse; + return Qtrue; } /* * call-seq: - * to_i(base = 10) -> integer - * - * Returns the result of interpreting leading characters in +self+ - * as an integer in the given +base+ (which must be in (0, 2..36)): - * - * '123456'.to_i # => 123456 - * '123def'.to_i(16) # => 1195503 - * - * With +base+ zero, string +object+ may contain leading characters - * to specify the actual base: - * - * '123def'.to_i(0) # => 123 - * '0123def'.to_i(0) # => 83 - * '0b123def'.to_i(0) # => 1 - * '0o123def'.to_i(0) # => 83 - * '0d123def'.to_i(0) # => 123 - * '0x123def'.to_i(0) # => 1195503 - * - * Characters past a leading valid number (in the given +base+) are ignored: - * - * '12.345'.to_i # => 12 - * '12345'.to_i(2) # => 1 - * - * Returns zero if there is no leading valid number: + * str.to_i(base=10) -> integer * - * 'abcdef'.to_i # => 0 - * '2'.to_i(2) # => 0 + * Returns the result of interpreting leading characters in <i>str</i> as an + * integer base <i>base</i> (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 <i>str</i>, <code>0</code> is returned. This method never raises an + * exception when <i>base</i> 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 = 10; + int base; - if (rb_check_arity(argc, 0, 1) && (base = NUM2INT(argv[0])) < 0) { - rb_raise(rb_eArgError, "invalid radix %d", 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); } @@ -7022,21 +5693,16 @@ rb_str_to_i(int argc, VALUE *argv, VALUE str) /* * call-seq: - * to_f -> float - * - * Returns the result of interpreting leading characters in +self+ as a Float: - * - * '3.14159'.to_f # => 3.14159 - * '1.234e-2'.to_f # => 0.01234 - * - * Characters past a leading valid number (in the given +base+) are ignored: - * - * '3.14 (pi to two places)'.to_f # => 3.14 - * - * Returns zero if there is no leading valid number: + * str.to_f -> float * - * 'abcdef'.to_f # => 0.0 + * Returns the result of interpreting leading characters in <i>str</i> 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 <i>str</i>, + * <code>0.0</code> 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 @@ -7048,17 +5714,19 @@ rb_str_to_f(VALUE str) /* * call-seq: - * to_s -> self or string + * str.to_s -> str + * str.to_str -> str * - * Returns +self+ if +self+ is a +String+, - * or +self+ converted to a +String+ if +self+ is a subclass of +String+. + * Returns +self+. + * + * If called on a subclass of String, converts the receiver to a String object. */ static VALUE rb_str_to_s(VALUE str) { if (rb_obj_class(str) != rb_cString) { - return str_duplicate(rb_cString, str); + return str_duplicate(rb_cString, str); } return str; } @@ -7087,47 +5755,29 @@ rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p) 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); - } + 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); - } + 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; } -const char * -ruby_escaped_char(int c) -{ - switch (c) { - case '\0': return "\\0"; - case '\n': return "\\n"; - case '\r': return "\\r"; - case '\t': return "\\t"; - case '\f': return "\\f"; - case '\013': return "\\v"; - case '\010': return "\\b"; - case '\007': return "\\a"; - case '\033': return "\\e"; - case '\x7f': return "\\c?"; - } - return NULL; -} - VALUE rb_str_escape(VALUE str) { @@ -7142,11 +5792,10 @@ rb_str_escape(VALUE str) int asciicompat = rb_enc_asciicompat(enc); while (p < pend) { - unsigned int c; - const char *cc; - int n = rb_enc_precise_mbclen(p, pend, enc); + unsigned int c, cc; + int n = rb_enc_precise_mbclen(p, pend, enc); if (!MBCLEN_CHARFOUND_P(n)) { - if (p > prev) str_buf_cat(result, prev, p - prev); + if (p > prev) str_buf_cat(result, prev, p - prev); n = rb_enc_mbminlen(enc); if (pend < p + n) n = (int)(pend - p); @@ -7155,49 +5804,61 @@ rb_str_escape(VALUE str) str_buf_cat(result, buf, strlen(buf)); prev = ++p; } - continue; - } + continue; + } n = MBCLEN_CHARFOUND_LEN(n); - c = rb_enc_mbc_to_codepoint(p, pend, enc); - p += n; - cc = ruby_escaped_char(c); - if (cc) { - if (p - n > prev) str_buf_cat(result, prev, p - n - prev); - str_buf_cat(result, cc, strlen(cc)); - prev = p; - } - else if (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c)) { - } - 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; - } + c = rb_enc_mbc_to_codepoint(p, pend, enc); + p += n; + 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; + } + else if (asciicompat && rb_enc_isascii(c, enc) && ISPRINT(c)) { + } + 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; + } } if (p > prev) str_buf_cat(result, prev, p - prev); ENCODING_CODERANGE_SET(result, rb_usascii_encindex(), ENC_CODERANGE_7BIT); + OBJ_INFECT_RAW(result, str); return result; } /* - * call-seq: - * inspect -> string - * - * Returns a printable version of +self+, enclosed in double-quotes, - * and with special characters escaped: + * call-seq: + * str.inspect -> string * - * s = "foo\tbar\tbaz\n" - * s.inspect - * # => "\"foo\\tbar\\tbaz\\n\"" + * 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); + 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); @@ -7212,13 +5873,18 @@ rb_str_inspect(VALUE str) 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; + 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); + if (p > prev) str_buf_cat(result, prev, p - prev); n = rb_enc_mbminlen(enc); if (pend < p + n) n = (int)(pend - p); @@ -7227,66 +5893,59 @@ rb_str_inspect(VALUE str) str_buf_cat(result, buf, strlen(buf)); prev = ++p; } - continue; - } + continue; + } n = MBCLEN_CHARFOUND_LEN(n); - c = rb_enc_mbc_to_codepoint(p, pend, enc); - p += n; - if ((asciicompat || unicode_p) && - (c == '"'|| c == '\\' || - (c == '#' && + 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; - } - /* The special casing of 0x85 (NEXT_LINE) here is because - * Oniguruma historically treats it as printable, but it - * doesn't match the print POSIX bracket class or character - * property in regexps. - * - * See Ruby Bug #16842 for details: - * https://bugs.ruby-lang.org/issues/16842 - */ - if ((enc == resenc && rb_enc_isprint(c, enc) && c != 0x85) || - (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 - 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_RAW(result, str); return result; } @@ -7294,17 +5953,12 @@ rb_str_inspect(VALUE str) /* * call-seq: - * dump -> string - * - * Returns a printable version of +self+, enclosed in double-quotes, - * with special characters escaped, and with non-printing characters - * replaced by hexadecimal notation: + * str.dump -> new_str * - * "hello \n ''".dump # => "\"hello \\n ''\"" - * "\f\x00\xff\\\"".dump # => "\"\\f\\x00\\xFF\\\\\\\"\"" - * - * Related: String#undump (inverse of String#dump). + * Produces a version of +str+ with all non-printing characters replaced by + * <code>\nnn</code> notation and all special characters escaped. * + * "hello \n ''".dump #=> "\"hello \\n ''\"" */ VALUE @@ -7317,137 +5971,138 @@ rb_str_dump(VALUE str) char *q, *qend; VALUE result; int u8 = (encidx == rb_utf8_encindex()); - static const char nonascii_suffix[] = ".dup.force_encoding(\"%s\")"; + static const char nonascii_suffix[] = ".force_encoding(\"%s\")"; len = 2; /* "" */ if (!rb_enc_asciicompat(enc)) { - len += strlen(nonascii_suffix) - rb_strlen_lit("%s"); - len += strlen(enc->name); + len += strlen(nonascii_suffix) - rb_strlen_lit("%s"); + len += strlen(enc->name); } p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); while (p < pend) { - int clen; - unsigned char c = *p++; - - switch (c) { - case '"': case '\\': - case '\n': case '\r': - case '\t': case '\f': - case '\013': case '\010': case '\007': case '\033': - clen = 2; - break; - - case '#': - clen = IS_EVSTR(p, pend) ? 2 : 1; - break; - - default: - if (ISPRINT(c)) { - clen = 1; - } - else { - if (u8 && c > 0x7F) { /* \u notation */ - 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); - if (cc <= 0xFFFF) - clen = 6; /* \uXXXX */ - else if (cc <= 0xFFFFF) - clen = 9; /* \u{XXXXX} */ - else - clen = 10; /* \u{XXXXXX} */ - p += MBCLEN_CHARFOUND_LEN(n)-1; - break; - } - } - clen = 4; /* \xNN */ - } - break; - } - - if (clen > LONG_MAX - len) { - rb_raise(rb_eRuntimeError, "string size too big"); - } - len += clen; - } - - result = rb_str_new(0, len); + int clen; + unsigned char c = *p++; + + switch (c) { + case '"': case '\\': + case '\n': case '\r': + case '\t': case '\f': + case '\013': case '\010': case '\007': case '\033': + clen = 2; + break; + + case '#': + clen = IS_EVSTR(p, pend) ? 2 : 1; + break; + + default: + if (ISPRINT(c)) { + clen = 1; + } + else { + if (u8 && c > 0x7F) { /* \u notation */ + 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); + if (cc <= 0xFFFF) + clen = 6; /* \uXXXX */ + else if (cc <= 0xFFFFF) + clen = 9; /* \u{XXXXX} */ + else + clen = 10; /* \u{XXXXXX} */ + p += MBCLEN_CHARFOUND_LEN(n)-1; + break; + } + } + clen = 4; /* \xNN */ + } + break; + } + + if (clen > LONG_MAX - len) { + rb_raise(rb_eRuntimeError, "string size too big"); + } + len += clen; + } + + 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; - if (cc <= 0xFFFF) - snprintf(q, qend-q, "u%04X", cc); /* \uXXXX */ - else - snprintf(q, qend-q, "u{%X}", cc); /* \u{XXXXX} or \u{XXXXXX} */ - q += strlen(q); - continue; - } - } - snprintf(q, qend-q, "x%02X", c); - q += 3; - } + 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; + if (cc <= 0xFFFF) + snprintf(q, qend-q, "u%04X", cc); /* \uXXXX */ + else + snprintf(q, qend-q, "u{%X}", cc); /* \u{XXXXX} or \u{XXXXXX} */ + 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, nonascii_suffix, enc->name); - encidx = rb_ascii8bit_encindex(); + snprintf(q, qend-q, nonascii_suffix, enc->name); + encidx = rb_ascii8bit_encindex(); } + OBJ_INFECT_RAW(result, str); /* result from dump is ASCII */ rb_enc_associate_index(result, encidx); ENC_CODERANGE_SET(result, ENC_CODERANGE_7BIT); @@ -7459,23 +6114,24 @@ unescape_ascii(unsigned int c) { switch (c) { case 'n': - return '\n'; + return '\n'; case 'r': - return '\r'; + return '\r'; case 't': - return '\t'; + return '\t'; case 'f': - return '\f'; + return '\f'; case 'v': - return '\13'; + return '\13'; case 'b': - return '\010'; + return '\010'; case 'a': - return '\007'; + return '\007'; case 'e': - return 033; + return 033; + default: + UNREACHABLE; } - UNREACHABLE_RETURN(-1); } static void @@ -7485,16 +6141,16 @@ undump_after_backslash(VALUE undumped, const char **ss, const char *s_end, rb_en unsigned int c; int codelen; size_t hexlen; - unsigned char buf[6]; + char buf[6]; static rb_encoding *enc_utf8 = NULL; switch (*s) { case '\\': case '"': case '#': - rb_str_cat(undumped, s, 1); /* cat itself */ - s++; - break; + rb_str_cat(undumped, s, 1); /* cat itself */ + s++; + break; case 'n': case 'r': case 't': @@ -7503,83 +6159,83 @@ undump_after_backslash(VALUE undumped, const char **ss, const char *s_end, rb_en case 'b': case 'a': case 'e': - *buf = unescape_ascii(*s); - rb_str_cat(undumped, (char *)buf, 1); - s++; - break; + *buf = (char)unescape_ascii(*s); + rb_str_cat(undumped, buf, 1); + s++; + break; case 'u': - if (*binary) { - rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed"); - } - *utf8 = true; - if (++s >= s_end) { - rb_raise(rb_eRuntimeError, "invalid Unicode escape"); - } - if (enc_utf8 == NULL) enc_utf8 = rb_utf8_encoding(); - if (*penc != enc_utf8) { - *penc = enc_utf8; - rb_enc_associate(undumped, enc_utf8); - } - if (*s == '{') { /* handle \u{...} form */ - s++; - for (;;) { - if (s >= s_end) { - rb_raise(rb_eRuntimeError, "unterminated Unicode escape"); - } - if (*s == '}') { - s++; - break; - } - if (ISSPACE(*s)) { - s++; - continue; - } - c = scan_hex(s, s_end-s, &hexlen); - if (hexlen == 0 || hexlen > 6) { - rb_raise(rb_eRuntimeError, "invalid Unicode escape"); - } - if (c > 0x10ffff) { - rb_raise(rb_eRuntimeError, "invalid Unicode codepoint (too large)"); - } - if (0xd800 <= c && c <= 0xdfff) { - rb_raise(rb_eRuntimeError, "invalid Unicode codepoint"); - } - codelen = rb_enc_mbcput(c, (char *)buf, *penc); - rb_str_cat(undumped, (char *)buf, codelen); - s += hexlen; - } - } - else { /* handle \uXXXX form */ - c = scan_hex(s, 4, &hexlen); - if (hexlen != 4) { - rb_raise(rb_eRuntimeError, "invalid Unicode escape"); - } - if (0xd800 <= c && c <= 0xdfff) { - rb_raise(rb_eRuntimeError, "invalid Unicode codepoint"); - } - codelen = rb_enc_mbcput(c, (char *)buf, *penc); - rb_str_cat(undumped, (char *)buf, codelen); - s += hexlen; - } - break; + if (*binary) { + rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed"); + } + *utf8 = true; + if (++s >= s_end) { + rb_raise(rb_eRuntimeError, "invalid Unicode escape"); + } + if (enc_utf8 == NULL) enc_utf8 = rb_utf8_encoding(); + if (*penc != enc_utf8) { + *penc = enc_utf8; + rb_enc_associate(undumped, enc_utf8); + } + if (*s == '{') { /* handle \u{...} form */ + s++; + for (;;) { + if (s >= s_end) { + rb_raise(rb_eRuntimeError, "unterminated Unicode escape"); + } + if (*s == '}') { + s++; + break; + } + if (ISSPACE(*s)) { + s++; + continue; + } + c = scan_hex(s, s_end-s, &hexlen); + if (hexlen == 0 || hexlen > 6) { + rb_raise(rb_eRuntimeError, "invalid Unicode escape"); + } + if (c > 0x10ffff) { + rb_raise(rb_eRuntimeError, "invalid Unicode codepoint (too large)"); + } + if (0xd800 <= c && c <= 0xdfff) { + rb_raise(rb_eRuntimeError, "invalid Unicode codepoint"); + } + codelen = rb_enc_mbcput(c, buf, *penc); + rb_str_cat(undumped, buf, codelen); + s += hexlen; + } + } + else { /* handle \uXXXX form */ + c = scan_hex(s, 4, &hexlen); + if (hexlen != 4) { + rb_raise(rb_eRuntimeError, "invalid Unicode escape"); + } + if (0xd800 <= c && c <= 0xdfff) { + rb_raise(rb_eRuntimeError, "invalid Unicode codepoint"); + } + codelen = rb_enc_mbcput(c, buf, *penc); + rb_str_cat(undumped, buf, codelen); + s += hexlen; + } + break; case 'x': - if (*utf8) { - rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed"); - } - *binary = true; - if (++s >= s_end) { - rb_raise(rb_eRuntimeError, "invalid hex escape"); - } - *buf = scan_hex(s, 2, &hexlen); - if (hexlen != 2) { - rb_raise(rb_eRuntimeError, "invalid hex escape"); - } - rb_str_cat(undumped, (char *)buf, 1); - s += hexlen; - break; + if (*utf8) { + rb_raise(rb_eRuntimeError, "hex escape and Unicode escape are mixed"); + } + *binary = true; + if (++s >= s_end) { + rb_raise(rb_eRuntimeError, "invalid hex escape"); + } + *buf = scan_hex(s, 2, &hexlen); + if (hexlen != 2) { + rb_raise(rb_eRuntimeError, "invalid hex escape"); + } + rb_str_cat(undumped, buf, 1); + s += hexlen; + break; default: - rb_str_cat(undumped, s-1, 2); - s++; + rb_str_cat(undumped, s-1, 2); + s++; } *ss = s; @@ -7589,17 +6245,12 @@ static VALUE rb_str_is_ascii_only_p(VALUE str); /* * call-seq: - * undump -> string - * - * Returns an unescaped version of +self+: + * str.undump -> new_str * - * s_orig = "\f\x00\xff\\\"" # => "\f\u0000\xFF\\\"" - * s_dumped = s_orig.dump # => "\"\\f\\x00\\xFF\\\\\\\"\"" - * s_undumped = s_dumped.undump # => "\f\u0000\xFF\\\"" - * s_undumped == s_orig # => true - * - * Related: String#dump (inverse of String#undump). + * Produces unescaped version of +str+. + * See also String#dump because String#undump does inverse of String#dump. * + * "\"hello \\n ''\"".undump #=> "hello \n ''" */ static VALUE @@ -7615,10 +6266,10 @@ str_undump(VALUE str) rb_must_asciicompat(str); if (rb_str_is_ascii_only_p(str) == Qfalse) { - rb_raise(rb_eRuntimeError, "non-ASCII character detected"); + rb_raise(rb_eRuntimeError, "non-ASCII character detected"); } if (!str_null_check(str, &w)) { - rb_raise(rb_eRuntimeError, "string contains null byte"); + rb_raise(rb_eRuntimeError, "string contains null byte"); } if (RSTRING_LEN(str) < 2) goto invalid_format; if (*s != '"') goto invalid_format; @@ -7627,67 +6278,60 @@ str_undump(VALUE str) s++; for (;;) { - if (s >= s_end) { - rb_raise(rb_eRuntimeError, "unterminated dumped string"); - } - - if (*s == '"') { - /* epilogue */ - s++; - if (s == s_end) { - /* ascii compatible dumped string */ - break; - } - else { - static const char force_encoding_suffix[] = ".force_encoding(\""; /* "\")" */ - static const char dup_suffix[] = ".dup"; - const char *encname; - int encidx; - ptrdiff_t size; - - /* check separately for strings dumped by older versions */ - size = sizeof(dup_suffix) - 1; - if (s_end - s > size && memcmp(s, dup_suffix, size) == 0) s += size; - - size = sizeof(force_encoding_suffix) - 1; - if (s_end - s <= size) goto invalid_format; - if (memcmp(s, force_encoding_suffix, size) != 0) goto invalid_format; - s += size; - - if (utf8) { - rb_raise(rb_eRuntimeError, "dumped string contained Unicode escape but used force_encoding"); - } - - encname = s; - s = memchr(s, '"', s_end-s); - size = s - encname; - if (!s) goto invalid_format; - if (s_end - s != 2) goto invalid_format; - if (s[0] != '"' || s[1] != ')') goto invalid_format; - - encidx = rb_enc_find_index2(encname, (long)size); - if (encidx < 0) { - rb_raise(rb_eRuntimeError, "dumped string has unknown encoding name"); - } - rb_enc_associate_index(undumped, encidx); - } - break; - } - - if (*s == '\\') { - s++; - if (s >= s_end) { - rb_raise(rb_eRuntimeError, "invalid escape"); - } - undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary); - } - else { - rb_str_cat(undumped, s++, 1); - } - } - - RB_GC_GUARD(str); - + if (s >= s_end) { + rb_raise(rb_eRuntimeError, "unterminated dumped string"); + } + + if (*s == '"') { + /* epilogue */ + s++; + if (s == s_end) { + /* ascii compatible dumped string */ + break; + } + else { + const char *encname; + int encidx; + ptrdiff_t size; + + if (utf8) { + rb_raise(rb_eRuntimeError, "dumped string contained Unicode escape but used force_encoding"); + } + + size = rb_strlen_lit(".force_encoding(\""); + if (s_end - s <= size) goto invalid_format; + if (memcmp(s, ".force_encoding(\"", size) != 0) goto invalid_format; + s += size; + + encname = s; + s = memchr(s, '"', s_end-s); + size = s - encname; + if (!s) goto invalid_format; + if (s_end - s != 2) goto invalid_format; + if (s[0] != '"' || s[1] != ')') goto invalid_format; + + encidx = rb_enc_find_index2(encname, (long)size); + if (encidx < 0) { + rb_raise(rb_eRuntimeError, "dumped string has unknown encoding name"); + } + rb_enc_associate_index(undumped, encidx); + } + break; + } + + if (*s == '\\') { + s++; + if (s >= s_end) { + rb_raise(rb_eRuntimeError, "invalid escape"); + } + undump_after_backslash(undumped, &s, s_end, &enc, &utf8, &binary); + } + else { + rb_str_cat(undumped, s++, 1); + } + } + + OBJ_INFECT(undumped, str); return undumped; invalid_format: rb_raise(rb_eRuntimeError, "invalid dumped string; not wrapped with '\"' nor '\"...\".force_encoding(\"...\")' form"); @@ -7697,19 +6341,11 @@ 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)); + rb_raise(rb_eEncCompatError, "incompatible encoding with this operation: %s", + rb_enc_name(enc)); } } -static rb_encoding * -str_true_enc(VALUE str) -{ - rb_encoding *enc = STR_ENC_GET(str); - rb_str_check_dummy_enc(enc); - return enc; -} - static OnigCaseFoldType check_case_options(int argc, VALUE *argv, OnigCaseFoldType flags) { @@ -7718,46 +6354,38 @@ check_case_options(int argc, VALUE *argv, OnigCaseFoldType flags) if (argc>2) rb_raise(rb_eArgError, "too many options"); if (argv[0]==sym_turkic) { - flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI; - if (argc==2) { - if (argv[1]==sym_lithuanian) - flags |= ONIGENC_CASE_FOLD_LITHUANIAN; - else - rb_raise(rb_eArgError, "invalid second option"); - } + flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI; + if (argc==2) { + if (argv[1]==sym_lithuanian) + flags |= ONIGENC_CASE_FOLD_LITHUANIAN; + else + rb_raise(rb_eArgError, "invalid second option"); + } } else if (argv[0]==sym_lithuanian) { - flags |= ONIGENC_CASE_FOLD_LITHUANIAN; - if (argc==2) { - if (argv[1]==sym_turkic) - flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI; - else - rb_raise(rb_eArgError, "invalid second option"); - } + flags |= ONIGENC_CASE_FOLD_LITHUANIAN; + if (argc==2) { + if (argv[1]==sym_turkic) + flags |= ONIGENC_CASE_FOLD_TURKISH_AZERI; + else + rb_raise(rb_eArgError, "invalid second option"); + } } else if (argc>1) - rb_raise(rb_eArgError, "too many options"); + rb_raise(rb_eArgError, "too many options"); else if (argv[0]==sym_ascii) - flags |= ONIGENC_CASE_ASCII_ONLY; + flags |= ONIGENC_CASE_ASCII_ONLY; else if (argv[0]==sym_fold) { - if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE) - flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE; - else - rb_raise(rb_eArgError, "option :fold only allowed for downcasing"); + if ((flags & (ONIGENC_CASE_UPCASE|ONIGENC_CASE_DOWNCASE)) == ONIGENC_CASE_DOWNCASE) + flags ^= ONIGENC_CASE_FOLD|ONIGENC_CASE_DOWNCASE; + else + rb_raise(rb_eArgError, "option :fold only allowed for downcasing"); } else - rb_raise(rb_eArgError, "invalid option"); + rb_raise(rb_eArgError, "invalid option"); return flags; } -static inline bool -case_option_single_p(OnigCaseFoldType flags, rb_encoding *enc, VALUE str) -{ - if ((flags & ONIGENC_CASE_ASCII_ONLY) && (enc==rb_utf8_encoding() || rb_enc_mbmaxlen(enc) == 1)) - return true; - return !(flags & ONIGENC_CASE_FOLD_TURKISH_AZERI) && ENC_CODERANGE(str) == ENC_CODERANGE_7BIT; -} - /* 16 should be long enough to absorb any kind of single character length increase */ #define CASE_MAPPING_ADDITIONAL_LENGTH 20 #ifndef CASEMAP_DEBUG @@ -7769,7 +6397,7 @@ typedef struct mapping_buffer { size_t capa; size_t used; struct mapping_buffer *next; - OnigUChar space[FLEX_ARY_LEN]; + OnigUChar space[1]; } mapping_buffer; static void @@ -7786,8 +6414,7 @@ mapping_buffer_free(void *p) static const rb_data_type_t mapping_buffer_type = { "mapping_buffer", - {0, mapping_buffer_free,}, - 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED + {0, mapping_buffer_free,} }; static VALUE @@ -7795,7 +6422,7 @@ rb_str_casemap(VALUE source, OnigCaseFoldType *flags, rb_encoding *enc) { VALUE target; - const OnigUChar *source_current, *source_end; + OnigUChar *source_current, *source_end; int target_length = 0; VALUE buffer_anchor; mapping_buffer *current_buffer = 0; @@ -7803,7 +6430,7 @@ rb_str_casemap(VALUE source, OnigCaseFoldType *flags, rb_encoding *enc) size_t buffer_count = 0; int buffer_length_or_invalid; - if (RSTRING_LEN(source) == 0) return str_duplicate(rb_cString, source); + if (RSTRING_LEN(source) == 0) return rb_str_dup(source); source_current = (OnigUChar*)RSTRING_PTR(source); source_end = (OnigUChar*)RSTRING_END(source); @@ -7811,134 +6438,94 @@ rb_str_casemap(VALUE source, OnigCaseFoldType *flags, rb_encoding *enc) buffer_anchor = TypedData_Wrap_Struct(0, &mapping_buffer_type, 0); pre_buffer = (mapping_buffer **)&DATA_PTR(buffer_anchor); while (source_current < source_end) { - /* increase multiplier using buffer count to converge quickly */ - size_t capa = (size_t)(source_end-source_current)*++buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH; - if (CASEMAP_DEBUG) { - fprintf(stderr, "Buffer allocation, capa is %"PRIuSIZE"\n", capa); /* for tuning */ - } + /* increase multiplier using buffer count to converge quickly */ + size_t capa = (size_t)(source_end-source_current)*++buffer_count + CASE_MAPPING_ADDITIONAL_LENGTH; + if (CASEMAP_DEBUG) { + fprintf(stderr, "Buffer allocation, capa is %"PRIuSIZE"\n", capa); /* for tuning */ + } current_buffer = xmalloc(offsetof(mapping_buffer, space) + capa); *pre_buffer = current_buffer; pre_buffer = ¤t_buffer->next; - current_buffer->next = NULL; - current_buffer->capa = capa; - buffer_length_or_invalid = enc->case_map(flags, - &source_current, source_end, - current_buffer->space, - current_buffer->space+current_buffer->capa, - enc); - if (buffer_length_or_invalid < 0) { + current_buffer->next = NULL; + current_buffer->capa = capa; + buffer_length_or_invalid = enc->case_map(flags, + (const OnigUChar**)&source_current, source_end, + current_buffer->space, + current_buffer->space+current_buffer->capa, + enc); + if (buffer_length_or_invalid < 0) { current_buffer = DATA_PTR(buffer_anchor); DATA_PTR(buffer_anchor) = 0; - mapping_buffer_free(current_buffer); - rb_raise(rb_eArgError, "input string invalid"); - } - target_length += current_buffer->used = buffer_length_or_invalid; + mapping_buffer_free(current_buffer); + rb_raise(rb_eArgError, "input string invalid"); + } + target_length += current_buffer->used = buffer_length_or_invalid; } if (CASEMAP_DEBUG) { - fprintf(stderr, "Buffer count is %"PRIuSIZE"\n", buffer_count); /* for tuning */ + fprintf(stderr, "Buffer count is %"PRIuSIZE"\n", buffer_count); /* for tuning */ } if (buffer_count==1) { - target = rb_str_new((const char*)current_buffer->space, target_length); + target = rb_str_new_with_class(source, (const char*)current_buffer->space, target_length); } else { - char *target_current; - - target = rb_str_new(0, target_length); - target_current = RSTRING_PTR(target); - current_buffer = DATA_PTR(buffer_anchor); - while (current_buffer) { - memcpy(target_current, current_buffer->space, current_buffer->used); - target_current += current_buffer->used; - current_buffer = current_buffer->next; - } + char *target_current; + + target = rb_str_new_with_class(source, 0, target_length); + target_current = RSTRING_PTR(target); + current_buffer = DATA_PTR(buffer_anchor); + while (current_buffer) { + memcpy(target_current, current_buffer->space, current_buffer->used); + target_current += current_buffer->used; + current_buffer = current_buffer->next; + } } current_buffer = DATA_PTR(buffer_anchor); DATA_PTR(buffer_anchor) = 0; mapping_buffer_free(current_buffer); - RB_GC_GUARD(buffer_anchor); - /* TODO: check about string terminator character */ - str_enc_copy_direct(target, source); + OBJ_INFECT_RAW(target, source); + str_enc_copy(target, source); /*ENC_CODERANGE_SET(mapped, cr);*/ return target; } -static VALUE -rb_str_ascii_casemap(VALUE source, VALUE target, OnigCaseFoldType *flags, rb_encoding *enc) +static void +rb_str_ascii_casemap(VALUE source, OnigCaseFoldType *flags, rb_encoding *enc) { - const OnigUChar *source_current, *source_end; - OnigUChar *target_current, *target_end; + OnigUChar *source_current, *source_end; long old_length = RSTRING_LEN(source); int length_or_invalid; - if (old_length == 0) return Qnil; + if (old_length == 0) return; source_current = (OnigUChar*)RSTRING_PTR(source); source_end = (OnigUChar*)RSTRING_END(source); - if (source == target) { - target_current = (OnigUChar*)source_current; - target_end = (OnigUChar*)source_end; - } - else { - target_current = (OnigUChar*)RSTRING_PTR(target); - target_end = (OnigUChar*)RSTRING_END(target); - } length_or_invalid = onigenc_ascii_only_case_map(flags, - &source_current, source_end, - target_current, target_end, enc); + (const OnigUChar**)&source_current, source_end, + source_current, source_end, enc); if (length_or_invalid < 0) rb_raise(rb_eArgError, "input string invalid"); if (CASEMAP_DEBUG && length_or_invalid != old_length) { - fprintf(stderr, "problem with rb_str_ascii_casemap" - "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid); - rb_raise(rb_eArgError, "internal problem with rb_str_ascii_casemap" - "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid); - } - - str_enc_copy(target, source); - - return target; -} - -static bool -upcase_single(VALUE str) -{ - char *s = RSTRING_PTR(str), *send = RSTRING_END(str); - bool modified = false; - - while (s < send) { - unsigned int c = *(unsigned char*)s; - - if ('a' <= c && c <= 'z') { - *s = 'A' + (c - 'a'); - modified = true; - } - s++; + fprintf(stderr, "problem with rb_str_ascii_casemap" + "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid); + rb_raise(rb_eArgError, "internal problem with rb_str_ascii_casemap" + "; old_length=%ld, new_length=%d\n", old_length, length_or_invalid); } - return modified; } /* * call-seq: - * upcase!(*options) -> self or nil - * - * Upcases the characters in +self+; - * returns +self+ if any changes were made, +nil+ otherwise: - * - * s = 'Hello World!' # => "Hello World!" - * s.upcase! # => "HELLO WORLD!" - * s # => "HELLO WORLD!" - * s.upcase! # => nil - * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * str.upcase! -> str or nil + * str.upcase!([options]) -> str or nil * - * Related: String#upcase, String#downcase, String#downcase!. + * Upcases the contents of <i>str</i>, returning <code>nil</code> if no changes + * were made. * + * See String#downcase for meaning of +options+ and use with different encodings. */ static VALUE @@ -7949,15 +6536,26 @@ rb_str_upcase_bang(int argc, VALUE *argv, VALUE str) flags = check_case_options(argc, argv, flags); str_modify_keep_cr(str); - enc = str_true_enc(str); - if (case_option_single_p(flags, enc, str)) { - if (upcase_single(str)) - flags |= ONIGENC_CASE_MODIFIED; + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + if (((flags&ONIGENC_CASE_ASCII_ONLY) && (enc==rb_utf8_encoding() || rb_enc_mbmaxlen(enc)==1)) + || (!(flags&ONIGENC_CASE_FOLD_TURKISH_AZERI) && ENC_CODERANGE(str)==ENC_CODERANGE_7BIT)) { + char *s = RSTRING_PTR(str), *send = RSTRING_END(str); + + while (s < send) { + unsigned int c = *(unsigned char*)s; + + if (rb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') { + *s = 'A' + (c - 'a'); + flags |= ONIGENC_CASE_MODIFIED; + } + s++; + } } else if (flags&ONIGENC_CASE_ASCII_ONLY) - rb_str_ascii_casemap(str, str, &flags, enc); + rb_str_ascii_casemap(str, &flags, enc); else - str_shared_replace(str, rb_str_casemap(str, &flags, enc)); + str_shared_replace(str, rb_str_casemap(str, &flags, enc)); if (ONIGENC_CASE_MODIFIED&flags) return str; return Qnil; @@ -7966,81 +6564,34 @@ rb_str_upcase_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * upcase(*options) -> string - * - * Returns a string containing the upcased characters in +self+: + * str.upcase -> new_str + * str.upcase([options]) -> new_str * - * s = 'Hello World!' # => "Hello World!" - * s.upcase # => "HELLO WORLD!" + * Returns a copy of <i>str</i> with all lowercase letters replaced with their + * uppercase counterparts. * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. - * - * Related: String#upcase!, String#downcase, String#downcase!. + * See String#downcase for meaning of +options+ and use with different encodings. * + * "hEllO".upcase #=> "HELLO" */ static VALUE rb_str_upcase(int argc, VALUE *argv, VALUE str) { - rb_encoding *enc; - OnigCaseFoldType flags = ONIGENC_CASE_UPCASE; - VALUE ret; - - flags = check_case_options(argc, argv, flags); - enc = str_true_enc(str); - if (case_option_single_p(flags, enc, str)) { - ret = rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str)); - str_enc_copy_direct(ret, str); - upcase_single(ret); - } - else if (flags&ONIGENC_CASE_ASCII_ONLY) { - ret = rb_str_new(0, RSTRING_LEN(str)); - rb_str_ascii_casemap(str, ret, &flags, enc); - } - else { - ret = rb_str_casemap(str, &flags, enc); - } - - return ret; -} - -static bool -downcase_single(VALUE str) -{ - char *s = RSTRING_PTR(str), *send = RSTRING_END(str); - bool modified = false; - - while (s < send) { - unsigned int c = *(unsigned char*)s; - - if ('A' <= c && c <= 'Z') { - *s = 'a' + (c - 'A'); - modified = true; - } - s++; - } - - return modified; + str = rb_str_dup(str); + rb_str_upcase_bang(argc, argv, str); + return str; } /* * call-seq: - * downcase!(*options) -> self or nil - * - * Downcases the characters in +self+; - * returns +self+ if any changes were made, +nil+ otherwise: - * - * s = 'Hello World!' # => "Hello World!" - * s.downcase! # => "hello world!" - * s # => "hello world!" - * s.downcase! # => nil + * str.downcase! -> str or nil + * str.downcase!([options]) -> str or nil * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. - * - * Related: String#downcase, String#upcase, String#upcase!. + * Downcases the contents of <i>str</i>, returning <code>nil</code> if no + * changes were made. * + * See String#downcase for meaning of +options+ and use with different encodings. */ static VALUE @@ -8051,15 +6602,26 @@ rb_str_downcase_bang(int argc, VALUE *argv, VALUE str) flags = check_case_options(argc, argv, flags); str_modify_keep_cr(str); - enc = str_true_enc(str); - if (case_option_single_p(flags, enc, str)) { - if (downcase_single(str)) - flags |= ONIGENC_CASE_MODIFIED; + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); + if (((flags&ONIGENC_CASE_ASCII_ONLY) && (enc==rb_utf8_encoding() || rb_enc_mbmaxlen(enc)==1)) + || (!(flags&ONIGENC_CASE_FOLD_TURKISH_AZERI) && ENC_CODERANGE(str)==ENC_CODERANGE_7BIT)) { + char *s = RSTRING_PTR(str), *send = RSTRING_END(str); + + while (s < send) { + unsigned int c = *(unsigned char*)s; + + if (rb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') { + *s = 'a' + (c - 'A'); + flags |= ONIGENC_CASE_MODIFIED; + } + s++; + } } else if (flags&ONIGENC_CASE_ASCII_ONLY) - rb_str_ascii_casemap(str, str, &flags, enc); + rb_str_ascii_casemap(str, &flags, enc); else - str_shared_replace(str, rb_str_casemap(str, &flags, enc)); + str_shared_replace(str, rb_str_casemap(str, &flags, enc)); if (ONIGENC_CASE_MODIFIED&flags) return str; return Qnil; @@ -8068,64 +6630,77 @@ rb_str_downcase_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * downcase(*options) -> string + * str.downcase -> new_str + * str.downcase([options]) -> new_str + * + * Returns a copy of <i>str</i> with all uppercase letters replaced with their + * lowercase counterparts. Which letters exactly are replaced, and by which + * other letters, depends on the presence or absence of options, and on the + * +encoding+ of the string. * - * Returns a string containing the downcased characters in +self+: + * The meaning of the +options+ is as follows: * - * s = 'Hello World!' # => "Hello World!" - * s.downcase # => "hello world!" + * No option :: + * Full Unicode case mapping, suitable for most languages + * (see :turkic and :lithuanian options below for exceptions). + * Context-dependent case mapping as described in Table 3-14 of the + * Unicode standard is currently not supported. + * :ascii :: + * Only the ASCII region, i.e. the characters ``A'' to ``Z'' and + * ``a'' to ``z'', are affected. + * This option cannot be combined with any other option. + * :turkic :: + * Full Unicode case mapping, adapted for Turkic languages + * (Turkish, Aserbaijani,...). This means that upper case I is mapped to + * lower case dotless i, and so on. + * :lithuanian :: + * Currently, just full Unicode case mapping. In the future, full Unicode + * case mapping adapted for Lithuanian (keeping the dot on the lower case + * i even if there is an accent on top). + * :fold :: + * Only available on +downcase+ and +downcase!+. Unicode case <b>folding</b>, + * which is more far-reaching than Unicode case mapping. + * This option currently cannot be combined with any other option + * (i.e. there is currenty no variant for turkic languages). * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * Please note that several assumptions that are valid for ASCII-only case + * conversions do not hold for more general case conversions. For example, + * the length of the result may not be the same as the length of the input + * (neither in characters nor in bytes), some roundtrip assumptions + * (e.g. str.downcase == str.upcase.downcase) may not apply, and Unicode + * normalization (i.e. String#unicode_normalize) is not necessarily maintained + * by case mapping operations. * - * Related: String#downcase!, String#upcase, String#upcase!. + * Non-ASCII case mapping/folding is currently supported for UTF-8, + * UTF-16BE/LE, UTF-32BE/LE, and ISO-8859-1~16 Strings/Symbols. + * This support will be extended to other encodings. * + * "hEllO".downcase #=> "hello" */ static VALUE rb_str_downcase(int argc, VALUE *argv, VALUE str) { - rb_encoding *enc; - OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE; - VALUE ret; - - flags = check_case_options(argc, argv, flags); - enc = str_true_enc(str); - if (case_option_single_p(flags, enc, str)) { - ret = rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str)); - str_enc_copy_direct(ret, str); - downcase_single(ret); - } - else if (flags&ONIGENC_CASE_ASCII_ONLY) { - ret = rb_str_new(0, RSTRING_LEN(str)); - rb_str_ascii_casemap(str, ret, &flags, enc); - } - else { - ret = rb_str_casemap(str, &flags, enc); - } - - return ret; + str = rb_str_dup(str); + rb_str_downcase_bang(argc, argv, str); + return str; } /* * call-seq: - * capitalize!(*options) -> self or nil - * - * Upcases the first character in +self+; - * downcases the remaining characters; - * returns +self+ if any changes were made, +nil+ otherwise: - * - * s = 'hello World!' # => "hello World!" - * s.capitalize! # => "Hello world!" - * s # => "Hello world!" - * s.capitalize! # => nil + * str.capitalize! -> str or nil + * str.capitalize!([options]) -> str or nil * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * Modifies <i>str</i> by converting the first character to uppercase and the + * remainder to lowercase. Returns <code>nil</code> if no changes are made. * - * Related: String#capitalize. + * See String#downcase for meaning of +options+ and use with different encodings. * + * a = "hello" + * a.capitalize! #=> "Hello" + * a #=> "Hello" + * a.capitalize! #=> nil */ static VALUE @@ -8136,12 +6711,13 @@ rb_str_capitalize_bang(int argc, VALUE *argv, VALUE str) flags = check_case_options(argc, argv, flags); str_modify_keep_cr(str); - enc = str_true_enc(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; if (flags&ONIGENC_CASE_ASCII_ONLY) - rb_str_ascii_casemap(str, str, &flags, enc); + rb_str_ascii_casemap(str, &flags, enc); else - str_shared_replace(str, rb_str_casemap(str, &flags, enc)); + str_shared_replace(str, rb_str_casemap(str, &flags, enc)); if (ONIGENC_CASE_MODIFIED&flags) return str; return Qnil; @@ -8150,61 +6726,37 @@ rb_str_capitalize_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * capitalize(*options) -> string - * - * Returns a string containing the characters in +self+; - * the first character is upcased; - * the remaining characters are downcased: - * - * s = 'hello World!' # => "hello World!" - * s.capitalize # => "Hello world!" + * str.capitalize -> new_str + * str.capitalize([options]) -> new_str * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * Returns a copy of <i>str</i> with the first character converted to uppercase + * and the remainder to lowercase. * - * Related: String#capitalize!. + * See String#downcase for meaning of +options+ and use with different encodings. * + * "hello".capitalize #=> "Hello" + * "HELLO".capitalize #=> "Hello" + * "123ABC".capitalize #=> "123abc" */ static VALUE rb_str_capitalize(int argc, VALUE *argv, VALUE str) { - rb_encoding *enc; - OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_TITLECASE; - VALUE ret; - - flags = check_case_options(argc, argv, flags); - enc = str_true_enc(str); - if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return str; - if (flags&ONIGENC_CASE_ASCII_ONLY) { - ret = rb_str_new(0, RSTRING_LEN(str)); - rb_str_ascii_casemap(str, ret, &flags, enc); - } - else { - ret = rb_str_casemap(str, &flags, enc); - } - return ret; + str = rb_str_dup(str); + rb_str_capitalize_bang(argc, argv, str); + return str; } /* * call-seq: - * swapcase!(*options) -> self or nil - * - * Upcases each lowercase character in +self+; - * downcases uppercase character; - * returns +self+ if any changes were made, +nil+ otherwise: - * - * s = 'Hello World!' # => "Hello World!" - * s.swapcase! # => "hELLO wORLD!" - * s # => "hELLO wORLD!" - * ''.swapcase! # => nil - * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * str.swapcase! -> str or nil + * str.swapcase!([options]) -> str or nil * - * Related: String#swapcase. + * Equivalent to <code>String#swapcase</code>, but modifies the receiver in + * place, returning <i>str</i>, or <code>nil</code> if no changes were made. * + * See String#downcase for meaning of +options+ and use with different encodings. */ static VALUE @@ -8215,11 +6767,12 @@ rb_str_swapcase_bang(int argc, VALUE *argv, VALUE str) flags = check_case_options(argc, argv, flags); str_modify_keep_cr(str); - enc = str_true_enc(str); + enc = STR_ENC_GET(str); + rb_str_check_dummy_enc(enc); if (flags&ONIGENC_CASE_ASCII_ONLY) - rb_str_ascii_casemap(str, str, &flags, enc); + rb_str_ascii_casemap(str, &flags, enc); else - str_shared_replace(str, rb_str_casemap(str, &flags, enc)); + str_shared_replace(str, rb_str_casemap(str, &flags, enc)); if (ONIGENC_CASE_MODIFIED&flags) return str; return Qnil; @@ -8228,40 +6781,24 @@ rb_str_swapcase_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * swapcase(*options) -> string - * - * Returns a string containing the characters in +self+, with cases reversed; - * each uppercase character is downcased; - * each lowercase character is upcased: - * - * s = 'Hello World!' # => "Hello World!" - * s.swapcase # => "hELLO wORLD!" + * str.swapcase -> new_str + * str.swapcase([options]) -> new_str * - * The casing may be affected by the given +options+; - * see {Case Mapping}[rdoc-ref:case_mapping.rdoc]. + * Returns a copy of <i>str</i> with uppercase alphabetic characters converted + * to lowercase and lowercase characters converted to uppercase. * - * Related: String#swapcase!. + * See String#downcase for meaning of +options+ and use with different encodings. * + * "Hello".swapcase #=> "hELLO" + * "cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11" */ static VALUE rb_str_swapcase(int argc, VALUE *argv, VALUE str) { - rb_encoding *enc; - OnigCaseFoldType flags = ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE; - VALUE ret; - - flags = check_case_options(argc, argv, flags); - enc = str_true_enc(str); - if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return str_duplicate(rb_cString, str); - if (flags&ONIGENC_CASE_ASCII_ONLY) { - ret = rb_str_new(0, RSTRING_LEN(str)); - rb_str_ascii_casemap(str, ret, &flags, enc); - } - else { - ret = rb_str_casemap(str, &flags, enc); - } - return ret; + str = rb_str_dup(str); + rb_str_swapcase_bang(argc, argv, str); + return str; } typedef unsigned char *USTR; @@ -8278,53 +6815,51 @@ trnext(struct tr *t, rb_encoding *enc) int n; for (;;) { - nextpart: - if (!t->gen) { - 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 */ - } - else if (t->now < c) { - 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; - } - } + 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; + } + } } } @@ -8340,7 +6875,7 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) int cflag = 0; unsigned int c, c0, last = 0; int modify = 0, i, l; - unsigned char *s, *send; + char *s, *send; VALUE hash = 0; int singlebyte = single_byte_optimizable(str); int termlen; @@ -8348,30 +6883,30 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) #define CHECK_IF_ASCII(c) \ (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \ - (cr = ENC_CODERANGE_VALID) : 0) + (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); + 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; + enc = e1; } else { - enc = rb_enc_check(src, repl); + 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; + 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); @@ -8380,213 +6915,196 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) 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; - } - } + 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)); - } - } + 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 && rb_enc_asciicompat(e1)) - cr = ENC_CODERANGE_7BIT; + cr = ENC_CODERANGE_7BIT; str_modify_keep_cr(str); - s = (unsigned char *)RSTRING_PTR(str); send = (unsigned char *)RSTRING_END(str); + s = RSTRING_PTR(str); send = RSTRING_END(str); termlen = rb_enc_mbminlen(enc); if (sflag) { - int clen, tlen; - long offset, max = RSTRING_LEN(str); - unsigned int save = -1; - unsigned char *buf = ALLOC_N(unsigned char, max + termlen), *t = buf; - - while (s < send) { - int may_modify = 0; - - int r = rb_enc_precise_mbclen((char *)s, (char *)send, e1); - if (!MBCLEN_CHARFOUND_P(r)) { - xfree(buf); - rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(e1)); - } - clen = MBCLEN_CHARFOUND_LEN(r); - c0 = c = rb_enc_mbc_to_codepoint((char *)s, (char *)send, 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; - } - if ((offset = t - buf) + tlen > max) { - size_t MAYBE_UNUSED(old) = max + termlen; - max = offset + tlen + (send - s); - SIZED_REALLOC_N(buf, unsigned char, max + termlen, old); - 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((char *)t, termlen); - RSTRING(str)->as.heap.ptr = (char *)buf; - STR_SET_LEN(str, t - buf); - STR_SET_NOEMBED(str); - RSTRING(str)->as.heap.aux.capa = max; + int clen, tlen; + long offset, max = RSTRING_LEN(str); + unsigned int save = -1; + char *buf = ALLOC_N(char, max + termlen), *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; + } + if ((offset = t - buf) + tlen > max) { + max = offset + tlen + (send - s); + REALLOC_N(buf, char, max + termlen); + 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, termlen); + 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++; - } + 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; - long offset, max = (long)((send - s) * 1.2); - unsigned char *buf = ALLOC_N(unsigned char, max + termlen), *t = buf; - - while (s < send) { - int may_modify = 0; - - int r = rb_enc_precise_mbclen((char *)s, (char *)send, e1); - if (!MBCLEN_CHARFOUND_P(r)) { - xfree(buf); - rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(e1)); - } - clen = MBCLEN_CHARFOUND_LEN(r); - c0 = c = rb_enc_mbc_to_codepoint((char *)s, (char *)send, 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; - } - if ((offset = t - buf) + tlen > max) { - size_t MAYBE_UNUSED(old) = max + termlen; - max = offset + tlen + (long)((send - s) * 1.2); - SIZED_REALLOC_N(buf, unsigned char, max + termlen, old); - 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((char *)t, termlen); - RSTRING(str)->as.heap.ptr = (char *)buf; - STR_SET_LEN(str, t - buf); - STR_SET_NOEMBED(str); - RSTRING(str)->as.heap.aux.capa = max; + int clen, tlen; + long offset, max = (long)((send - s) * 1.2); + char *buf = ALLOC_N(char, max + termlen), *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; + } + if ((offset = t - buf) + tlen > max) { + max = offset + tlen + (long)((send - s) * 1.2); + REALLOC_N(buf, char, max + termlen); + 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, termlen); + 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; + if (cr != ENC_CODERANGE_BROKEN) + ENC_CODERANGE_SET(str, cr); + rb_enc_associate(str, enc); + return str; } return Qnil; } @@ -8594,11 +7112,11 @@ tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) /* * call-seq: - * tr!(selector, replacements) -> self or nil - * - * Like String#tr, but modifies +self+ in place. - * Returns +self+ if any changes were made, +nil+ otherwise. + * str.tr!(from_str, to_str) -> str or nil * + * Translates <i>str</i> in place, using the same rules as + * <code>String#tr</code>. Returns <i>str</i>, or <code>nil</code> if no + * changes were made. */ static VALUE @@ -8610,59 +7128,54 @@ rb_str_tr_bang(VALUE str, VALUE src, VALUE repl) /* * call-seq: - * tr(selector, replacements) -> new_string - * - * Returns a copy of +self+ with each character specified by string +selector+ - * translated to the corresponding character in string +replacements+. - * The correspondence is _positional_: + * str.tr(from_str, to_str) => new_str * - * - Each occurrence of the first character specified by +selector+ - * is translated to the first character in +replacements+. - * - Each occurrence of the second character specified by +selector+ - * is translated to the second character in +replacements+. - * - And so on. + * 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. * - * Example: + * "hello".tr('el', 'ip') #=> "hippo" + * "hello".tr('aeiou', '*') #=> "h*ll*" + * "hello".tr('aeiou', 'AA*') #=> "hAll*" * - * 'hello'.tr('el', 'ip') #=> "hippo" + * Both strings may use the <code>c1-c2</code> notation to denote ranges of + * characters, and +from_str+ may start with a <code>^</code>, which denotes + * all characters except those listed. * - * If +replacements+ is shorter than +selector+, - * it is implicitly padded with its own last character: + * "hello".tr('a-y', 'b-z') #=> "ifmmp" + * "hello".tr('^aeiou', '*') #=> "*e**o" * - * 'hello'.tr('aeiou', '-') # => "h-ll-" - * 'hello'.tr('aeiou', 'AA-') # => "hAll-" + * The backslash character <code>\\</code> can be used to escape + * <code>^</code> or <code>-</code> and is otherwise ignored unless it + * appears at the end of a range or the end of the +from_str+ or +to_str+: * - * Arguments +selector+ and +replacements+ must be valid character selectors - * (see {Character Selectors}[rdoc-ref:character_selectors.rdoc]), - * and may use any of its valid forms, including negation, ranges, and escaping: + * "hello^world".tr("\\^aeiou", "*") #=> "h*ll**w*rld" + * "hello-world".tr("a\\-eo", "*") #=> "h*ll**w*rld" * - * # Negation. - * 'hello'.tr('^aeiou', '-') # => "-e--o" - * # Ranges. - * 'ibm'.tr('b-z', 'a-z') # => "hal" - * # Escapes. - * 'hel^lo'.tr('\^aeiou', '-') # => "h-l-l-" # Escaped leading caret. - * 'i-b-m'.tr('b\-z', 'a-z') # => "ibabm" # Escaped embedded hyphen. - * 'foo\\bar'.tr('ab\\', 'XYZ') # => "fooZYXr" # Escaped backslash. + * "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 = str_duplicate(rb_cString, str); + str = rb_str_dup(str); tr_trans(str, src, repl, 0); return str; } -#define TR_TABLE_MAX (UCHAR_MAX+1) -#define TR_TABLE_SIZE (TR_TABLE_MAX+1) +#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) + VALUE *tablep, VALUE *ctablep, rb_encoding *enc) { const unsigned int errc = -1; - char buf[TR_TABLE_MAX]; + char buf[256]; struct tr tr; unsigned int c; VALUE table = 0, ptable = 0; @@ -8672,51 +7185,51 @@ tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first, 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; + cflag = 1; + tr.p += l; } if (first) { - for (i=0; i<TR_TABLE_MAX; i++) { - stable[i] = 1; - } - stable[TR_TABLE_MAX] = cflag; + for (i=0; i<256; i++) { + stable[i] = 1; + } + stable[256] = cflag; } - else if (stable[TR_TABLE_MAX] && !cflag) { - stable[TR_TABLE_MAX] = 0; + else if (stable[256] && !cflag) { + stable[256] = 0; } - for (i=0; i<TR_TABLE_MAX; i++) { - buf[i] = cflag; + for (i=0; i<256; i++) { + buf[i] = cflag; } while ((c = trnext(&tr, enc)) != errc) { - if (c < TR_TABLE_MAX) { - buf[(unsigned char)c] = !cflag; - } - else { - VALUE key = UINT2NUM(c); - - if (!table && (first || *tablep || stable[TR_TABLE_MAX])) { - 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<TR_TABLE_MAX; i++) { - stable[i] = stable[i] && buf[i]; + 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; + *tablep = 0; } } @@ -8724,32 +7237,31 @@ tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first, static int tr_find(unsigned int c, const char table[TR_TABLE_SIZE], VALUE del, VALUE nodel) { - if (c < TR_TABLE_MAX) { - return table[c] != 0; + if (c < 256) { + return table[c] != 0; } else { - VALUE v = UINT2NUM(c); + 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[TR_TABLE_MAX] ? TRUE : FALSE; + 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: - * delete!(*selectors) -> self or nil - * - * Like String#delete, but modifies +self+ in place. - * Returns +self+ if any changes were made, +nil+ otherwise. + * str.delete!([other_str]+) -> str or nil * + * Performs a <code>delete</code> operation in place, returning <i>str</i>, or + * <code>nil</code> if <i>str</i> was not modified. */ static VALUE @@ -8765,11 +7277,11 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str) if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); for (i=0; i<argc; i++) { - VALUE s = argv[i]; + VALUE s = argv[i]; - StringValue(s); - enc = rb_enc_check(str, s); - tr_setup_table(s, squeez, i==0, &del, &nodel, enc); + StringValue(s); + enc = rb_enc_check(str, s); + tr_setup_table(s, squeez, i==0, &del, &nodel, enc); } str_modify_keep_cr(str); @@ -8778,32 +7290,32 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str) send = RSTRING_END(str); cr = ascompat ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID; while (s < send) { - unsigned int c; - int clen; - - if (ascompat && (c = *(unsigned char*)s) < 0x80) { - if (squeez[c]) { - modify = 1; - } - else { - if (t != s) *t = c; - t++; - } - s++; - } - else { - c = rb_enc_codepoint_len(s, send, &clen, enc); - - if (tr_find(c, squeez, del, nodel)) { - modify = 1; - } - else { - if (t != s) rb_enc_mbcput(c, t, enc); - t += clen; - if (cr == ENC_CODERANGE_7BIT) cr = ENC_CODERANGE_VALID; - } - s += clen; - } + unsigned int c; + int clen; + + if (ascompat && (c = *(unsigned char*)s) < 0x80) { + if (squeez[c]) { + modify = 1; + } + else { + if (t != s) *t = c; + t++; + } + s++; + } + else { + c = rb_enc_codepoint_len(s, send, &clen, enc); + + if (tr_find(c, squeez, del, nodel)) { + modify = 1; + } + else { + if (t != s) rb_enc_mbcput(c, t, enc); + t += clen; + if (cr == ENC_CODERANGE_7BIT) cr = ENC_CODERANGE_VALID; + } + s += clen; + } } TERM_FILL(t, TERM_LEN(str)); STR_SET_LEN(str, t - RSTRING_PTR(str)); @@ -8816,22 +7328,22 @@ rb_str_delete_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * delete(*selectors) -> new_string + * str.delete([other_str]+) -> new_str * - * Returns a copy of +self+ with characters specified by +selectors+ removed - * (see {Multiple Character Selectors}[rdoc-ref:character_selectors.rdoc@Multiple+Character+Selectors]): + * Returns a copy of <i>str</i> with all characters in the intersection of its + * arguments deleted. Uses the same rules for building the set of characters as + * <code>String#count</code>. * * "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 = str_duplicate(rb_cString, str); + str = rb_str_dup(str); rb_str_delete_bang(argc, argv, str); return str; } @@ -8839,10 +7351,10 @@ rb_str_delete(int argc, VALUE *argv, VALUE str) /* * call-seq: - * squeeze!(*selectors) -> self or nil + * str.squeeze!([other_str]*) -> str or nil * - * Like String#squeeze, but modifies +self+ in place. - * Returns +self+ if any changes were made, +nil+ otherwise. + * Squeezes <i>str</i> in place, returning either <i>str</i>, or + * <code>nil</code> if no changes were made. */ static VALUE @@ -8851,69 +7363,69 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str) char squeez[TR_TABLE_SIZE]; rb_encoding *enc = 0; VALUE del = 0, nodel = 0; - unsigned char *s, *send, *t; + 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); + enc = STR_ENC_GET(str); } else { - for (i=0; i<argc; i++) { - VALUE s = argv[i]; - - StringValue(s); - enc = rb_enc_check(str, s); - if (singlebyte && !single_byte_optimizable(s)) - singlebyte = 0; - tr_setup_table(s, squeez, i==0, &del, &nodel, enc); - } + for (i=0; i<argc; i++) { + VALUE s = argv[i]; + + StringValue(s); + enc = rb_enc_check(str, s); + if (singlebyte && !single_byte_optimizable(s)) + singlebyte = 0; + tr_setup_table(s, squeez, i==0, &del, &nodel, enc); + } } str_modify_keep_cr(str); - s = t = (unsigned char *)RSTRING_PTR(str); + s = t = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qnil; - send = (unsigned char *)RSTRING_END(str); + send = RSTRING_END(str); save = -1; ascompat = rb_enc_asciicompat(enc); if (singlebyte) { while (s < send) { - unsigned int c = *s++; - if (c != save || (argc > 0 && !squeez[c])) { - *t++ = save = c; - } - } + unsigned int c = *(unsigned char*)s++; + if (c != save || (argc > 0 && !squeez[c])) { + *t++ = save = c; + } + } } else { - while (s < send) { - unsigned int c; - int clen; - - if (ascompat && (c = *s) < 0x80) { - if (c != save || (argc > 0 && !squeez[c])) { - *t++ = save = c; - } - s++; - } - else { - c = rb_enc_codepoint_len((char *)s, (char *)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; - } - } + 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((char *)t, TERM_LEN(str)); - if ((char *)t - RSTRING_PTR(str) != RSTRING_LEN(str)) { - STR_SET_LEN(str, (char *)t - RSTRING_PTR(str)); - modify = 1; + 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; @@ -8923,25 +7435,23 @@ rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * squeeze(*selectors) -> new_string + * str.squeeze([other_str]*) -> new_str * - * Returns a copy of +self+ with characters specified by +selectors+ "squeezed" - * (see {Multiple Character Selectors}[rdoc-ref:character_selectors.rdoc@Multiple+Character+Selectors]): - * - * "Squeezed" means that each multiple-character run of a selected character - * is squeezed down to a single character; - * with no arguments given, squeezes all characters: + * Builds a set of characters from the <i>other_str</i> parameter(s) using the + * procedure described for <code>String#count</code>. 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 = str_duplicate(rb_cString, str); + str = rb_str_dup(str); rb_str_squeeze_bang(argc, argv, str); return str; } @@ -8949,12 +7459,10 @@ rb_str_squeeze(int argc, VALUE *argv, VALUE str) /* * call-seq: - * tr_s!(selector, replacements) -> self or nil + * str.tr_s!(from_str, to_str) -> str or nil * - * Like String#tr_s, but modifies +self+ in place. - * Returns +self+ if any changes were made, +nil+ otherwise. - * - * Related: String#squeeze!. + * Performs <code>String#tr_s</code> processing on <i>str</i> in place, + * returning <i>str</i>, or <code>nil</code> if no changes were made. */ static VALUE @@ -8966,23 +7474,21 @@ rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl) /* * call-seq: - * tr_s(selector, replacements) -> string - * - * Like String#tr, but also squeezes the modified portions of the translated string; - * returns a new string (translated and squeezed). + * str.tr_s(from_str, to_str) -> new_str * - * 'hello'.tr_s('l', 'r') #=> "hero" - * 'hello'.tr_s('el', '-') #=> "h-o" - * 'hello'.tr_s('el', 'hx') #=> "hhxo" - * - * Related: String#squeeze. + * Processes a copy of <i>str</i> as described under <code>String#tr</code>, + * 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 = str_duplicate(rb_cString, str); + str = rb_str_dup(str); tr_trans(str, src, repl, 1); return str; } @@ -8990,11 +7496,15 @@ rb_str_tr_s(VALUE str, VALUE src, VALUE repl) /* * call-seq: - * count(*selectors) -> integer + * str.count([other_str]+) -> integer * - * Returns the total number of characters in +self+ - * that are specified by the given +selectors+ - * (see {Multiple Character Selectors}[rdoc-ref:character_selectors.rdoc@Multiple+Character+Selectors]): + * 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 <code>^</code> is negated. The + * sequence <code>c1-c2</code> means all characters between c1 and c2. The + * backslash character <code>\\</code> can be used to escape <code>^</code> or + * <code>-</code> 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 @@ -9020,7 +7530,6 @@ rb_str_count(int argc, VALUE *argv, VALUE str) char *s, *send; int i; int ascompat; - size_t n = 0; rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); @@ -9028,64 +7537,66 @@ rb_str_count(int argc, VALUE *argv, VALUE str) 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 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 SIZET2NUM(n); - } + 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<argc; i++) { - tstr = argv[i]; - StringValue(tstr); - enc = rb_enc_check(str, tstr); - tr_setup_table(tstr, table, FALSE, &del, &nodel, enc); + tstr = argv[i]; + StringValue(tstr); + enc = rb_enc_check(str, tstr); + tr_setup_table(tstr, table, FALSE, &del, &nodel, enc); } s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return INT2FIX(0); send = RSTRING_END(str); ascompat = rb_enc_asciicompat(enc); + i = 0; while (s < send) { - unsigned int c; + unsigned int c; - if (ascompat && (c = *(unsigned char*)s) < 0x80) { - if (table[c]) { - n++; - } - s++; - } - else { - int clen; - c = rb_enc_codepoint_len(s, send, &clen, enc); - if (tr_find(c, table, del, nodel)) { - n++; - } - s += clen; - } + if (ascompat && (c = *(unsigned char*)s) < 0x80) { + if (table[c]) { + i++; + } + s++; + } + else { + int clen; + c = rb_enc_codepoint_len(s, send, &clen, enc); + if (tr_find(c, table, del, nodel)) { + i++; + } + s += clen; + } } - return SIZET2NUM(n); + return INT2NUM(i); } static VALUE rb_fs_check(VALUE val) { if (!NIL_P(val) && !RB_TYPE_P(val, T_STRING) && !RB_TYPE_P(val, T_REGEXP)) { - val = rb_check_string_type(val); - if (NIL_P(val)) return 0; + val = rb_check_string_type(val); + if (NIL_P(val)) return 0; } return val; } @@ -9111,71 +7622,55 @@ static const char isspacetable[256] = { #define ascii_isspace(c) isspacetable[(unsigned char)(c)] -static long -split_string(VALUE result, VALUE str, long beg, long len, long empty_count) -{ - if (empty_count >= 0 && len == 0) { - return empty_count + 1; - } - if (empty_count > 0) { - /* make different substrings */ - if (result) { - do { - rb_ary_push(result, str_new_empty_String(str)); - } while (--empty_count > 0); - } - else { - do { - rb_yield(str_new_empty_String(str)); - } while (--empty_count > 0); - } - } - str = rb_str_subseq(str, beg, len); - if (result) { - rb_ary_push(result, str); - } - else { - rb_yield(str); - } - return empty_count; -} - -typedef enum { - SPLIT_TYPE_AWK, SPLIT_TYPE_STRING, SPLIT_TYPE_REGEXP, SPLIT_TYPE_CHARS -} split_type_t; - -static split_type_t -literal_split_pattern(VALUE spat, split_type_t default_type) -{ - rb_encoding *enc = STR_ENC_GET(spat); - const char *ptr; - long len; - RSTRING_GETMEM(spat, ptr, len); - if (len == 0) { - /* Special case - split into chars */ - return SPLIT_TYPE_CHARS; - } - else if (rb_enc_asciicompat(enc)) { - if (len == 1 && ptr[0] == ' ') { - return SPLIT_TYPE_AWK; - } - } - else { - int l; - if (rb_enc_ascget(ptr, ptr + len, &l, enc) == ' ' && len == l) { - return SPLIT_TYPE_AWK; - } - } - return default_type; -} - /* * call-seq: - * split(field_sep = $;, limit = 0) -> array - * split(field_sep = $;, limit = 0) {|substring| ... } -> self + * str.split(pattern=nil, [limit]) -> an_array * - * :include: doc/string/split.rdoc + * Divides <i>str</i> into substrings based on a delimiter, returning an array + * of these substrings. * + * If <i>pattern</i> is a <code>String</code>, then its contents are used as + * the delimiter when splitting <i>str</i>. If <i>pattern</i> is a single + * space, <i>str</i> is split on whitespace, with leading whitespace and runs + * of contiguous whitespace characters ignored. + * + * If <i>pattern</i> is a <code>Regexp</code>, <i>str</i> is divided where the + * pattern matches. Whenever the pattern matches a zero-length string, + * <i>str</i> is split into individual characters. If <i>pattern</i> contains + * groups, the respective matches will be returned in the array as well. + * + * If <i>pattern</i> is <code>nil</code>, the value of <code>$;</code> is used. + * If <code>$;</code> is <code>nil</code> (which is the default), <i>str</i> is + * split on whitespace as if ' ' were specified. + * + * If the <i>limit</i> parameter is omitted, trailing null fields are + * suppressed. If <i>limit</i> is a positive number, at most that number + * of split substrings will be returned (captured groups will be returned + * as well, but are not counted towards the limit). + * If <i>limit</i> is <code>1</code>, 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", "", ""] + * + * "1:2:3".split(/(:)()()/, 2) #=> ["1", ":", "", "", "2:3"] + * + * "".split(',', -1) #=> [] */ static VALUE @@ -9184,220 +7679,210 @@ rb_str_split_m(int argc, VALUE *argv, VALUE str) rb_encoding *enc; VALUE spat; VALUE limit; - split_type_t split_type; - long beg, end, i = 0, empty_count = -1; + enum {awk, string, regexp} split_type; + long beg, end, i = 0; int lim = 0; VALUE result, tmp; - result = rb_block_given_p() ? Qfalse : Qnil; 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 result ? rb_ary_new2(0) : str; - tmp = str_duplicate(rb_cString, str); - if (!result) { - rb_yield(tmp); - return str; - } - return rb_ary_new3(1, tmp); - } - i = 1; + 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, rb_str_dup(str)); + } + i = 1; } - if (NIL_P(limit) && !lim) empty_count = 0; enc = STR_ENC_GET(str); - split_type = SPLIT_TYPE_REGEXP; + split_type = regexp; if (!NIL_P(spat)) { - spat = get_pat_quoted(spat, 0); + spat = get_pat_quoted(spat, 0); } else if (NIL_P(spat = rb_fs)) { - split_type = SPLIT_TYPE_AWK; + split_type = awk; } else if (!(spat = rb_fs_check(spat))) { - rb_raise(rb_eTypeError, "value of $; must be String or Regexp"); - } - else { - rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$; is set to non-nil value"); - } - if (split_type != SPLIT_TYPE_AWK) { - switch (BUILTIN_TYPE(spat)) { - case T_REGEXP: - rb_reg_options(spat); /* check if uninitialized */ - tmp = RREGEXP_SRC(spat); - split_type = literal_split_pattern(tmp, SPLIT_TYPE_REGEXP); - if (split_type == SPLIT_TYPE_AWK) { - spat = tmp; - split_type = SPLIT_TYPE_STRING; - } - break; - - case T_STRING: - mustnot_broken(spat); - split_type = literal_split_pattern(spat, SPLIT_TYPE_STRING); - break; - - default: - UNREACHABLE_RETURN(Qnil); - } - } - -#define SPLIT_STR(beg, len) (empty_count = split_string(result, str, beg, len, empty_count)) - + rb_raise(rb_eTypeError, "value of $; must be String or Regexp"); + } + if (split_type != awk) { + 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; + } + } + } + } + + result = rb_ary_new(); beg = 0; - char *ptr = RSTRING_PTR(str); - char *eptr = RSTRING_END(str); - if (split_type == SPLIT_TYPE_AWK) { - char *bptr = ptr; - int skip = 1; - unsigned int c; - - if (result) result = rb_ary_new(); - 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)) { - SPLIT_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)) { - SPLIT_STR(beg, end-beg); - skip = 1; - beg = ptr - bptr; - if (!NIL_P(limit)) ++i; - } - else { - end = ptr - bptr; - } - } - } - } - else if (split_type == SPLIT_TYPE_STRING) { - char *str_start = ptr; - char *substr_start = ptr; - char *sptr = RSTRING_PTR(spat); - long slen = RSTRING_LEN(spat); - - if (result) result = rb_ary_new(); - 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; - } - SPLIT_STR(substr_start - str_start, (ptr+end) - substr_start); - ptr += end + slen; - substr_start = ptr; - if (!NIL_P(limit) && lim <= ++i) break; - } - beg = ptr - str_start; - } - else if (split_type == SPLIT_TYPE_CHARS) { - char *str_start = ptr; - int n; - - if (result) result = rb_ary_new_capa(RSTRING_LEN(str)); - mustnot_broken(str); - enc = rb_enc_get(str); - while (ptr < eptr && - (n = rb_enc_precise_mbclen(ptr, eptr, enc)) > 0) { - SPLIT_STR(ptr - str_start, n); - ptr += n; - if (!NIL_P(limit) && lim <= ++i) break; - } - beg = ptr - str_start; + 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 *str_start = ptr; + char *substr_start = 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, substr_start - str_start, + (ptr+end) - substr_start)); + ptr += end + slen; + substr_start = ptr; + if (!NIL_P(limit) && lim <= ++i) break; + } + beg = ptr - str_start; } else { - if (result) result = rb_ary_new(); - long len = RSTRING_LEN(str); - long start = beg; - long idx; - int last_null = 0; - struct re_registers *regs; - VALUE match = 0; - - for (; rb_reg_search(spat, str, start, 0) >= 0; - (match ? (rb_match_unbusy(match), rb_backref_set(match)) : (void)0)) { - match = rb_backref_get(); - if (!result) rb_match_busy(match); - regs = RMATCH_REGS(match); - end = BEG(0); - if (start == end && BEG(0) == END(0)) { - if (!ptr) { - SPLIT_STR(0, 0); - break; - } - else if (last_null == 1) { - SPLIT_STR(beg, rb_enc_fast_mbclen(ptr+beg, eptr, enc)); - beg = start; - } - 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 (start == len) start++; else - start += rb_enc_fast_mbclen(ptr+start,eptr,enc); - last_null = 1; - continue; - } - } - else { - SPLIT_STR(beg, end-beg); - beg = start = END(0); - } - last_null = 0; - - for (idx=1; idx < regs->num_regs; idx++) { - if (BEG(idx) == -1) continue; - SPLIT_STR(BEG(idx), END(idx)-BEG(idx)); - } - if (!NIL_P(limit) && lim <= ++i) break; - } - if (match) rb_match_unbusy(match); + 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)) { - SPLIT_STR(beg, RSTRING_LEN(str)-beg); + 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 ? result : str; + return result; } VALUE @@ -9410,18 +7895,33 @@ rb_str_split(VALUE str, const char *sep0) return rb_str_split_m(1, &sep, str); } -#define WANTARRAY(m, size) (!rb_block_given_p() ? rb_ary_new_capa(size) : 0) +static int +enumerator_wantarray(const char *method) +{ + if (rb_block_given_p()) { +#if STRING_ENUMERATORS_WANTARRAY + rb_warn("given block not used"); +#else + rb_warning("passing a block to String#%s is deprecated", method); + return 0; +#endif + } + return 1; +} + +#define WANTARRAY(m, size) \ + (enumerator_wantarray(m) ? rb_ary_new_capa(size) : 0) static inline int enumerator_element(VALUE ary, VALUE e) { if (ary) { - rb_ary_push(ary, e); - return 0; + rb_ary_push(ary, e); + return 0; } else { - rb_yield(e); - return 1; + rb_yield(e); + return 1; } } @@ -9432,30 +7932,15 @@ chomp_newline(const char *p, const char *e, rb_encoding *enc) { const char *prev = rb_enc_prev_char(p, e, e, enc); if (rb_enc_is_newline(prev, e, enc)) { - e = prev; - prev = rb_enc_prev_char(p, e, e, enc); - if (prev && rb_enc_ascget(prev, e, NULL, enc) == '\r') - e = prev; + e = prev; + prev = rb_enc_prev_char(p, e, e, enc); + if (prev && rb_enc_ascget(prev, e, NULL, enc) == '\r') + e = prev; } return e; } static VALUE -get_rs(void) -{ - VALUE rs = rb_rs; - if (!NIL_P(rs) && - (!RB_TYPE_P(rs, T_STRING) || - RSTRING_LEN(rs) != 1 || - RSTRING_PTR(rs)[0] != '\n')) { - rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$/ is set to non-default value"); - } - return rs; -} - -#define rb_rs get_rs() - -static VALUE rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, VALUE ary) { rb_encoding *enc; @@ -9465,23 +7950,23 @@ rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, VALUE ary) int rsnewline = 0; if (rb_scan_args(argc, argv, "01:", &rs, &opts) == 0) - rs = rb_rs; + rs = rb_rs; if (!NIL_P(opts)) { - static ID keywords[1]; - if (!keywords[0]) { - keywords[0] = rb_intern_const("chomp"); - } - rb_get_kwargs(opts, keywords, 0, 1, &chomp); - chomp = (!UNDEF_P(chomp) && RTEST(chomp)); + static ID keywords[1]; + if (!keywords[0]) { + keywords[0] = rb_intern_const("chomp"); + } + rb_get_kwargs(opts, keywords, 0, 1, &chomp); + chomp = (chomp != Qundef && RTEST(chomp)); } if (NIL_P(rs)) { - if (!ENUM_ELEM(ary, str)) { - return ary; - } - else { - return orig; - } + if (!ENUM_ELEM(ary, str)) { + return ary; + } + else { + return orig; + } } if (!RSTRING_LEN(str)) goto end; @@ -9493,115 +7978,138 @@ rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, VALUE ary) rslen = RSTRING_LEN(rs); if (rs == rb_default_rs) - enc = rb_enc_get(str); + enc = rb_enc_get(str); else - enc = rb_enc_check(str, rs); + enc = rb_enc_check(str, rs); if (rslen == 0) { - /* paragraph mode */ - int n; - const char *eol = NULL; - subend = subptr; - while (subend < pend) { - long chomp_rslen = 0; - do { - if (rb_enc_ascget(subend, pend, &n, enc) != '\r') - n = 0; - rslen = n + rb_enc_mbclen(subend + n, pend, enc); - if (rb_enc_is_newline(subend + n, pend, enc)) { - if (eol == subend) break; - subend += rslen; - if (subptr) { - eol = subend; - chomp_rslen = -rslen; - } - } - else { - if (!subptr) subptr = subend; - subend += rslen; - } - rslen = 0; - } while (subend < pend); - if (!subptr) break; - if (rslen == 0) chomp_rslen = 0; - line = rb_str_subseq(str, subptr - ptr, - subend - subptr + (chomp ? chomp_rslen : rslen)); - if (ENUM_ELEM(ary, line)) { - str_mod_check(str, ptr, len); - } - subptr = eol = NULL; - } - goto end; + /* paragraph mode */ + int n; + const char *eol = NULL; + subend = subptr; + while (subend < pend) { + do { + if (rb_enc_ascget(subend, pend, &n, enc) != '\r') + n = 0; + rslen = n + rb_enc_mbclen(subend + n, pend, enc); + if (rb_enc_is_newline(subend + n, pend, enc)) { + if (eol == subend) break; + subend += rslen; + if (subptr) eol = subend; + } + else { + if (!subptr) subptr = subend; + subend += rslen; + } + rslen = 0; + } while (subend < pend); + if (!subptr) break; + line = rb_str_subseq(str, subptr - ptr, + subend - subptr + (chomp ? 0 : rslen)); + if (ENUM_ELEM(ary, line)) { + str_mod_check(str, ptr, len); + } + subptr = eol = NULL; + } + goto end; } else { - rsptr = RSTRING_PTR(rs); - if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) && - rb_enc_is_newline(rsptr, rsptr + RSTRING_LEN(rs), enc)) { - rsnewline = 1; - } + rsptr = RSTRING_PTR(rs); + if (RSTRING_LEN(rs) == rb_enc_mbminlen(enc) && + rb_enc_is_newline(rsptr, rsptr + RSTRING_LEN(rs), enc)) { + rsnewline = 1; + } } if ((rs == rb_default_rs) && !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); + 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 (chomp) { - if (rsnewline) { - subend = chomp_newline(subptr, subend, enc); - } - else { - subend -= rslen; - } - } - line = rb_str_subseq(str, subptr - ptr, subend - subptr); - if (ENUM_ELEM(ary, line)) { - str_mod_check(str, ptr, len); - } - subptr = hit; + 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 (chomp) { + if (rsnewline) { + subend = chomp_newline(subptr, subend, enc); + } + else { + subend -= rslen; + } + } + line = rb_str_subseq(str, subptr - ptr, subend - subptr); + if (ENUM_ELEM(ary, line)) { + str_mod_check(str, ptr, len); + } + subptr = hit; } if (subptr != pend) { - if (chomp) { - if (rsnewline) { - pend = chomp_newline(subptr, pend, enc); - } - else if (pend - subptr >= rslen && - memcmp(pend - rslen, rsptr, rslen) == 0) { - pend -= rslen; - } - } - line = rb_str_subseq(str, subptr - ptr, pend - subptr); - ENUM_ELEM(ary, line); - RB_GC_GUARD(str); + if (chomp) { + if (rsnewline) { + pend = chomp_newline(subptr, pend, enc); + } + else if (pend - subptr >= rslen && + memcmp(pend - rslen, rsptr, rslen) == 0) { + pend -= rslen; + } + } + line = rb_str_subseq(str, subptr - ptr, pend - subptr); + ENUM_ELEM(ary, line); + RB_GC_GUARD(str); } end: if (ary) - return ary; + return ary; else - return orig; + return orig; } /* * call-seq: - * each_line(line_sep = $/, chomp: false) {|substring| ... } -> self - * each_line(line_sep = $/, chomp: false) -> enumerator + * str.each_line(separator=$/ [, getline_args]) {|substr| block } -> str + * str.each_line(separator=$/ [, getline_args]) -> an_enumerator + * + * Splits <i>str</i> using the supplied parameter as the record + * separator (<code>$/</code> 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. + * + * See IO.readlines for details about getline_args. + * + * 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} * - * :include: doc/string/each_line.rdoc + * <em>produces:</em> * + * Example one + * "hello\n" + * "world" + * Example two + * "hel" + * "l" + * "o\nworl" + * "d" + * Example three + * "hello\n\n" + * "world" */ static VALUE @@ -9613,11 +8121,14 @@ rb_str_each_line(int argc, VALUE *argv, VALUE str) /* * call-seq: - * lines(Line_sep = $/, chomp: false) -> array_of_strings + * str.lines(separator=$/) -> an_array * - * Forms substrings ("lines") of +self+ according to the given arguments - * (see String#each_line for details); returns the lines in an array. + * Returns an array of lines in <i>str</i> split using the supplied + * record separator (<code>$/</code> by default). This is a + * shorthand for <code>str.each_line(separator).to_a</code>. * + * If a block is given, which is a deprecated form, works the same as + * <code>each_line</code>. */ static VALUE @@ -9639,21 +8150,27 @@ rb_str_enumerate_bytes(VALUE str, VALUE ary) long i; for (i=0; i<RSTRING_LEN(str); i++) { - ENUM_ELEM(ary, INT2FIX((unsigned char)RSTRING_PTR(str)[i])); + ENUM_ELEM(ary, INT2FIX(RSTRING_PTR(str)[i] & 0xff)); } if (ary) - return ary; + return ary; else - return str; + return str; } /* * call-seq: - * each_byte {|byte| ... } -> self - * each_byte -> enumerator + * str.each_byte {|integer| block } -> str + * str.each_byte -> an_enumerator + * + * Passes each byte in <i>str</i> to the given block, or returns an + * enumerator if no block is given. * - * :include: doc/string/each_byte.rdoc + * "hello".each_byte {|c| print c, ' ' } * + * <em>produces:</em> + * + * 104 101 108 108 111 */ static VALUE @@ -9665,10 +8182,13 @@ rb_str_each_byte(VALUE str) /* * call-seq: - * bytes -> array_of_bytes + * str.bytes -> an_array * - * :include: doc/string/bytes.rdoc + * Returns an array of bytes in <i>str</i>. This is a shorthand for + * <code>str.each_byte.to_a</code>. * + * If a block is given, which is a deprecated form, works the same as + * <code>each_byte</code>. */ static VALUE @@ -9698,31 +8218,37 @@ rb_str_enumerate_chars(VALUE str, VALUE ary) enc = rb_enc_get(str); if (ENC_CODERANGE_CLEAN_P(ENC_CODERANGE(str))) { - for (i = 0; i < len; i += n) { - n = rb_enc_fast_mbclen(ptr + i, ptr + len, enc); - ENUM_ELEM(ary, rb_str_subseq(str, i, n)); - } + for (i = 0; i < len; i += n) { + n = rb_enc_fast_mbclen(ptr + i, ptr + len, enc); + ENUM_ELEM(ary, rb_str_subseq(str, i, n)); + } } else { - for (i = 0; i < len; i += n) { - n = rb_enc_mbclen(ptr + i, ptr + len, enc); - ENUM_ELEM(ary, rb_str_subseq(str, i, n)); - } + for (i = 0; i < len; i += n) { + n = rb_enc_mbclen(ptr + i, ptr + len, enc); + ENUM_ELEM(ary, rb_str_subseq(str, i, n)); + } } RB_GC_GUARD(str); if (ary) - return ary; + return ary; else - return orig; + return orig; } /* * call-seq: - * each_char {|c| ... } -> self - * each_char -> enumerator + * str.each_char {|cstr| block } -> str + * str.each_char -> an_enumerator + * + * Passes each character in <i>str</i> to the given block, or returns + * an enumerator if no block is given. * - * :include: doc/string/each_char.rdoc + * "hello".each_char {|c| print c, ' ' } * + * <em>produces:</em> + * + * h e l l o */ static VALUE @@ -9734,10 +8260,13 @@ rb_str_each_char(VALUE str) /* * call-seq: - * chars -> array_of_characters + * str.chars -> an_array * - * :include: doc/string/chars.rdoc + * Returns an array of characters in <i>str</i>. This is a shorthand + * for <code>str.each_char.to_a</code>. * + * If a block is given, which is a deprecated form, works the same as + * <code>each_char</code>. */ static VALUE @@ -9757,7 +8286,7 @@ rb_str_enumerate_codepoints(VALUE str, VALUE ary) rb_encoding *enc; if (single_byte_optimizable(str)) - return rb_str_enumerate_bytes(str, ary); + return rb_str_enumerate_bytes(str, ary); str = rb_str_new_frozen(str); ptr = RSTRING_PTR(str); @@ -9765,24 +8294,35 @@ rb_str_enumerate_codepoints(VALUE str, VALUE ary) enc = STR_ENC_GET(str); while (ptr < end) { - c = rb_enc_codepoint_len(ptr, end, &n, enc); - ENUM_ELEM(ary, UINT2NUM(c)); - ptr += n; + c = rb_enc_codepoint_len(ptr, end, &n, enc); + ENUM_ELEM(ary, UINT2NUM(c)); + ptr += n; } RB_GC_GUARD(str); if (ary) - return ary; + return ary; else - return orig; + return orig; } /* * call-seq: - * each_codepoint {|integer| ... } -> self - * each_codepoint -> enumerator + * str.each_codepoint {|integer| block } -> str + * str.each_codepoint -> an_enumerator + * + * Passes the <code>Integer</code> ordinal of each character in <i>str</i>, + * also known as a <i>codepoint</i> when applied to Unicode strings to the + * given block. For encodings other than UTF-8/UTF-16(BE|LE)/UTF-32(BE|LE), + * values are directly derived from the binary representation + * of each character. * - * :include: doc/string/each_codepoint.rdoc + * If no block is given, an enumerator is returned instead. * + * "hello\u0639".each_codepoint {|c| print c, ' ' } + * + * <em>produces:</em> + * + * 104 101 108 108 111 1593 */ static VALUE @@ -9794,10 +8334,14 @@ rb_str_each_codepoint(VALUE str) /* * call-seq: - * codepoints -> array_of_integers + * str.codepoints -> an_array * - * :include: doc/string/codepoints.rdoc + * Returns an array of the <code>Integer</code> ordinals of the + * characters in <i>str</i>. This is a shorthand for + * <code>str.each_codepoint.to_a</code>. * + * If a block is given, which is a deprecated form, works the same as + * <code>each_codepoint</code>. */ static VALUE @@ -9811,93 +8355,50 @@ static regex_t * get_reg_grapheme_cluster(rb_encoding *enc) { int encidx = rb_enc_to_index(enc); + regex_t *reg_grapheme_cluster = NULL; + static regex_t *reg_grapheme_cluster_utf8 = NULL; - const OnigUChar source_ascii[] = "\\X"; - const OnigUChar *source = source_ascii; - size_t source_len = sizeof(source_ascii) - 1; - - switch (encidx) { -#define CHARS_16BE(x) (OnigUChar)((x)>>8), (OnigUChar)(x) -#define CHARS_16LE(x) (OnigUChar)(x), (OnigUChar)((x)>>8) -#define CHARS_32BE(x) CHARS_16BE((x)>>16), CHARS_16BE(x) -#define CHARS_32LE(x) CHARS_16LE(x), CHARS_16LE((x)>>16) -#define CASE_UTF(e) \ - case ENCINDEX_UTF_##e: { \ - static const OnigUChar source_UTF_##e[] = {CHARS_##e('\\'), CHARS_##e('X')}; \ - source = source_UTF_##e; \ - source_len = sizeof(source_UTF_##e); \ - break; \ - } - CASE_UTF(16BE); CASE_UTF(16LE); CASE_UTF(32BE); CASE_UTF(32LE); -#undef CASE_UTF -#undef CHARS_16BE -#undef CHARS_16LE -#undef CHARS_32BE -#undef CHARS_32LE + /* synchronize */ + if (encidx == rb_utf8_encindex() && reg_grapheme_cluster_utf8) { + reg_grapheme_cluster = reg_grapheme_cluster_utf8; } - - regex_t *reg_grapheme_cluster; - OnigErrorInfo einfo; - int r = onig_new(®_grapheme_cluster, source, source + source_len, - ONIG_OPTION_DEFAULT, enc, OnigDefaultSyntax, &einfo); - if (r) { - UChar message[ONIG_MAX_ERROR_MESSAGE_LEN]; - onig_error_code_to_str(message, r, &einfo); - rb_fatal("cannot compile grapheme cluster regexp: %s", (char *)message); + if (!reg_grapheme_cluster) { + const OnigUChar source[] = "\\X"; + int r = onig_new(®_grapheme_cluster, source, source + sizeof(source) - 1, + ONIG_OPTION_DEFAULT, enc, OnigDefaultSyntax, NULL); + if (r) { + rb_bug("cannot compile grapheme cluster regexp"); + } + if (encidx == rb_utf8_encindex()) { + reg_grapheme_cluster_utf8 = reg_grapheme_cluster; + } } - return reg_grapheme_cluster; } -static regex_t * -get_cached_reg_grapheme_cluster(rb_encoding *enc) -{ - int encidx = rb_enc_to_index(enc); - static regex_t *reg_grapheme_cluster_utf8 = NULL; - - if (encidx == rb_utf8_encindex()) { - if (!reg_grapheme_cluster_utf8) { - reg_grapheme_cluster_utf8 = get_reg_grapheme_cluster(enc); - } - - return reg_grapheme_cluster_utf8; - } - - return NULL; -} - static VALUE rb_str_each_grapheme_cluster_size(VALUE str, VALUE args, VALUE eobj) { size_t grapheme_cluster_count = 0; - rb_encoding *enc = get_encoding(str); + regex_t *reg_grapheme_cluster = NULL; + rb_encoding *enc = rb_enc_from_index(ENCODING_GET(str)); const char *ptr, *end; if (!rb_enc_unicode_p(enc)) { - return rb_str_length(str); - } - - bool cached_reg_grapheme_cluster = true; - regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc); - if (!reg_grapheme_cluster) { - reg_grapheme_cluster = get_reg_grapheme_cluster(enc); - cached_reg_grapheme_cluster = false; + return rb_str_length(str); } + reg_grapheme_cluster = get_reg_grapheme_cluster(enc); ptr = RSTRING_PTR(str); end = RSTRING_END(str); while (ptr < end) { - OnigPosition len = onig_match(reg_grapheme_cluster, - (const OnigUChar *)ptr, (const OnigUChar *)end, - (const OnigUChar *)ptr, NULL, 0); - if (len <= 0) break; - grapheme_cluster_count++; - ptr += len; - } - - if (!cached_reg_grapheme_cluster) { - onig_free(reg_grapheme_cluster); + OnigPosition len = onig_match(reg_grapheme_cluster, + (const OnigUChar *)ptr, (const OnigUChar *)end, + (const OnigUChar *)ptr, NULL, 0); + if (len <= 0) break; + grapheme_cluster_count++; + ptr += len; } return SIZET2NUM(grapheme_cluster_count); @@ -9907,51 +8408,46 @@ static VALUE rb_str_enumerate_grapheme_clusters(VALUE str, VALUE ary) { VALUE orig = str; - rb_encoding *enc = get_encoding(str); + regex_t *reg_grapheme_cluster = NULL; + rb_encoding *enc = rb_enc_from_index(ENCODING_GET(str)); const char *ptr0, *ptr, *end; if (!rb_enc_unicode_p(enc)) { - return rb_str_enumerate_chars(str, ary); + return rb_str_enumerate_chars(str, ary); } if (!ary) str = rb_str_new_frozen(str); - - bool cached_reg_grapheme_cluster = true; - regex_t *reg_grapheme_cluster = get_cached_reg_grapheme_cluster(enc); - if (!reg_grapheme_cluster) { - reg_grapheme_cluster = get_reg_grapheme_cluster(enc); - cached_reg_grapheme_cluster = false; - } - + reg_grapheme_cluster = get_reg_grapheme_cluster(enc); ptr0 = ptr = RSTRING_PTR(str); end = RSTRING_END(str); while (ptr < end) { - OnigPosition len = onig_match(reg_grapheme_cluster, - (const OnigUChar *)ptr, (const OnigUChar *)end, - (const OnigUChar *)ptr, NULL, 0); - if (len <= 0) break; - ENUM_ELEM(ary, rb_str_subseq(str, ptr-ptr0, len)); - ptr += len; + OnigPosition len = onig_match(reg_grapheme_cluster, + (const OnigUChar *)ptr, (const OnigUChar *)end, + (const OnigUChar *)ptr, NULL, 0); + if (len <= 0) break; + ENUM_ELEM(ary, rb_str_subseq(str, ptr-ptr0, len)); + ptr += len; } - - if (!cached_reg_grapheme_cluster) { - onig_free(reg_grapheme_cluster); - } - RB_GC_GUARD(str); if (ary) - return ary; + return ary; else - return orig; + return orig; } /* * call-seq: - * each_grapheme_cluster {|gc| ... } -> self - * each_grapheme_cluster -> enumerator + * str.each_grapheme_cluster {|cstr| block } -> str + * str.each_grapheme_cluster -> an_enumerator * - * :include: doc/string/each_grapheme_cluster.rdoc + * Passes each grapheme cluster in <i>str</i> to the given block, or returns + * an enumerator if no block is given. + * Unlike String#each_char, this enumerates by grapheme clusters defined by + * Unicode Standard Annex #29 http://unicode.org/reports/tr29/ + * + * "a\u0300".each_char.to_a.size #=> 2 + * "a\u0300".each_grapheme_cluster.to_a.size #=> 1 * */ @@ -9964,10 +8460,13 @@ rb_str_each_grapheme_cluster(VALUE str) /* * call-seq: - * grapheme_clusters -> array_of_grapheme_clusters + * str.grapheme_clusters -> an_array * - * :include: doc/string/grapheme_clusters.rdoc + * Returns an array of grapheme clusters in <i>str</i>. This is a shorthand + * for <code>str.each_grapheme_cluster.to_a</code>. * + * If a block is given, which is a deprecated form, works the same as + * <code>each_grapheme_cluster</code>. */ static VALUE @@ -9985,24 +8484,23 @@ chopped_length(VALUE str) beg = RSTRING_PTR(str); end = beg + RSTRING_LEN(str); - if (beg >= end) return 0; + 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; + 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: - * chop! -> self or nil - * - * Like String#chop, but modifies +self+ in place; - * returns +nil+ if +self+ is empty, +self+ otherwise. + * str.chop! -> str or nil * - * Related: String#chomp!. + * Processes <i>str</i> as for <code>String#chop</code>, returning <i>str</i>, + * or <code>nil</code> if <i>str</i> is the empty string. See also + * <code>String#chomp!</code>. */ static VALUE @@ -10010,14 +8508,14 @@ 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; + 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; } @@ -10025,10 +8523,19 @@ rb_str_chop_bang(VALUE str) /* * call-seq: - * chop -> new_string + * str.chop -> new_str * - * :include: doc/string/chop.rdoc + * Returns a new <code>String</code> with the last character removed. If the + * string ends with <code>\r\n</code>, both characters are removed. Applying + * <code>chop</code> to an empty string returns an empty + * string. <code>String#chomp</code> 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 @@ -10037,37 +8544,6 @@ rb_str_chop(VALUE str) return rb_str_subseq(str, 0, chopped_length(str)); } -static long -smart_chomp(VALUE str, const char *e, const char *p) -{ - rb_encoding *enc = rb_enc_get(str); - if (rb_enc_mbminlen(enc) > 1) { - const char *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; -} static long chompped_length(VALUE str, VALUE rs) @@ -10082,61 +8558,88 @@ chompped_length(VALUE str, VALUE rs) if (len == 0) return 0; e = p + len; if (rs == rb_default_rs) { - return smart_chomp(str, e, p); + 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 (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') - return smart_chomp(str, e, p); - } - else { - if (rb_enc_is_newline(rsptr, rsptr+rslen, enc)) - return smart_chomp(str, e, p); - } + 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; + return len; } pp = e - rslen; if (p[len-1] == newline && - (rslen <= 1 || - memcmp(rsptr, pp, rslen) == 0)) { - if (at_char_boundary(p, pp, e, enc)) - return len - rslen; - RB_GC_GUARD(rs); + (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; } @@ -10144,19 +8647,19 @@ chompped_length(VALUE str, VALUE rs) /*! * Returns the separator for arguments of rb_str_chomp. * - * @return returns rb_rs ($/) as default, the default value of rb_rs ($/) is "\n". + * @return returns rb_ps ($/) as default, the default value of rb_ps ($/) is "\n". */ 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; + VALUE rs = argv[0]; + if (!NIL_P(rs)) StringValue(rs); + return rs; } else { - return rb_rs; + return rb_rs; } } @@ -10170,18 +8673,17 @@ rb_str_chomp_string(VALUE str, VALUE rs) 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); + ENC_CODERANGE_CLEAR(str); } return str; } /* * call-seq: - * chomp!(line_sep = $/) -> self or nil - * - * Like String#chomp, but modifies +self+ in place; - * returns +nil+ if no modification made, +self+ otherwise. + * str.chomp!(separator=$/) -> str or nil * + * Modifies <i>str</i> in place as described for <code>String#chomp</code>, + * returning <i>str</i>, or <code>nil</code> if no modifications were made. */ static VALUE @@ -10189,7 +8691,7 @@ rb_str_chomp_bang(int argc, VALUE *argv, VALUE str) { VALUE rs; str_modifiable(str); - if (RSTRING_LEN(str) == 0 && argc < 2) return Qnil; + if (RSTRING_LEN(str) == 0) return Qnil; rs = chomp_rs(argc, argv); if (NIL_P(rs)) return Qnil; return rb_str_chomp_string(str, rs); @@ -10198,17 +8700,31 @@ rb_str_chomp_bang(int argc, VALUE *argv, VALUE str) /* * call-seq: - * chomp(line_sep = $/) -> new_string + * str.chomp(separator=$/) -> new_str * - * :include: doc/string/chomp.rdoc + * Returns a new <code>String</code> with the given record separator removed + * from the end of <i>str</i> (if present). If <code>$/</code> has not been + * changed from the default Ruby record separator, then <code>chomp</code> also + * removes carriage return characters (that is it will remove <code>\n</code>, + * <code>\r</code>, and <code>\r\n</code>). If <code>$/</code> 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 str_duplicate(rb_cString, str); + if (NIL_P(rs)) return rb_str_dup(str); return rb_str_subseq(str, 0, chompped_length(str, rs)); } @@ -10221,28 +8737,33 @@ lstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc) /* remove spaces at head */ if (single_byte_optimizable(str)) { - while (s < e && (*s == '\0' || ascii_isspace(*s))) s++; + while (s < e && ascii_isspace(*s)) s++; } else { - while (s < e) { - int n; - unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); + while (s < e) { + int n; + unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); - if (cc && !rb_isspace(cc)) break; - s += n; - } + if (!rb_isspace(cc)) break; + s += n; + } } return s - start; } /* * call-seq: - * lstrip! -> self or nil + * str.lstrip! -> self or nil + * + * Removes leading whitespace from <i>str</i>, returning <code>nil</code> if no + * change was made. See also <code>String#rstrip!</code> and + * <code>String#strip!</code>. * - * Like String#lstrip, except that any modifications are made in +self+; - * returns +self+ if any modification are made, +nil+ otherwise. + * Refer to <code>strip</code> for the definition of whitespace. * - * Related: String#rstrip!, String#strip!. + * " hello ".lstrip! #=> "hello " + * "hello ".lstrip! #=> nil + * "hello".lstrip! #=> nil */ static VALUE @@ -10257,12 +8778,14 @@ rb_str_lstrip_bang(VALUE 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); - TERM_FILL(start+len, rb_enc_mbminlen(enc)); - return str; + 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; } @@ -10270,17 +8793,15 @@ rb_str_lstrip_bang(VALUE str) /* * call-seq: - * lstrip -> new_string + * str.lstrip -> new_str * - * Returns a copy of +self+ with leading whitespace removed; - * see {Whitespace in Strings}[rdoc-ref:String@Whitespace+in+Strings]: + * Returns a copy of <i>str</i> with leading whitespace removed. See also + * <code>String#rstrip</code> and <code>String#strip</code>. * - * whitespace = "\x00\t\n\v\f\r " - * s = whitespace + 'abc' + whitespace - * s # => "\u0000\t\n\v\f\r abc\u0000\t\n\v\f\r " - * s.lstrip # => "abc\u0000\t\n\v\f\r " + * Refer to <code>strip</code> for the definition of whitespace. * - * Related: String#rstrip, String#strip. + * " hello ".lstrip #=> "hello " + * "hello".lstrip #=> "hello" */ static VALUE @@ -10290,7 +8811,7 @@ rb_str_lstrip(VALUE str) long len, loffset; RSTRING_GETMEM(str, start, len); loffset = lstrip_offset(str, start, start+len, STR_ENC_GET(str)); - if (loffset <= 0) return str_duplicate(rb_cString, str); + if (loffset <= 0) return rb_str_dup(str); return rb_str_subseq(str, loffset, len - loffset); } @@ -10300,37 +8821,39 @@ rstrip_offset(VALUE str, const char *s, const char *e, rb_encoding *enc) const char *t; rb_str_check_dummy_enc(enc); - if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) { - rb_raise(rb_eEncCompatError, "invalid byte sequence in %s", rb_enc_name(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--; + unsigned char c; + while (s < t && ((c = *(t-1)) == '\0' || ascii_isspace(c))) t--; } else { - char *tp; + 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; - } + unsigned int c = rb_enc_codepoint(tp, e, enc); + if (c && !rb_isspace(c)) break; + t = tp; + } } return e - t; } /* * call-seq: - * rstrip! -> self or nil + * str.rstrip! -> self or nil + * + * Removes trailing whitespace from <i>str</i>, returning <code>nil</code> if + * no change was made. See also <code>String#lstrip!</code> and + * <code>String#strip!</code>. * - * Like String#rstrip, except that any modifications are made in +self+; - * returns +self+ if any modification are made, +nil+ otherwise. + * Refer to <code>strip</code> for the definition of whitespace. * - * Related: String#lstrip!, String#strip!. + * " hello ".rstrip! #=> " hello" + * " hello".rstrip! #=> nil + * "hello".rstrip! #=> nil */ static VALUE @@ -10345,11 +8868,13 @@ rb_str_rstrip_bang(VALUE str) RSTRING_GETMEM(str, start, olen); roffset = rstrip_offset(str, start, start+olen, enc); if (roffset > 0) { - long len = olen - roffset; + long len = olen - roffset; - STR_SET_LEN(str, len); - TERM_FILL(start+len, rb_enc_mbminlen(enc)); - return str; + STR_SET_LEN(str, len); +#if !SHARABLE_MIDDLE_SUBSTRING + TERM_FILL(start+len, rb_enc_mbminlen(enc)); +#endif + return str; } return Qnil; } @@ -10357,17 +8882,15 @@ rb_str_rstrip_bang(VALUE str) /* * call-seq: - * rstrip -> new_string + * str.rstrip -> new_str * - * Returns a copy of the receiver with trailing whitespace removed; - * see {Whitespace in Strings}[rdoc-ref:String@Whitespace+in+Strings]: + * Returns a copy of <i>str</i> with trailing whitespace removed. See also + * <code>String#lstrip</code> and <code>String#strip</code>. * - * whitespace = "\x00\t\n\v\f\r " - * s = whitespace + 'abc' + whitespace - * s # => "\u0000\t\n\v\f\r abc\u0000\t\n\v\f\r " - * s.rstrip # => "\u0000\t\n\v\f\r abc" + * Refer to <code>strip</code> for the definition of whitespace. * - * Related: String#lstrip, String#strip. + * " hello ".rstrip #=> " hello" + * "hello".rstrip #=> "hello" */ static VALUE @@ -10381,19 +8904,19 @@ rb_str_rstrip(VALUE str) RSTRING_GETMEM(str, start, olen); roffset = rstrip_offset(str, start, start+olen, enc); - if (roffset <= 0) return str_duplicate(rb_cString, str); + if (roffset <= 0) return rb_str_dup(str); return rb_str_subseq(str, 0, olen-roffset); } /* * call-seq: - * strip! -> self or nil + * str.strip! -> str or nil * - * Like String#strip, except that any modifications are made in +self+; - * returns +self+ if any modification are made, +nil+ otherwise. + * Removes leading and trailing whitespace from <i>str</i>. Returns + * <code>nil</code> if <i>str</i> was not altered. * - * Related: String#lstrip!, String#strip!. + * Refer to <code>strip</code> for the definition of whitespace. */ static VALUE @@ -10410,14 +8933,16 @@ rb_str_strip_bang(VALUE str) 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); - TERM_FILL(start+len, rb_enc_mbminlen(enc)); - return str; + 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; } @@ -10425,17 +8950,16 @@ rb_str_strip_bang(VALUE str) /* * call-seq: - * strip -> new_string + * str.strip -> new_str * - * Returns a copy of the receiver with leading and trailing whitespace removed; - * see {Whitespace in Strings}[rdoc-ref:String@Whitespace+in+Strings]: + * Returns a copy of <i>str</i> with leading and trailing whitespace removed. * - * whitespace = "\x00\t\n\v\f\r " - * s = whitespace + 'abc' + whitespace - * s # => "\u0000\t\n\v\f\r abc\u0000\t\n\v\f\r " - * s.strip # => "abc" + * Whitespace is defined as any of the following characters: + * null, horizontal tab, line feed, vertical tab, form feed, carriage return, space. * - * Related: String#lstrip, String#rstrip. + * " hello ".strip #=> "hello" + * "\tgoodbye\r\n".strip #=> "goodbye" + * "\x00\t\n\v\f\r ".strip #=> "" */ static VALUE @@ -10449,104 +8973,92 @@ rb_str_strip(VALUE str) loffset = lstrip_offset(str, start, start+olen, enc); roffset = rstrip_offset(str, start+loffset, start+olen, enc); - if (loffset <= 0 && roffset <= 0) return str_duplicate(rb_cString, str); + 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, int set_backref_str) { - VALUE result = Qnil; + VALUE result, match; + struct re_registers *regs; + int i; long end, pos = rb_pat_search(pat, str, *start, set_backref_str); if (pos >= 0) { - VALUE match; - struct re_registers *regs; - if (BUILTIN_TYPE(pat) == T_STRING) { - regs = NULL; - end = pos + RSTRING_LEN(pat); - } - else { - match = rb_backref_get(); - regs = RMATCH_REGS(match); - pos = BEG(0); - end = END(0); - } - - if (pos == end) { - rb_encoding *enc = STR_ENC_GET(str); - /* - * Always consume at least one character of the input string - */ - if (RSTRING_LEN(str) > end) - *start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end, - RSTRING_END(str), enc); - else - *start = end + 1; - } - else { - *start = end; - } - - if (!regs || regs->num_regs == 1) { - result = rb_str_subseq(str, pos, end - pos); - return result; - } - else { - result = rb_ary_new2(regs->num_regs); - for (int i = 1; i < regs->num_regs; i++) { - VALUE s = Qnil; - if (BEG(i) >= 0) { - s = rb_str_subseq(str, BEG(i), END(i)-BEG(i)); - } - - rb_ary_push(result, s); - } - } - - RB_GC_GUARD(match); + if (BUILTIN_TYPE(pat) == T_STRING) { + regs = NULL; + end = pos + RSTRING_LEN(pat); + } + else { + match = rb_backref_get(); + regs = RMATCH_REGS(match); + pos = BEG(0); + end = END(0); + } + if (pos == end) { + rb_encoding *enc = STR_ENC_GET(str); + /* + * Always consume at least one character of the input string + */ + if (RSTRING_LEN(str) > end) + *start = end + rb_enc_fast_mbclen(RSTRING_PTR(str) + end, + RSTRING_END(str), enc); + else + *start = end + 1; + } + else { + *start = end; + } + if (!regs || regs->num_regs == 1) { + result = rb_str_subseq(str, pos, end - pos); + OBJ_INFECT(result, pat); + return result; + } + result = rb_ary_new2(regs->num_regs); + for (i=1; i < regs->num_regs; i++) { + VALUE s = Qnil; + if (BEG(i) >= 0) { + s = rb_str_subseq(str, BEG(i), END(i)-BEG(i)); + OBJ_INFECT(s, pat); + } + rb_ary_push(result, s); + } + + return result; } - - return result; + return Qnil; } /* * call-seq: - * scan(string_or_regexp) -> array - * scan(string_or_regexp) {|matches| ... } -> self - * - * Matches a pattern against +self+; the pattern is: - * - * - +string_or_regexp+ itself, if it is a Regexp. - * - <tt>Regexp.quote(string_or_regexp)</tt>, if +string_or_regexp+ is a string. + * str.scan(pattern) -> array + * str.scan(pattern) {|match, ...| block } -> str * - * Iterates through +self+, generating a collection of matching results: + * Both forms iterate through <i>str</i>, matching the pattern (which may be a + * <code>Regexp</code> or a <code>String</code>). 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, <code>$&</code>. If the pattern contains groups, each + * individual result is itself an array containing one entry per group. * - * - If the pattern contains no groups, each result is the - * matched string, <code>$&</code>. - * - If the pattern contains groups, each result is 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"]] * - * With no block given, returns an array of the results: + * And the block form: * - * s = 'cruel world' - * s.scan(/\w+/) # => ["cruel", "world"] - * s.scan(/.../) # => ["cru", "el ", "wor"] - * s.scan(/(...)/) # => [["cru"], ["el "], ["wor"]] - * s.scan(/(..)(..)/) # => [["cr", "ue"], ["l ", "wo"]] + * a.scan(/\w+/) {|w| print "<<#{w}>> " } + * print "\n" + * a.scan(/(.)(.)/) {|x,y| print y, x } + * print "\n" * - * With a block given, calls the block with each result; returns +self+: - * - * s.scan(/\w+/) {|w| print "<<#{w}>> " } - * print "\n" - * s.scan(/(.)(.)/) {|x,y| print y, x } - * print "\n" - * - * Output: + * <em>produces:</em> * * <<cruel>> <<world>> * rceu lowlr - * */ static VALUE @@ -10560,23 +9072,23 @@ rb_str_scan(VALUE str, VALUE pat) pat = get_pat_quoted(pat, 1); mustnot_broken(str); if (!rb_block_given_p()) { - VALUE ary = rb_ary_new(); + VALUE ary = rb_ary_new(); - while (!NIL_P(result = scan_once(str, pat, &start, 0))) { - last = prev; - prev = start; - rb_ary_push(ary, result); - } - if (last >= 0) rb_pat_search(pat, str, last, 1); - else rb_backref_set(Qnil); - return ary; + while (!NIL_P(result = scan_once(str, pat, &start, 0))) { + last = prev; + prev = start; + rb_ary_push(ary, result); + } + if (last >= 0) rb_pat_search(pat, str, last, 1); + else rb_backref_set(Qnil); + return ary; } while (!NIL_P(result = scan_once(str, pat, &start, 1))) { - last = prev; - prev = start; - rb_yield(result); - str_mod_check(str, p, len); + 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; @@ -10585,20 +9097,16 @@ rb_str_scan(VALUE str, VALUE pat) /* * call-seq: - * hex -> integer + * str.hex -> integer * - * Interprets the leading substring of +self+ as a string of hexadecimal digits + * Treats leading characters from <i>str</i> as a string of hexadecimal digits * (with an optional sign and an optional <code>0x</code>) and returns the - * corresponding number; - * returns zero if there is no such leading substring: - * - * '0x0a'.hex # => 10 - * '-1234'.hex # => -4660 - * '0'.hex # => 0 - * 'non-numeric'.hex # => 0 - * - * Related: String#oct. + * corresponding number. Zero is returned on error. * + * "0x0a".hex #=> 10 + * "-1234".hex #=> -4660 + * "0".hex #=> 0 + * "wombat".hex #=> 0 */ static VALUE @@ -10610,22 +9118,19 @@ rb_str_hex(VALUE str) /* * call-seq: - * oct -> integer - * - * Interprets the leading substring of +self+ as a string of octal digits - * (with an optional sign) and returns the corresponding number; - * returns zero if there is no such leading substring: - * - * '123'.oct # => 83 - * '-377'.oct # => -255 - * '0377non-numeric'.oct # => 255 - * 'non-numeric'.oct # => 0 + * str.oct -> integer * - * If +self+ starts with <tt>0</tt>, radix indicators are honored; - * see Kernel#Integer. + * Treats leading characters of <i>str</i> as a string of octal digits (with an + * optional sign) and returns the corresponding number. Returns 0 if the + * conversion fails. * - * Related: String#hex. + * "123".oct #=> 83 + * "-377".oct #=> -255 + * "bad".oct #=> 0 + * "0377bad".oct #=> 255 * + * If +str+ starts with <code>0</code>, radix indicators are honored. + * See Kernel#Integer. */ static VALUE @@ -10634,78 +9139,22 @@ rb_str_oct(VALUE str) return rb_str_to_inum(str, -8, FALSE); } -#ifndef HAVE_CRYPT_R -# include "ruby/thread_native.h" -# include "ruby/atomic.h" - -static struct { - rb_nativethread_lock_t lock; -} crypt_mutex = {PTHREAD_MUTEX_INITIALIZER}; - -static void -crypt_mutex_initialize(void) -{ -} -#endif /* * call-seq: - * crypt(salt_str) -> new_string - * - * Returns the string generated by calling <code>crypt(3)</code> - * standard library function with <code>str</code> and - * <code>salt_str</code>, in this order, as its arguments. Please do - * not use this method any longer. It is legacy; provided only for - * backward compatibility with ruby scripts in earlier days. It is - * bad to use in contemporary programs for several reasons: - * - * * Behaviour of C's <code>crypt(3)</code> depends on the OS it is - * run. The generated string lacks data portability. - * - * * On some OSes such as Mac OS, <code>crypt(3)</code> never fails - * (i.e. silently ends up in unexpected results). + * str.crypt(salt_str) -> new_str * - * * On some OSes such as Mac OS, <code>crypt(3)</code> is not - * thread safe. + * Applies a one-way cryptographic hash to <i>str</i> by invoking the + * standard library function <code>crypt(3)</code> with the given + * salt string. While the format and the result are system and + * implementation dependent, using a salt matching the regular + * expression <code>\A[a-zA-Z0-9./]{2}</code> should be valid and + * safe on any platform, in which only the first two characters are + * significant. * - * * So-called "traditional" usage of <code>crypt(3)</code> is very - * very very weak. According to its manpage, Linux's traditional - * <code>crypt(3)</code> output has only 2**56 variations; too - * easy to brute force today. And this is the default behaviour. - * - * * In order to make things robust some OSes implement so-called - * "modular" usage. To go through, you have to do a complex - * build-up of the <code>salt_str</code> parameter, by hand. - * Failure in generation of a proper salt string tends not to - * yield any errors; typos in parameters are normally not - * detectable. - * - * * For instance, in the following example, the second invocation - * of String#crypt is wrong; it has a typo in "round=" (lacks - * "s"). However the call does not fail and something unexpected - * is generated. - * - * "foo".crypt("$5$rounds=1000$salt$") # OK, proper usage - * "foo".crypt("$5$round=1000$salt$") # Typo not detected - * - * * Even in the "modular" mode, some hash functions are considered - * archaic and no longer recommended at all; for instance module - * <code>$1$</code> is officially abandoned by its author: see - * http://phk.freebsd.dk/sagas/md5crypt_eol/ . For another - * instance module <code>$3$</code> is considered completely - * broken: see the manpage of FreeBSD. - * - * * On some OS such as Mac OS, there is no modular mode. Yet, as - * written above, <code>crypt(3)</code> on Mac OS never fails. - * This means even if you build up a proper salt string it - * generates a traditional DES hash anyways, and there is no way - * for you to be aware of. - * - * "foo".crypt("$5$rounds=1000$salt$") # => "$5fNPQMxC5j6." - * - * If for some reason you cannot migrate to other secure contemporary - * password hashing algorithms, install the string-crypt gem and - * <code>require 'string/crypt'</code> to continue using it. + * 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 @@ -10717,7 +9166,7 @@ rb_str_crypt(VALUE str, VALUE salt) # define CRYPT_END() ALLOCV_END(databuf) #else extern char *crypt(const char *, const char *); -# define CRYPT_END() rb_nativethread_lock_unlock(&crypt_mutex.lock) +# define CRYPT_END() (void)0 #endif VALUE result; const char *s, *saltp; @@ -10729,18 +9178,20 @@ rb_str_crypt(VALUE str, VALUE salt) StringValue(salt); mustnot_wchar(str); mustnot_wchar(salt); - s = StringValueCStr(str); - saltp = RSTRING_PTR(salt); - if (RSTRING_LEN(salt) < 2 || !saltp[0] || !saltp[1]) { - rb_raise(rb_eArgError, "salt too short (need >=2 bytes)"); + if (RSTRING_LEN(salt) < 2) { + short_salt: + rb_raise(rb_eArgError, "salt too short (need >=2 bytes)"); } + s = StringValueCStr(str); + 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; + salt_8bit_clean[0] = saltp[0] & 0x7f; + salt_8bit_clean[1] = saltp[1] & 0x7f; + salt_8bit_clean[2] = '\0'; + saltp = salt_8bit_clean; } #endif #ifdef HAVE_CRYPT_R @@ -10750,30 +9201,30 @@ rb_str_crypt(VALUE str, VALUE salt) # endif res = crypt_r(s, saltp, data); #else - crypt_mutex_initialize(); - rb_nativethread_lock_lock(&crypt_mutex.lock); res = crypt(s, saltp); #endif if (!res) { - int err = errno; - CRYPT_END(); - rb_syserr_fail(err, "crypt"); + int err = errno; + CRYPT_END(); + rb_syserr_fail(err, "crypt"); } result = rb_str_new_cstr(res); CRYPT_END(); + FL_SET_RAW(result, OBJ_TAINTED_RAW(str) | OBJ_TAINTED_RAW(salt)); return result; } /* * call-seq: - * ord -> integer + * str.ord -> integer * - * :include: doc/string/ord.rdoc + * Return the <code>Integer</code> ordinal of a one-character string. * + * "a".ord #=> 97 */ -static VALUE +VALUE rb_str_ord(VALUE s) { unsigned int c; @@ -10783,23 +9234,33 @@ rb_str_ord(VALUE s) } /* * call-seq: - * sum(n = 16) -> integer - * - * :include: doc/string/sum.rdoc + * str.sum(n=16) -> integer * + * Returns a basic <em>n</em>-bit checksum of the characters in <i>str</i>, + * where <em>n</em> is the optional <code>Integer</code> parameter, defaulting + * to 16. The result is simply the sum of the binary value of each byte in + * <i>str</i> modulo <code>2**n - 1</code>. This is not a particularly good + * checksum. */ static VALUE rb_str_sum(int argc, VALUE *argv, VALUE str) { - int bits = 16; + VALUE vbits; + int bits; char *ptr, *p, *pend; long len; VALUE sum = INT2FIX(0); unsigned long sum0 = 0; - if (rb_check_arity(argc, 0, 1) && (bits = NUM2INT(argv[0])) < 0) { - bits = 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); @@ -10861,18 +9322,18 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag) termlen = rb_enc_mbminlen(enc); width = NUM2LONG(w); if (argc == 2) { - StringValue(pad); - enc = rb_enc_check(str, pad); - f = RSTRING_PTR(pad); - flen = RSTRING_LEN(pad); - fclen = str_strlen(pad, enc); /* rb_enc_check */ - singlebyte = single_byte_optimizable(pad); - if (flen == 0 || fclen == 0) { - rb_raise(rb_eArgError, "zero width padding"); - } + StringValue(pad); + enc = rb_enc_check(str, pad); + f = RSTRING_PTR(pad); + flen = RSTRING_LEN(pad); + fclen = str_strlen(pad, enc); /* rb_enc_check */ + singlebyte = single_byte_optimizable(pad); + if (flen == 0 || fclen == 0) { + rb_raise(rb_eArgError, "zero width padding"); + } } len = str_strlen(str, enc); /* rb_enc_check */ - if (width < 0 || len >= width) return str_duplicate(rb_cString, str); + if (width < 0 || len >= width) return rb_str_dup(str); n = width - len; llen = (jflag == 'l') ? 0 : ((jflag == 'r') ? n : n/2); rlen = n - llen; @@ -10888,7 +9349,7 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag) rb_raise(rb_eArgError, "argument too big"); } len += size; - res = str_enc_new(rb_cString, 0, len, enc); + res = str_new0(rb_obj_class(str), 0, len, termlen); p = RSTRING_PTR(res); if (flen <= 1) { memset(p, *f, llen); @@ -10896,14 +9357,14 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag) } else { while (llen >= fclen) { - memcpy(p,f,flen); - p += flen; - 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; @@ -10913,22 +9374,24 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag) } else { while (rlen >= fclen) { - memcpy(p,f,flen); - p += flen; - rlen -= fclen; - } + memcpy(p,f,flen); + p += flen; + rlen -= fclen; + } if (rlen > 0) { memcpy(p, f, rlen2); p += rlen2; - } + } } TERM_FILL(p, termlen); STR_SET_LEN(res, p-RSTRING_PTR(res)); - + OBJ_INFECT_RAW(res, str); + if (!NIL_P(pad)) OBJ_INFECT_RAW(res, pad); + rb_enc_associate(res, enc); if (argc == 2) - cr = ENC_CODERANGE_AND(cr, ENC_CODERANGE(pad)); + cr = ENC_CODERANGE_AND(cr, ENC_CODERANGE(pad)); if (cr != ENC_CODERANGE_BROKEN) - ENC_CODERANGE_SET(res, cr); + ENC_CODERANGE_SET(res, cr); RB_GC_GUARD(pad); return res; @@ -10937,12 +9400,15 @@ rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag) /* * call-seq: - * ljust(size, pad_string = ' ') -> new_string - * - * :include: doc/string/ljust.rdoc + * str.ljust(integer, padstr=' ') -> new_str * - * Related: String#rjust, String#center. + * If <i>integer</i> is greater than the length of <i>str</i>, returns a new + * <code>String</code> of length <i>integer</i> with <i>str</i> left justified + * and padded with <i>padstr</i>; otherwise, returns <i>str</i>. * + * "hello".ljust(4) #=> "hello" + * "hello".ljust(20) #=> "hello " + * "hello".ljust(20, '1234') #=> "hello123412341234123" */ static VALUE @@ -10951,14 +9417,18 @@ rb_str_ljust(int argc, VALUE *argv, VALUE str) return rb_str_justify(argc, argv, str, 'l'); } + /* * call-seq: - * rjust(size, pad_string = ' ') -> new_string - * - * :include: doc/string/rjust.rdoc + * str.rjust(integer, padstr=' ') -> new_str * - * Related: String#ljust, String#center. + * If <i>integer</i> is greater than the length of <i>str</i>, returns a new + * <code>String</code> of length <i>integer</i> with <i>str</i> right justified + * and padded with <i>padstr</i>; otherwise, returns <i>str</i>. * + * "hello".rjust(4) #=> "hello" + * "hello".rjust(20) #=> " hello" + * "hello".rjust(20, '1234') #=> "123412341234123hello" */ static VALUE @@ -10970,12 +9440,15 @@ rb_str_rjust(int argc, VALUE *argv, VALUE str) /* * call-seq: - * center(size, pad_string = ' ') -> new_string + * str.center(width, padstr=' ') -> new_str * - * :include: doc/string/center.rdoc - * - * Related: String#ljust, String#rjust. + * 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 @@ -10986,10 +9459,17 @@ rb_str_center(int argc, VALUE *argv, VALUE str) /* * call-seq: - * partition(string_or_regexp) -> [head, match, tail] + * str.partition(sep) -> [head, sep, tail] + * str.partition(regexp) -> [head, match, tail] * - * :include: doc/string/partition.rdoc + * Searches <i>sep</i> or pattern (<i>regexp</i>) 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 <i>str</i>. * + * "hello".partition("l") #=> ["he", "l", "lo"] + * "hello".partition("x") #=> ["hello", "", ""] + * "hello".partition(/.l/) #=> ["h", "el", "lo"] */ static VALUE @@ -10999,74 +9479,87 @@ rb_str_partition(VALUE str, VALUE sep) sep = get_pat_quoted(sep, 0); if (RB_TYPE_P(sep, T_REGEXP)) { - if (rb_reg_search(sep, str, 0, 0) < 0) { - goto failed; - } - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); - - pos = BEG(0); - sep = rb_str_subseq(str, pos, END(0) - pos); + pos = rb_reg_search(sep, str, 0, 0); + if (pos < 0) { + failed: + return rb_ary_new3(3, rb_str_dup(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; + 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))); - - failed: - return rb_ary_new3(3, str_duplicate(rb_cString, str), str_new_empty_String(str), str_new_empty_String(str)); + sep, + rb_str_subseq(str, pos+RSTRING_LEN(sep), + RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); } /* * call-seq: - * rpartition(sep) -> [head, match, tail] + * str.rpartition(sep) -> [head, sep, tail] + * str.rpartition(regexp) -> [head, match, tail] * - * :include: doc/string/rpartition.rdoc + * Searches <i>sep</i> or pattern (<i>regexp</i>) 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 <i>str</i>. * + * "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; - sep = get_pat_quoted(sep, 0); if (RB_TYPE_P(sep, T_REGEXP)) { - if (rb_reg_search(sep, str, pos, 1) < 0) { - goto failed; - } - VALUE match = rb_backref_get(); - struct re_registers *regs = RMATCH_REGS(match); + pos = rb_reg_search(sep, str, pos, 1); + regex = TRUE; + } + else { + VALUE tmp; - pos = BEG(0); - sep = rb_str_subseq(str, pos, END(0) - pos); + 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), rb_str_dup(str)); + } + if (regex) { + sep = rb_reg_nth_match(0, rb_backref_get()); } else { - pos = rb_str_sublen(str, pos); - pos = rb_str_rindex(str, sep, pos); - if (pos < 0) { - goto failed; - } + 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))); - failed: - return rb_ary_new3(3, str_new_empty_String(str), str_new_empty_String(str), str_duplicate(rb_cString, str)); + sep, + rb_str_subseq(str, pos+RSTRING_LEN(sep), + RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); } /* * call-seq: - * start_with?(*string_or_regexp) -> true or false + * str.start_with?([prefixes]+) -> true or false + * + * Returns true if +str+ starts with one of the +prefixes+ given. * - * :include: doc/string/start_with_p.rdoc + * "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 @@ -11075,62 +9568,57 @@ rb_str_start_with(int argc, VALUE *argv, VALUE str) int i; for (i=0; i<argc; i++) { - VALUE tmp = argv[i]; - if (RB_TYPE_P(tmp, T_REGEXP)) { - if (rb_reg_start_with_p(tmp, str)) - return Qtrue; - } - else { - const char *p, *s, *e; - long slen, tlen; - rb_encoding *enc; - - StringValue(tmp); - enc = rb_enc_check(str, tmp); - if ((tlen = RSTRING_LEN(tmp)) == 0) return Qtrue; - if ((slen = RSTRING_LEN(str)) < tlen) continue; - p = RSTRING_PTR(str); - e = p + slen; - s = p + tlen; - if (!at_char_right_boundary(p, s, e, enc)) - continue; - if (memcmp(p, RSTRING_PTR(tmp), tlen) == 0) - return Qtrue; - } + VALUE tmp = argv[i]; + switch (TYPE(tmp)) { + case T_REGEXP: + { + bool r = rb_reg_start_with_p(tmp, str); + if (r) return Qtrue; + } + break; + default: + StringValue(tmp); + rb_enc_check(str, tmp); + if (RSTRING_LEN(str) < RSTRING_LEN(tmp)) continue; + if (memcmp(RSTRING_PTR(str), RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0) + return Qtrue; + } } return Qfalse; } /* * call-seq: - * end_with?(*strings) -> true or false + * str.end_with?([suffixes]+) -> true or false + * + * Returns true if +str+ ends with one of the +suffixes+ given. * - * :include: doc/string/end_with_p.rdoc + * "hello".end_with?("ello") #=> true * + * # returns true if one of the +suffixes+ matches. + * "hello".end_with?("heaven", "ello") #=> true + * "hello".end_with?("heaven", "paradise") #=> false */ 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<argc; i++) { - VALUE tmp = argv[i]; - const char *p, *s, *e; - long slen, tlen; - rb_encoding *enc; - - StringValue(tmp); - enc = rb_enc_check(str, tmp); - if ((tlen = RSTRING_LEN(tmp)) == 0) return Qtrue; - if ((slen = RSTRING_LEN(str)) < tlen) continue; - p = RSTRING_PTR(str); - e = p + slen; - s = e - tlen; - if (!at_char_boundary(p, s, e, enc)) - continue; - if (memcmp(s, RSTRING_PTR(tmp), tlen) == 0) - return Qtrue; + VALUE tmp = argv[i]; + StringValue(tmp); + enc = rb_enc_check(str, tmp); + if (RSTRING_LEN(str) < RSTRING_LEN(tmp)) continue; + p = RSTRING_PTR(str); + e = p + RSTRING_LEN(str); + s = e - RSTRING_LEN(tmp); + if (rb_enc_left_char_head(p, s, e, enc) != s) + continue; + if (memcmp(s, RSTRING_PTR(tmp), RSTRING_LEN(tmp)) == 0) + return Qtrue; } return Qfalse; } @@ -11147,17 +9635,12 @@ rb_str_end_with(int argc, VALUE *argv, VALUE str) static long deleted_prefix_length(VALUE str, VALUE prefix) { - const char *strptr, *prefixptr; + char *strptr, *prefixptr; long olen, prefixlen; - rb_encoding *enc = rb_enc_get(str); StringValue(prefix); - - if (!is_broken_string(prefix) || - !rb_enc_asciicompat(enc) || - !rb_enc_asciicompat(rb_enc_get(prefix))) { - enc = rb_enc_check(str, prefix); - } + if (is_broken_string(prefix)) return 0; + rb_enc_check(str, prefix); /* return 0 if not start with prefix */ prefixlen = RSTRING_LEN(prefix); @@ -11167,30 +9650,19 @@ deleted_prefix_length(VALUE str, VALUE prefix) strptr = RSTRING_PTR(str); prefixptr = RSTRING_PTR(prefix); if (memcmp(strptr, prefixptr, prefixlen) != 0) return 0; - if (is_broken_string(prefix)) { - if (!is_broken_string(str)) { - /* prefix in a valid string cannot be broken */ - return 0; - } - const char *strend = strptr + olen; - const char *after_prefix = strptr + prefixlen; - if (!at_char_right_boundary(strptr, after_prefix, strend, enc)) { - /* prefix does not end at char-boundary */ - return 0; - } - } - /* prefix part in `str` also should be valid. */ return prefixlen; } /* * call-seq: - * delete_prefix!(prefix) -> self or nil + * str.delete_prefix!(prefix) -> self or nil * - * Like String#delete_prefix, except that +self+ is modified in place. - * Returns +self+ if the prefix is removed, +nil+ otherwise. + * Deletes leading <code>prefix</code> from <i>str</i>, returning + * <code>nil</code> if no change was made. * + * "hello".delete_prefix!("hel") #=> "lo" + * "hello".delete_prefix!("llo") #=> nil */ static VALUE @@ -11207,10 +9679,12 @@ rb_str_delete_prefix_bang(VALUE str, VALUE prefix) /* * call-seq: - * delete_prefix(prefix) -> new_string + * str.delete_prefix(prefix) -> new_str * - * :include: doc/string/delete_prefix.rdoc + * Returns a copy of <i>str</i> with leading <code>prefix</code> deleted. * + * "hello".delete_prefix("hel") #=> "lo" + * "hello".delete_prefix("llo") #=> "hello" */ static VALUE @@ -11219,7 +9693,7 @@ rb_str_delete_prefix(VALUE str, VALUE prefix) long prefixlen; prefixlen = deleted_prefix_length(str, prefix); - if (prefixlen <= 0) return str_duplicate(rb_cString, str); + if (prefixlen <= 0) return rb_str_dup(str); return rb_str_subseq(str, prefixlen, RSTRING_LEN(str) - prefixlen); } @@ -11236,7 +9710,7 @@ rb_str_delete_prefix(VALUE str, VALUE prefix) static long deleted_suffix_length(VALUE str, VALUE suffix) { - const char *strptr, *suffixptr; + char *strptr, *suffixptr, *s; long olen, suffixlen; rb_encoding *enc; @@ -11251,21 +9725,22 @@ deleted_suffix_length(VALUE str, VALUE suffix) if (olen < suffixlen) return 0; strptr = RSTRING_PTR(str); suffixptr = RSTRING_PTR(suffix); - const char *strend = strptr + olen; - const char *before_suffix = strend - suffixlen; - if (memcmp(before_suffix, suffixptr, suffixlen) != 0) return 0; - if (!at_char_boundary(strptr, before_suffix, strend, enc)) return 0; + s = strptr + olen - suffixlen; + if (memcmp(s, suffixptr, suffixlen) != 0) return 0; + if (rb_enc_left_char_head(strptr, s, strptr + olen, enc) != s) return 0; return suffixlen; } /* * call-seq: - * delete_suffix!(suffix) -> self or nil + * str.delete_suffix!(suffix) -> self or nil * - * Like String#delete_suffix, except that +self+ is modified in place. - * Returns +self+ if the suffix is removed, +nil+ otherwise. + * Deletes trailing <code>suffix</code> from <i>str</i>, returning + * <code>nil</code> if no change was made. * + * "hello".delete_suffix!("llo") #=> "he" + * "hello".delete_suffix!("hel") #=> nil */ static VALUE @@ -11283,17 +9758,19 @@ rb_str_delete_suffix_bang(VALUE str, VALUE suffix) 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); + ENC_CODERANGE_CLEAR(str); } return str; } /* * call-seq: - * delete_suffix(suffix) -> new_string + * str.delete_suffix(suffix) -> new_str * - * :include: doc/string/delete_suffix.rdoc + * Returns a copy of <i>str</i> with trailing <code>suffix</code> deleted. * + * "hello".delete_suffix("llo") #=> "he" + * "hello".delete_suffix("hel") #=> "hello" */ static VALUE @@ -11302,7 +9779,7 @@ rb_str_delete_suffix(VALUE str, VALUE suffix) long suffixlen; suffixlen = deleted_suffix_length(str, suffix); - if (suffixlen <= 0) return str_duplicate(rb_cString, str); + if (suffixlen <= 0) return rb_str_dup(str); return rb_str_subseq(str, 0, RSTRING_LEN(str) - suffixlen); } @@ -11311,7 +9788,7 @@ void rb_str_setter(VALUE val, ID id, VALUE *var) { if (!NIL_P(val) && !RB_TYPE_P(val, T_STRING)) { - rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id)); + rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id)); } *var = val; } @@ -11321,12 +9798,9 @@ rb_fs_setter(VALUE val, ID id, VALUE *var) { val = rb_fs_check(val); if (!val) { - rb_raise(rb_eTypeError, - "value of %"PRIsVALUE" must be String or Regexp", - rb_id2str(id)); - } - if (!NIL_P(val)) { - rb_warn_deprecated("'$;'", NULL); + rb_raise(rb_eTypeError, + "value of %"PRIsVALUE" must be String or Regexp", + rb_id2str(id)); } *var = val; } @@ -11334,87 +9808,46 @@ rb_fs_setter(VALUE val, ID id, VALUE *var) /* * call-seq: - * force_encoding(encoding) -> self - * - * :include: doc/string/force_encoding.rdoc + * str.force_encoding(encoding) -> str * + * Changes the encoding to +encoding+ and returns self. */ static VALUE rb_str_force_encoding(VALUE str, VALUE enc) { str_modifiable(str); - - rb_encoding *encoding = rb_to_encoding(enc); - int idx = rb_enc_to_index(encoding); - - // If the encoding is unchanged, we do nothing. - if (ENCODING_GET(str) == idx) { - return str; - } - - rb_enc_associate_index(str, idx); - - // If the coderange was 7bit and the new encoding is ASCII-compatible - // we can keep the coderange. - if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT && encoding && rb_enc_asciicompat(encoding)) { - return str; - } - + rb_enc_associate(str, rb_to_encoding(enc)); ENC_CODERANGE_CLEAR(str); return str; } /* * call-seq: - * b -> string - * - * :include: doc/string/b.rdoc + * str.b -> str * + * Returns a copied string whose encoding is ASCII-8BIT. */ static VALUE rb_str_b(VALUE str) { - VALUE str2; - if (STR_EMBED_P(str)) { - str2 = str_alloc_embed(rb_cString, RSTRING_LEN(str) + TERM_LEN(str)); - } - else { - str2 = str_alloc_heap(rb_cString); - } + VALUE str2 = str_alloc(rb_cString); str_replace_shared_without_enc(str2, str); - - if (rb_enc_asciicompat(STR_ENC_GET(str))) { - // BINARY strings can never be broken; they're either 7-bit ASCII or VALID. - // If we know the receiver's code range then we know the result's code range. - int cr = ENC_CODERANGE(str); - switch (cr) { - case ENC_CODERANGE_7BIT: - ENC_CODERANGE_SET(str2, ENC_CODERANGE_7BIT); - break; - case ENC_CODERANGE_BROKEN: - case ENC_CODERANGE_VALID: - ENC_CODERANGE_SET(str2, ENC_CODERANGE_VALID); - break; - default: - ENC_CODERANGE_CLEAR(str2); - break; - } - } - + OBJ_INFECT_RAW(str2, str); + ENC_CODERANGE_CLEAR(str2); return str2; } /* * call-seq: - * valid_encoding? -> true or false + * str.valid_encoding? -> true or false * - * Returns +true+ if +self+ is encoded correctly, +false+ otherwise: + * Returns true for a string which is 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 + * "\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 @@ -11422,19 +9855,17 @@ rb_str_valid_encoding_p(VALUE str) { int cr = rb_enc_str_coderange(str); - return RBOOL(cr != ENC_CODERANGE_BROKEN); + return cr == ENC_CODERANGE_BROKEN ? Qfalse : Qtrue; } /* * call-seq: - * ascii_only? -> true or false + * str.ascii_only? -> true or false * - * Returns +true+ if +self+ contains only ASCII characters, - * +false+ otherwise: - * - * 'abc'.ascii_only? # => true - * "abc\u{6666}".ascii_only? # => 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 @@ -11442,9 +9873,23 @@ rb_str_is_ascii_only_p(VALUE str) { int cr = rb_enc_str_coderange(str); - return RBOOL(cr == ENC_CODERANGE_7BIT); + 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) { @@ -11457,27 +9902,27 @@ rb_str_ellipsize(VALUE str, long len) 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; + (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(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); - } + !(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); + 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); + estr = rb_str_encode(rb_usascii_str_new(ellipsis, ellipsislen), + rb_enc_from_encoding(enc), 0, Qnil); + rb_str_append(ret, estr); } return ret; } @@ -11489,20 +9934,25 @@ str_compat_and_valid(VALUE str, rb_encoding *enc) 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); + rb_raise(rb_eArgError, "replacement must be valid byte sequence '%+"PRIsVALUE"'", str); } else { - rb_encoding *e = STR_ENC_GET(str); - if (cr == ENC_CODERANGE_7BIT ? rb_enc_mbminlen(enc) != 1 : enc != e) { - rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", - rb_enc_inspect_name(enc), rb_enc_inspect_name(e)); - } + rb_encoding *e = STR_ENC_GET(str); + if (cr == ENC_CODERANGE_7BIT ? rb_enc_mbminlen(enc) != 1 : enc != e) { + rb_raise(rb_eEncCompatError, "incompatible character encodings: %s and %s", + rb_enc_name(enc), rb_enc_name(e)); + } } return str; } static VALUE enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl, int cr); +/** + * @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) { @@ -11515,9 +9965,9 @@ rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl) { int cr = ENC_CODERANGE_UNKNOWN; if (enc == STR_ENC_GET(str)) { - /* cached coderange makes sense only when enc equals the - * actual encoding of str */ - cr = ENC_CODERANGE(str); + /* cached coderange makes sense only when enc equals the + * actual encoding of str */ + cr = ENC_CODERANGE(str); } return enc_str_scrub(enc, str, repl, cr); } @@ -11527,267 +9977,280 @@ enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl, int cr) { int encidx; VALUE buf = Qnil; - const char *rep, *p, *e, *p1, *sp; + const char *rep; long replen = -1; - long slen; + int tainted = 0; if (rb_block_given_p()) { - if (!NIL_P(repl)) - rb_raise(rb_eArgError, "both of block and replacement given"); - replen = 0; + if (!NIL_P(repl)) + rb_raise(rb_eArgError, "both of block and replacement given"); + replen = 0; } if (ENC_CODERANGE_CLEAN_P(cr)) - return Qnil; + return Qnil; if (!NIL_P(repl)) { - repl = str_compat_and_valid(repl, enc); + repl = str_compat_and_valid(repl, enc); + tainted = OBJ_TAINTED_RAW(repl); } if (rb_enc_dummy_p(enc)) { - return Qnil; + 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); \ + static const char replace[sizeof(str)-1] = str; \ + rep = replace; replen = (int)sizeof(replace); \ } while (0) - slen = RSTRING_LEN(str); - p = RSTRING_PTR(str); - e = RSTRING_END(str); - p1 = p; - sp = p; - if (rb_enc_asciicompat(enc)) { - int rep7bit_p; - if (!replen) { - rep = NULL; - 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)); - str_mod_check(str, sp, slen); - 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)); - str_mod_check(str, sp, slen); - 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; - } - } + const char *p = RSTRING_PTR(str); + const char *e = RSTRING_END(str); + const char *p1 = p; + int rep7bit_p; + if (!replen) { + rep = NULL; + 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); + tainted |= OBJ_TAINTED_RAW(repl); + 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); + tainted |= OBJ_TAINTED_RAW(repl); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + if (ENC_CODERANGE(repl) == ENC_CODERANGE_VALID) + cr = ENC_CODERANGE_VALID; + } + } } else { - /* ASCII incompatible */ - long mbminlen = rb_enc_mbminlen(enc); - if (!replen) { - rep = NULL; - } - else 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, clen, enc)); - str_mod_check(str, sp, slen); - 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)); - str_mod_check(str, sp, slen); - repl = str_compat_and_valid(repl, enc); - rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); - } - } - cr = ENC_CODERANGE_VALID; - } + /* ASCII incompatible */ + const char *p = RSTRING_PTR(str); + const char *e = RSTRING_END(str); + const char *p1 = p; + long mbminlen = rb_enc_mbminlen(enc); + if (!replen) { + rep = NULL; + } + else 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, clen, enc)); + repl = str_compat_and_valid(repl, enc); + tainted |= OBJ_TAINTED_RAW(repl); + 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); + tainted |= OBJ_TAINTED_RAW(repl); + rb_str_buf_cat(buf, RSTRING_PTR(repl), RSTRING_LEN(repl)); + } + } + cr = ENC_CODERANGE_VALID; + } + FL_SET_RAW(buf, tainted|OBJ_TAINTED_RAW(str)); ENCODING_CODERANGE_SET(buf, rb_enc_to_index(enc), cr); return buf; } /* * call-seq: - * scrub(replacement_string = default_replacement) -> new_string - * scrub{|bytes| ... } -> new_string + * str.scrub -> new_str + * str.scrub(repl) -> new_str + * str.scrub{|bytes|} -> new_str * - * :include: doc/string/scrub.rdoc + * 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<e380>" */ 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) ? str_duplicate(rb_cString, str): new; + return NIL_P(new) ? rb_str_dup(str): new; } /* * call-seq: - * scrub! -> self - * scrub!(replacement_string = default_replacement) -> self - * scrub!{|bytes| ... } -> self + * str.scrub! -> str + * str.scrub!(repl) -> str + * str.scrub!{|bytes|} -> str * - * Like String#scrub, except that any replacements are made in +self+. + * 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<e380>" */ static VALUE str_scrub_bang(int argc, VALUE *argv, VALUE str) @@ -11809,46 +10272,35 @@ unicode_normalize_common(int argc, VALUE *argv, VALUE str, ID id) VALUE argv2[2]; if (!UnicodeNormalizeRequired) { - rb_require("unicode_normalize/normalize.rb"); - UnicodeNormalizeRequired = 1; + rb_require("unicode_normalize/normalize.rb"); + UnicodeNormalizeRequired = 1; } argv2[0] = str; - if (rb_check_arity(argc, 0, 1)) argv2[1] = argv[0]; + rb_scan_args(argc, argv, "01", &argv2[1]); return rb_funcallv(mUnicodeNormalize, id, argc+1, argv2); } /* * call-seq: - * unicode_normalize(form = :nfc) -> string - * - * Returns a copy of +self+ with - * {Unicode normalization}[https://unicode.org/reports/tr15] applied. - * - * Argument +form+ must be one of the following symbols - * (see {Unicode normalization forms}[https://unicode.org/reports/tr15/#Norm_Forms]): - * - * - +:nfc+: Canonical decomposition, followed by canonical composition. - * - +:nfd+: Canonical decomposition. - * - +:nfkc+: Compatibility decomposition, followed by canonical composition. - * - +:nfkd+: Compatibility decomposition. - * - * The encoding of +self+ must be one of: + * str.unicode_normalize(form=:nfc) * - * - Encoding::UTF_8 - * - Encoding::UTF_16BE - * - Encoding::UTF_16LE - * - Encoding::UTF_32BE - * - Encoding::UTF_32LE - * - Encoding::GB18030 - * - Encoding::UCS_2BE - * - Encoding::UCS_4BE + * Unicode Normalization---Returns a normalized form of +str+, + * using Unicode normalizations NFC, NFD, NFKC, or NFKD. + * The normalization form used is determined by +form+, which can + * be any of the four values +:nfc+, +:nfd+, +:nfkc+, or +:nfkd+. + * The default is +:nfc+. * - * Examples: + * If the string is not in a Unicode Encoding, then an Exception is raised. + * In this context, 'Unicode Encoding' means any of UTF-8, UTF-16BE/LE, + * and UTF-32BE/LE, as well as GB18030, UCS_2BE, and UCS_4BE. + * Anything other than UTF-8 is implemented by converting to UTF-8, + * which makes it slower than UTF-8. * - * "a\u0300".unicode_normalize # => "a" - * "\u00E0".unicode_normalize(:nfd) # => "a " - * - * Related: String#unicode_normalize!, String#unicode_normalized?. + * "a\u0300".unicode_normalize #=> "\u00E0" + * "a\u0300".unicode_normalize(:nfc) #=> "\u00E0" + * "\u00E0".unicode_normalize(:nfd) #=> "a\u0300" + * "\xE0".force_encoding('ISO-8859-1').unicode_normalize(:nfd) + * #=> Encoding::CompatibilityError raised */ static VALUE rb_str_unicode_normalize(int argc, VALUE *argv, VALUE str) @@ -11858,13 +10310,10 @@ rb_str_unicode_normalize(int argc, VALUE *argv, VALUE str) /* * call-seq: - * unicode_normalize!(form = :nfc) -> self - * - * Like String#unicode_normalize, except that the normalization - * is performed on +self+. - * - * Related String#unicode_normalized?. + * str.unicode_normalize!(form=:nfc) * + * Destructive version of String#unicode_normalize, doing Unicode + * normalization in place. */ static VALUE rb_str_unicode_normalize_bang(int argc, VALUE *argv, VALUE str) @@ -11873,27 +10322,21 @@ rb_str_unicode_normalize_bang(int argc, VALUE *argv, VALUE str) } /* call-seq: - * unicode_normalized?(form = :nfc) -> true or false - * - * Returns +true+ if +self+ is in the given +form+ of Unicode normalization, - * +false+ otherwise. - * The +form+ must be one of +:nfc+, +:nfd+, +:nfkc+, or +:nfkd+. - * - * Examples: - * - * "a\u0300".unicode_normalized? # => false - * "a\u0300".unicode_normalized?(:nfd) # => true - * "\u00E0".unicode_normalized? # => true - * "\u00E0".unicode_normalized?(:nfd) # => false - * - * - * Raises an exception if +self+ is not in a Unicode encoding: + * str.unicode_normalized?(form=:nfc) * - * s = "\xE0".force_encoding('ISO-8859-1') - * s.unicode_normalized? # Raises Encoding::CompatibilityError. + * Checks whether +str+ is in Unicode normalization form +form+, + * which can be any of the four values +:nfc+, +:nfd+, +:nfkc+, or +:nfkd+. + * The default is +:nfc+. * - * Related: String#unicode_normalize, String#unicode_normalize!. + * If the string is not in a Unicode Encoding, then an Exception is raised. + * For details, see String#unicode_normalize. * + * "a\u0300".unicode_normalized? #=> false + * "a\u0300".unicode_normalized?(:nfd) #=> true + * "\u00E0".unicode_normalized? #=> true + * "\u00E0".unicode_normalized?(:nfd) #=> false + * "\xE0".force_encoding('ISO-8859-1').unicode_normalized? + * #=> Encoding::CompatibilityError raised */ static VALUE rb_str_unicode_normalized_p(int argc, VALUE *argv, VALUE str) @@ -11904,18 +10347,17 @@ rb_str_unicode_normalized_p(int argc, VALUE *argv, VALUE str) /********************************************************************** * Document-class: Symbol * - * A +Symbol+ object represents a named identifier inside the Ruby interpreter. - * - * You can create a +Symbol+ object explicitly with: - * - * - A {symbol literal}[rdoc-ref:syntax/literals.rdoc@Symbol+Literals]. - * - * 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 <code>Fred</code> is a constant in one context, a method in - * another, and a class in a third, the +Symbol+ <code>:Fred</code> - * will be the same object in all three contexts. + * <code>Symbol</code> objects represent names and some strings + * inside the Ruby + * interpreter. They are generated using the <code>:name</code> and + * <code>:"string"</code> literals + * syntax, and by the various <code>to_sym</code> methods. The same + * <code>Symbol</code> 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 <code>Fred</code> is a constant in + * one context, a method in another, and a class in a third, the + * <code>Symbol</code> <code>:Fred</code> will be the same object in + * all three contexts. * * module One * class Fred @@ -11933,101 +10375,15 @@ rb_str_unicode_normalized_p(int argc, VALUE *argv, VALUE str) * $f2.object_id #=> 2514190 * $f3.object_id #=> 2514190 * - * Constant, method, and variable names are returned as symbols: - * - * module One - * Two = 2 - * def three; 3 end - * @four = 4 - * @@five = 5 - * $six = 6 - * end - * seven = 7 - * - * One.constants - * # => [:Two] - * One.instance_methods(true) - * # => [:three] - * One.instance_variables - * # => [:@four] - * One.class_variables - * # => [:@@five] - * global_variables.grep(/six/) - * # => [:$six] - * local_variables - * # => [:seven] - * - * A +Symbol+ object differs from a String object in that - * a +Symbol+ object represents an identifier, while a String object - * represents text or data. - * - * == What's Here - * - * First, what's elsewhere. \Class +Symbol+: - * - * - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here]. - * - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here]. - * - * Here, class +Symbol+ provides methods that are useful for: - * - * - {Querying}[rdoc-ref:Symbol@Methods+for+Querying] - * - {Comparing}[rdoc-ref:Symbol@Methods+for+Comparing] - * - {Converting}[rdoc-ref:Symbol@Methods+for+Converting] - * - * === Methods for Querying - * - * - ::all_symbols: Returns an array of the symbols currently in Ruby's symbol table. - * - #=~: Returns the index of the first substring in symbol that matches a - * given Regexp or other object; returns +nil+ if no match is found. - * - #[], #slice : Returns a substring of symbol - * determined by a given index, start/length, or range, or string. - * - #empty?: Returns +true+ if +self.length+ is zero; +false+ otherwise. - * - #encoding: Returns the Encoding object that represents the encoding - * of symbol. - * - #end_with?: Returns +true+ if symbol ends with - * any of the given strings. - * - #match: Returns a MatchData object if symbol - * matches a given Regexp; +nil+ otherwise. - * - #match?: Returns +true+ if symbol - * matches a given Regexp; +false+ otherwise. - * - #length, #size: Returns the number of characters in symbol. - * - #start_with?: Returns +true+ if symbol starts with - * any of the given strings. - * - * === Methods for Comparing - * - * - #<=>: Returns -1, 0, or 1 as a given symbol is smaller than, equal to, - * or larger than symbol. - * - #==, #===: Returns +true+ if a given symbol has the same content and - * encoding. - * - #casecmp: Ignoring case, returns -1, 0, or 1 as a given - * symbol is smaller than, equal to, or larger than symbol. - * - #casecmp?: Returns +true+ if symbol is equal to a given symbol - * after Unicode case folding; +false+ otherwise. - * - * === Methods for Converting - * - * - #capitalize: Returns symbol with the first character upcased - * and all other characters downcased. - * - #downcase: Returns symbol with all characters downcased. - * - #inspect: Returns the string representation of +self+ as a symbol literal. - * - #name: Returns the frozen string corresponding to symbol. - * - #succ, #next: Returns the symbol that is the successor to symbol. - * - #swapcase: Returns symbol with all upcase characters downcased - * and all downcase characters upcased. - * - #to_proc: Returns a Proc object which responds to the method named by symbol. - * - #to_s, #id2name: Returns the string corresponding to +self+. - * - #to_sym, #intern: Returns +self+. - * - #upcase: Returns symbol with all characters upcased. - * */ /* * call-seq: - * symbol == object -> true or false + * sym == obj -> true or false * - * Returns +true+ if +object+ is the same object as +self+, +false+ otherwise. + * Equality---If <i>sym</i> and <i>obj</i> are exactly the same + * symbol, returns <code>true</code>. */ #define sym_equal rb_obj_equal @@ -12036,14 +10392,14 @@ 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); + 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; + 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; } @@ -12061,8 +10417,8 @@ rb_str_symname_p(VALUE 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_symname2_p(ptr, len, enc) || !sym_printable(ptr, ptr + len, enc)) { - return FALSE; + !rb_enc_symname_p(ptr, enc) || !sym_printable(ptr, ptr + len, enc)) { + return FALSE; } return TRUE; } @@ -12082,8 +10438,8 @@ rb_str_quote_unprintable(VALUE 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_escape(str); + !sym_printable(ptr, ptr + len, enc)) { + return rb_str_inspect(str); } return str; } @@ -12091,23 +10447,16 @@ rb_str_quote_unprintable(VALUE str) VALUE rb_id_quote_unprintable(ID id) { - VALUE str = rb_id2str(id); - if (!rb_str_symname_p(str)) { - return rb_str_escape(str); - } - return str; + return rb_str_quote_unprintable(rb_id2str(id)); } /* * call-seq: - * inspect -> string - * - * Returns a string representation of +self+ (including the leading colon): + * sym.inspect -> string * - * :foo.inspect # => ":foo" - * - * Related: Symbol#to_s, Symbol#name. + * Returns the representation of <i>sym</i> as a symbol literal. * + * :fred.inspect #=> ":fred" */ static VALUE @@ -12119,62 +10468,93 @@ sym_inspect(VALUE sym) char *dest; if (!rb_str_symname_p(str)) { - str = rb_str_inspect(str); - len = RSTRING_LEN(str); - rb_str_resize(str, len + 1); - dest = RSTRING_PTR(str); - memmove(dest + 1, dest, len); + str = rb_str_inspect(str); + len = RSTRING_LEN(str); + rb_str_resize(str, len + 1); + dest = RSTRING_PTR(str); + memmove(dest + 1, dest, len); } else { - rb_encoding *enc = STR_ENC_GET(str); - VALUE orig_str = str; - - len = RSTRING_LEN(orig_str); - str = rb_enc_str_new(0, len + 1, enc); - - // Get data pointer after allocation - ptr = RSTRING_PTR(orig_str); - dest = RSTRING_PTR(str); - memcpy(dest + 1, ptr, len); - - RB_GC_GUARD(orig_str); + rb_encoding *enc = STR_ENC_GET(str); + RSTRING_GETMEM(str, ptr, len); + str = rb_enc_str_new(0, len + 1, enc); + dest = RSTRING_PTR(str); + memcpy(dest + 1, ptr, len); } dest[0] = ':'; - - RUBY_ASSERT_BUILTIN_TYPE(str, T_STRING); - return str; } + +/* + * call-seq: + * sym.id2name -> string + * sym.to_s -> string + * + * Returns the name or string corresponding to <i>sym</i>. + * + * :fred.id2name #=> "fred" + * :ginger.to_s #=> "ginger" + */ + + VALUE rb_sym_to_s(VALUE sym) { - VALUE str = str_new_shared(rb_cString, rb_sym2str(sym)); - FL_SET_RAW(str, STR_CHILLED_SYMBOL_TO_S); - return str; + return str_new_shared(rb_cString, rb_sym2str(sym)); +} + + +/* + * call-seq: + * sym.to_sym -> sym + * sym.intern -> sym + * + * In general, <code>to_sym</code> returns the <code>Symbol</code> corresponding + * to an object. As <i>sym</i> is already a symbol, <code>self</code> is returned + * in this case. + */ + +static VALUE +sym_to_sym(VALUE sym) +{ + return sym; } VALUE -rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc) +rb_sym_proc_call(ID mid, int argc, const VALUE *argv, VALUE passed_proc) { VALUE obj; if (argc < 1) { - rb_raise(rb_eArgError, "no receiver given"); + rb_raise(rb_eArgError, "no receiver given"); } obj = argv[0]; - return rb_funcall_with_block_kw(obj, mid, argc - 1, argv + 1, passed_proc, kw_splat); + return rb_funcall_with_block(obj, mid, argc - 1, argv + 1, passed_proc); } +#if 0 /* - * call-seq: - * succ + * call-seq: + * sym.to_proc * - * Equivalent to <tt>self.to_s.succ.to_sym</tt>: + * Returns a _Proc_ object which respond to the given method by _sym_. + * + * (1..3).collect(&:to_s) #=> ["1", "2", "3"] + */ + +VALUE +rb_sym_to_proc(VALUE sym) +{ +} +#endif + +/* + * call-seq: * - * :foo.succ # => :fop + * sym.succ * - * Related: String#succ. + * Same as <code>sym.to_s.succ.intern</code>. */ static VALUE @@ -12184,74 +10564,91 @@ sym_succ(VALUE sym) } /* - * call-seq: - * symbol <=> object -> -1, 0, +1, or nil - * - * If +object+ is a symbol, - * returns the equivalent of <tt>symbol.to_s <=> object.to_s</tt>: + * call-seq: * - * :bar <=> :foo # => -1 - * :foo <=> :foo # => 0 - * :foo <=> :bar # => 1 + * symbol <=> other_symbol -> -1, 0, +1, or nil * - * Otherwise, returns +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+. * - * :foo <=> 'bar' # => nil + * +nil+ is returned if the two values are incomparable. * - * Related: String#<=>. + * See String#<=> for more information. */ static VALUE sym_cmp(VALUE sym, VALUE other) { if (!SYMBOL_P(other)) { - return Qnil; + return Qnil; } return rb_str_cmp_m(rb_sym2str(sym), rb_sym2str(other)); } /* - * call-seq: - * casecmp(object) -> -1, 0, 1, or nil + * call-seq: + * sym.casecmp(other_symbol) -> -1, 0, +1, or nil * - * :include: doc/symbol/casecmp.rdoc + * Case-insensitive version of <code>Symbol#<=></code>. + * Currently, case-insensitivity only works on characters A-Z/a-z, + * not all of Unicode. This is different from Symbol#casecmp?. * + * :aBcDeF.casecmp(:abcde) #=> 1 + * :aBcDeF.casecmp(:abcdef) #=> 0 + * :aBcDeF.casecmp(:abcdefg) #=> -1 + * :abcdef.casecmp(:ABCDEF) #=> 0 + * + * +nil+ is returned if the two symbols have incompatible encodings, + * or if +other_symbol+ is not a symbol. + * + * :foo.casecmp(2) #=> nil + * "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp(:"\u{c4 d6 dc}") #=> nil */ static VALUE sym_casecmp(VALUE sym, VALUE other) { if (!SYMBOL_P(other)) { - return Qnil; + return Qnil; } return str_casecmp(rb_sym2str(sym), rb_sym2str(other)); } /* - * call-seq: - * casecmp?(object) -> true, false, or nil + * call-seq: + * sym.casecmp?(other_symbol) -> true, false, or nil + * + * Returns +true+ if +sym+ and +other_symbol+ are equal after + * Unicode case folding, +false+ if they are not equal. * - * :include: doc/symbol/casecmp_p.rdoc + * :aBcDeF.casecmp?(:abcde) #=> false + * :aBcDeF.casecmp?(:abcdef) #=> true + * :aBcDeF.casecmp?(:abcdefg) #=> false + * :abcdef.casecmp?(:ABCDEF) #=> true + * :"\u{e4 f6 fc}".casecmp?(:"\u{c4 d6 dc}") #=> true * + * +nil+ is returned if the two symbols have incompatible encodings, + * or if +other_symbol+ is not a symbol. + * + * :foo.casecmp?(2) #=> nil + * "\u{e4 f6 fc}".encode("ISO-8859-1").to_sym.casecmp?(:"\u{c4 d6 dc}") #=> nil */ static VALUE sym_casecmp_p(VALUE sym, VALUE other) { if (!SYMBOL_P(other)) { - return Qnil; + return Qnil; } return str_casecmp_p(rb_sym2str(sym), rb_sym2str(other)); } /* - * call-seq: - * symbol =~ object -> integer or nil - * - * Equivalent to <tt>symbol.to_s =~ object</tt>, - * including possible updates to global variables; - * see String#=~. + * call-seq: + * sym =~ obj -> integer or nil * + * Returns <code>sym.to_s =~ obj</code>. */ static VALUE @@ -12261,14 +10658,11 @@ sym_match(VALUE sym, VALUE other) } /* - * call-seq: - * match(pattern, offset = 0) -> matchdata or nil - * match(pattern, offset = 0) {|matchdata| } -> object - * - * Equivalent to <tt>self.to_s.match</tt>, - * including possible updates to global variables; - * see String#match. + * call-seq: + * sym.match(pattern) -> matchdata or nil + * sym.match(pattern, pos) -> matchdata or nil * + * Returns <code>sym.to_s.match</code>. */ static VALUE @@ -12278,12 +10672,11 @@ sym_match_m(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * match?(pattern, offset) -> true or false - * - * Equivalent to <tt>sym.to_s.match?</tt>; - * see String#match. + * call-seq: + * sym.match?(pattern) -> true or false + * sym.match?(pattern, pos) -> true or false * + * Returns <code>sym.to_s.match?</code>. */ static VALUE @@ -12293,15 +10686,13 @@ sym_match_m_p(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * symbol[index] -> string or nil - * symbol[start, length] -> string or nil - * symbol[range] -> string or nil - * symbol[regexp, capture = 0] -> string or nil - * symbol[substring] -> string or nil - * - * Equivalent to <tt>symbol.to_s[]</tt>; see String#[]. + * call-seq: + * sym[idx] -> char + * sym[b, n] -> string + * sym.slice(idx) -> char + * sym.slice(b, n) -> string * + * Returns <code>sym.to_s[]</code>. */ static VALUE @@ -12311,10 +10702,11 @@ sym_aref(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * length -> integer + * call-seq: + * sym.length -> integer + * sym.size -> integer * - * Equivalent to <tt>self.to_s.length</tt>; see String#length. + * Same as <code>sym.to_s.length</code>. */ static VALUE @@ -12324,11 +10716,10 @@ sym_length(VALUE sym) } /* - * call-seq: - * empty? -> true or false - * - * Returns +true+ if +self+ is <tt>:''</tt>, +false+ otherwise. + * call-seq: + * sym.empty? -> true or false * + * Returns whether _sym_ is :"" or not. */ static VALUE @@ -12338,13 +10729,11 @@ sym_empty(VALUE sym) } /* - * call-seq: - * upcase(*options) -> symbol - * - * Equivalent to <tt>sym.to_s.upcase.to_sym</tt>. - * - * See String#upcase. + * call-seq: + * sym.upcase -> symbol + * sym.upcase([options]) -> symbol * + * Same as <code>sym.to_s.upcase.intern</code>. */ static VALUE @@ -12354,15 +10743,11 @@ sym_upcase(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * downcase(*options) -> symbol - * - * Equivalent to <tt>sym.to_s.downcase.to_sym</tt>. - * - * See String#downcase. - * - * Related: Symbol#upcase. + * call-seq: + * sym.downcase -> symbol + * sym.downcase([options]) -> symbol * + * Same as <code>sym.to_s.downcase.intern</code>. */ static VALUE @@ -12372,13 +10757,11 @@ sym_downcase(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * capitalize(*options) -> symbol - * - * Equivalent to <tt>sym.to_s.capitalize.to_sym</tt>. - * - * See String#capitalize. + * call-seq: + * sym.capitalize -> symbol + * sym.capitalize([options]) -> symbol * + * Same as <code>sym.to_s.capitalize.intern</code>. */ static VALUE @@ -12388,13 +10771,11 @@ sym_capitalize(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * swapcase(*options) -> symbol - * - * Equivalent to <tt>sym.to_s.swapcase.to_sym</tt>. - * - * See String#swapcase. + * call-seq: + * sym.swapcase -> symbol + * sym.swapcase([options]) -> symbol * + * Same as <code>sym.to_s.swapcase.intern</code>. */ static VALUE @@ -12404,40 +10785,10 @@ sym_swapcase(int argc, VALUE *argv, VALUE sym) } /* - * call-seq: - * start_with?(*string_or_regexp) -> true or false - * - * Equivalent to <tt>self.to_s.start_with?</tt>; see String#start_with?. - * - */ - -static VALUE -sym_start_with(int argc, VALUE *argv, VALUE sym) -{ - return rb_str_start_with(argc, argv, rb_sym2str(sym)); -} - -/* - * call-seq: - * end_with?(*strings) -> true or false - * - * - * Equivalent to <tt>self.to_s.end_with?</tt>; see String#end_with?. - * - */ - -static VALUE -sym_end_with(int argc, VALUE *argv, VALUE sym) -{ - return rb_str_end_with(argc, argv, rb_sym2str(sym)); -} - -/* - * call-seq: - * encoding -> encoding - * - * Equivalent to <tt>self.to_s.encoding</tt>; see String#encoding. + * call-seq: + * sym.encoding -> encoding * + * Returns the Encoding object that represents the encoding of _sym_. */ static VALUE @@ -12450,12 +10801,12 @@ 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 nor a string", - name); - } - name = tmp; + 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; } @@ -12464,7 +10815,7 @@ ID rb_to_id(VALUE name) { if (SYMBOL_P(name)) { - return SYM2ID(name); + return SYM2ID(name); } name = string_for_symbol(name); return rb_intern_str(name); @@ -12474,102 +10825,36 @@ VALUE rb_to_symbol(VALUE name) { if (SYMBOL_P(name)) { - return name; + return name; } name = string_for_symbol(name); return rb_str_intern(name); } /* - * call-seq: - * Symbol.all_symbols -> array_of_symbols - * - * Returns an array of all symbols currently in Ruby's symbol table: + * A <code>String</code> object holds and manipulates an arbitrary sequence of + * bytes, typically representing characters. String objects may be created + * using <code>String::new</code> or as literals. * - * Symbol.all_symbols.size # => 9334 - * Symbol.all_symbols.take(3) # => [:!, :"\"", :"#"] + * Because of aliasing issues, users of strings should be aware of the methods + * that modify the contents of a <code>String</code> object. Typically, + * methods with names ending in ``!'' modify their receiver, while those + * without a ``!'' return a new <code>String</code>. However, there are + * exceptions, such as <code>String#[]=</code>. * */ -static VALUE -sym_all_symbols(VALUE _) -{ - return rb_sym_all_symbols(); -} - -VALUE -rb_str_to_interned_str(VALUE str) -{ - return rb_fstring(str); -} - -VALUE -rb_interned_str(const char *ptr, long len) -{ - struct RString fake_str; - return register_fstring(setup_fake_str(&fake_str, ptr, len, ENCINDEX_US_ASCII), true, false); -} - -VALUE -rb_interned_str_cstr(const char *ptr) -{ - return rb_interned_str(ptr, strlen(ptr)); -} - -VALUE -rb_enc_interned_str(const char *ptr, long len, rb_encoding *enc) -{ - if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) { - rb_enc_autoload(enc); - } - - struct RString fake_str; - return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), true, false); -} - -VALUE -rb_enc_literal_str(const char *ptr, long len, rb_encoding *enc) -{ - if (enc != NULL && UNLIKELY(rb_enc_autoload_p(enc))) { - rb_enc_autoload(enc); - } - - struct RString fake_str; - return register_fstring(rb_setup_fake_str(&fake_str, ptr, len, enc), true, true); -} - -VALUE -rb_enc_interned_str_cstr(const char *ptr, rb_encoding *enc) -{ - return rb_enc_interned_str(ptr, strlen(ptr), enc); -} - -#if USE_YJIT -void -rb_yjit_str_concat_codepoint(VALUE str, VALUE codepoint) -{ - if (RB_LIKELY(ENCODING_GET_INLINED(str) == rb_ascii8bit_encindex())) { - ssize_t code = RB_NUM2SSIZE(codepoint); - - if (RB_LIKELY(code >= 0 && code < 0xff)) { - rb_str_buf_cat_byte(str, (char) code); - return; - } - } - - rb_str_concat(str, codepoint); -} -#endif - void Init_String(void) { +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + rb_cString = rb_define_class("String", rb_cObject); - RUBY_ASSERT(rb_vm_fstring_table()); + assert(rb_vm_fstring_table()); st_foreach(rb_vm_fstring_table(), fstring_set_class_i, rb_cString); rb_include_module(rb_cString, rb_mComparable); rb_define_alloc_func(rb_cString, empty_str_alloc); - rb_define_singleton_method(rb_cString, "new", rb_str_s_new, -1); 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); @@ -12599,23 +10884,18 @@ Init_String(void) 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, "byteindex", rb_str_byteindex_m, -1); rb_define_method(rb_cString, "rindex", rb_str_rindex_m, -1); - rb_define_method(rb_cString, "byterindex", rb_str_byterindex_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, "bytesplice", rb_str_bytesplice, -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_str_freeze, 0); rb_define_method(rb_cString, "+@", str_uplus, 0); rb_define_method(rb_cString, "-@", str_uminus, 0); - rb_define_method(rb_cString, "dup", rb_str_dup_m, 0); - rb_define_alias(rb_cString, "dedup", "-@"); rb_define_method(rb_cString, "to_i", rb_str_to_i, -1); rb_define_method(rb_cString, "to_f", rb_str_to_f, 0); @@ -12625,10 +10905,10 @@ Init_String(void) rb_define_method(rb_cString, "dump", rb_str_dump, 0); rb_define_method(rb_cString, "undump", str_undump, 0); - sym_ascii = ID2SYM(rb_intern_const("ascii")); - sym_turkic = ID2SYM(rb_intern_const("turkic")); - sym_lithuanian = ID2SYM(rb_intern_const("lithuanian")); - sym_fold = ID2SYM(rb_intern_const("fold")); + sym_ascii = ID2SYM(rb_intern("ascii")); + sym_turkic = ID2SYM(rb_intern("turkic")); + sym_lithuanian = ID2SYM(rb_intern("lithuanian")); + sym_fold = ID2SYM(rb_intern("fold")); rb_define_method(rb_cString, "upcase", rb_str_upcase, -1); rb_define_method(rb_cString, "downcase", rb_str_downcase, -1); @@ -12651,7 +10931,6 @@ Init_String(void) 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_multi, -1); - rb_define_method(rb_cString, "append_as_bytes", rb_str_append_as_bytes, -1); rb_define_method(rb_cString, "<<", rb_str_concat, 1); rb_define_method(rb_cString, "prepend", rb_str_prepend_multi, -1); rb_define_method(rb_cString, "crypt", rb_str_crypt, 1); @@ -12722,8 +11001,8 @@ Init_String(void) /* define UnicodeNormalize module here so that we don't have to look it up */ mUnicodeNormalize = rb_define_module("UnicodeNormalize"); - id_normalize = rb_intern_const("normalize"); - id_normalized_p = rb_intern_const("normalized?"); + id_normalize = rb_intern("normalize"); + id_normalized_p = rb_intern("normalized?"); rb_define_method(rb_cString, "unicode_normalize", rb_str_unicode_normalize, -1); rb_define_method(rb_cString, "unicode_normalize!", rb_str_unicode_normalize_bang, -1); @@ -12738,12 +11017,16 @@ Init_String(void) 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", sym_all_symbols, 0); + 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_proc", rb_sym_to_proc, 0); /* in proc.c */ + 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", rb_sym_to_proc, 0); rb_define_method(rb_cSymbol, "succ", sym_succ, 0); rb_define_method(rb_cSymbol, "next", sym_succ, 0); @@ -12765,8 +11048,5 @@ Init_String(void) rb_define_method(rb_cSymbol, "capitalize", sym_capitalize, -1); rb_define_method(rb_cSymbol, "swapcase", sym_swapcase, -1); - rb_define_method(rb_cSymbol, "start_with?", sym_start_with, -1); - rb_define_method(rb_cSymbol, "end_with?", sym_end_with, -1); - rb_define_method(rb_cSymbol, "encoding", sym_encoding, 0); } |