/********************************************************************** string.c - $Author$ $Date$ created at: Mon Aug 9 17:12:58 JST 1993 Copyright (C) 1993-2006 Yukihiro Matsumoto Copyright (C) 2000 Network Applied Communication Laboratory, Inc. Copyright (C) 2000 Information-technology Promotion Agency, Japan **********************************************************************/ #include "ruby.h" #include "re.h" #define BEG(no) regs->beg[no] #define END(no) regs->end[no] #include #include #ifdef HAVE_UNISTD_H #include #endif VALUE rb_cString; VALUE rb_cSymbol; #define STR_TMPLOCK FL_USER7 #define STR_NOEMBED FL_USER1 #define STR_ASSOC FL_USER3 #define STR_SHARED_P(s) FL_ALL(s, STR_NOEMBED|ELTS_SHARED) #define STR_ASSOC_P(s) FL_ALL(s, STR_NOEMBED|STR_ASSOC) #define STR_NOCAPA (STR_NOEMBED|ELTS_SHARED|STR_ASSOC) #define STR_NOCAPA_P(s) (FL_TEST(s,STR_NOEMBED) && FL_ANY(s,ELTS_SHARED|STR_ASSOC)) #define STR_UNSET_NOCAPA(s) do {\ if (FL_TEST(s,STR_NOEMBED)) FL_UNSET(s,(ELTS_SHARED|STR_ASSOC));\ } while (0) #define STR_SET_NOEMBED(str) do {\ FL_SET(str, STR_NOEMBED);\ STR_SET_EMBED_LEN(str, 0);\ } while (0) #define STR_SET_EMBED(str) FL_UNSET(str, STR_NOEMBED) #define STR_EMBED_P(str) (!FL_TEST(str, STR_NOEMBED)) #define STR_SET_EMBED_LEN(str, n) do { \ long tmp_n = (n);\ RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\ RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\ } while (0) #define STR_SET_LEN(str, n) do { \ if (STR_EMBED_P(str)) {\ STR_SET_EMBED_LEN(str, n);\ }\ else {\ RSTRING(str)->as.heap.len = (n);\ }\ } while (0) #define STR_DEC_LEN(str) do {\ if (STR_EMBED_P(str)) {\ long n = RSTRING_LEN(str);\ n--;\ STR_SET_EMBED_LEN(str, n);\ }\ else {\ RSTRING(str)->as.heap.len--;\ }\ } while (0) #define RESIZE_CAPA(str,capacity) do {\ if (STR_EMBED_P(str)) {\ if ((capacity) > RSTRING_EMBED_LEN_MAX) {\ char *tmp = ALLOC_N(char, capacity+1);\ memcpy(tmp, RSTRING_PTR(str), RSTRING_LEN(str));\ RSTRING(str)->as.heap.ptr = tmp;\ RSTRING(str)->as.heap.len = RSTRING_LEN(str);\ STR_SET_NOEMBED(str);\ RSTRING(str)->as.heap.aux.capa = (capacity);\ }\ }\ else {\ REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+1);\ if (!STR_NOCAPA_P(str))\ RSTRING(str)->as.heap.aux.capa = (capacity);\ }\ } while (0) char * rb_str_ptr(VALUE str) { return RSTRING_PTR(str); } VALUE rb_fs; static inline void str_mod_check(VALUE s, char *p, long len) { if (RSTRING_PTR(s) != p || RSTRING_LEN(s) != len){ rb_raise(rb_eRuntimeError, "string modified"); } } static inline void str_frozen_check(VALUE s) { if (OBJ_FROZEN(s)) { rb_raise(rb_eRuntimeError, "string frozen"); } } static VALUE str_alloc(VALUE klass) { NEWOBJ(str, struct RString); OBJSETUP(str, klass, T_STRING); if (klass == rb_cSymbol) { /* need to be registered in table */ RBASIC(str)->klass = rb_cString; } str->as.heap.ptr = 0; str->as.heap.len = 0; str->as.heap.aux.capa = 0; return (VALUE)str; } static VALUE str_new(VALUE klass, const char *ptr, long len) { VALUE str; if (len < 0) { rb_raise(rb_eArgError, "negative string size (or size too big)"); } str = str_alloc(klass); if (len > RSTRING_EMBED_LEN_MAX) { RSTRING(str)->as.heap.aux.capa = len; RSTRING(str)->as.heap.ptr = ALLOC_N(char,len+1); STR_SET_NOEMBED(str); } if (ptr) { memcpy(RSTRING_PTR(str), ptr, len); } STR_SET_LEN(str, len); RSTRING_PTR(str)[len] = '\0'; return str; } VALUE rb_str_new(const char *ptr, long len) { return str_new(rb_cString, ptr, len); } VALUE rb_str_new2(const char *ptr) { if (!ptr) { rb_raise(rb_eArgError, "NULL pointer given"); } return rb_str_new(ptr, strlen(ptr)); } VALUE rb_tainted_str_new(const char *ptr, long len) { VALUE str = rb_str_new(ptr, len); OBJ_TAINT(str); return str; } VALUE rb_tainted_str_new2(const char *ptr) { VALUE str = rb_str_new2(ptr); OBJ_TAINT(str); return str; } static VALUE str_new3(VALUE klass, VALUE str) { VALUE str2 = str_alloc(klass); if (RSTRING_LEN(str) <= RSTRING_EMBED_LEN_MAX) { STR_SET_EMBED(str); memcpy(RSTRING_PTR(str2), RSTRING_PTR(str), RSTRING_LEN(str)+1); STR_SET_EMBED_LEN(str2, RSTRING_LEN(str)); } else { FL_SET(str2, STR_NOEMBED); RSTRING(str2)->as.heap.len = RSTRING_LEN(str); RSTRING(str2)->as.heap.ptr = RSTRING_PTR(str); RSTRING(str2)->as.heap.aux.shared = str; FL_SET(str2, ELTS_SHARED); } OBJ_INFECT(str2, str); return str2; } VALUE rb_str_new3(VALUE str) { return str_new3(rb_obj_class(str), str); } static VALUE str_new4(VALUE klass, VALUE str) { VALUE str2; str2 = str_alloc(klass); STR_SET_NOEMBED(str2); RSTRING(str2)->as.heap.len = RSTRING_LEN(str); RSTRING(str2)->as.heap.ptr = RSTRING_PTR(str); if (STR_SHARED_P(str)) { FL_SET(str2, ELTS_SHARED); RSTRING(str2)->as.heap.aux.shared = RSTRING(str)->as.heap.aux.shared; } else { FL_SET(str, ELTS_SHARED); RSTRING(str)->as.heap.aux.shared = str2; } OBJ_INFECT(str2, str); return str2; } VALUE rb_str_new4(VALUE orig) { VALUE klass, str; if (OBJ_FROZEN(orig)) return orig; klass = rb_obj_class(orig); if (STR_SHARED_P(orig) && (str = RSTRING(orig)->as.heap.aux.shared) && klass == RBASIC(str)->klass) { long ofs; ofs = RSTRING_LEN(str) - RSTRING_LEN(orig); if (ofs > 0) { str = str_new3(klass, str); RSTRING(str)->as.heap.ptr += ofs; RSTRING(str)->as.heap.len -= ofs; } } else if (STR_ASSOC_P(orig) || STR_EMBED_P(orig)) { str = str_new(klass, RSTRING_PTR(orig), RSTRING_LEN(orig)); } else { str = str_new4(klass, orig); } OBJ_INFECT(str, orig); OBJ_FREEZE(str); return str; } VALUE rb_str_new5(VALUE obj, const char *ptr, long len) { return str_new(rb_obj_class(obj), ptr, len); } #define STR_BUF_MIN_SIZE 128 VALUE rb_str_buf_new(long capa) { VALUE str = str_alloc(rb_cString); if (capa < STR_BUF_MIN_SIZE) { capa = STR_BUF_MIN_SIZE; } FL_SET(str, STR_NOEMBED); RSTRING(str)->as.heap.aux.capa = capa; RSTRING(str)->as.heap.ptr = ALLOC_N(char, capa+1); RSTRING(str)->as.heap.ptr[0] = '\0'; return str; } VALUE rb_str_buf_new2(const char *ptr) { VALUE str; long len = strlen(ptr); str = rb_str_buf_new(len); rb_str_buf_cat(str, ptr, len); return str; } void rb_str_free(VALUE str) { if (!STR_EMBED_P(str) && !STR_SHARED_P(str)) { xfree(RSTRING(str)->as.heap.ptr); } } VALUE rb_str_to_str(VALUE str) { return rb_convert_type(str, T_STRING, "String", "to_str"); } static void rb_str_shared_replace(VALUE str, VALUE str2) { if (str == str2) return; rb_str_modify(str); if (OBJ_TAINTED(str2)) OBJ_TAINT(str); if (RSTRING_LEN(str2) <= RSTRING_EMBED_LEN_MAX) { STR_SET_EMBED(str); memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1); STR_SET_EMBED_LEN(str, RSTRING_LEN(str2)); return; } STR_SET_NOEMBED(str); if (!STR_SHARED_P(str) && !STR_EMBED_P(str)) { free(RSTRING_PTR(str)); } STR_UNSET_NOCAPA(str); RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); RSTRING(str)->as.heap.len = RSTRING_LEN(str2); if (STR_NOCAPA_P(str2)) { FL_SET(str, RBASIC(str2)->flags & STR_NOCAPA); RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared; } else { RSTRING(str)->as.heap.aux.capa = RSTRING(str2)->as.heap.aux.capa; } RSTRING(str2)->as.heap.ptr = 0; /* abandon str2 */ RSTRING(str2)->as.heap.len = 0; RSTRING(str2)->as.heap.aux.capa = 0; STR_UNSET_NOCAPA(str2); } static ID id_to_s; VALUE rb_obj_as_string(VALUE obj) { VALUE str; if (TYPE(obj) == T_STRING) { return obj; } str = rb_funcall(obj, id_to_s, 0); if (TYPE(str) != T_STRING) return rb_any_to_s(obj); if (OBJ_TAINTED(obj)) OBJ_TAINT(str); return str; } static VALUE rb_str_replace(VALUE, VALUE); VALUE rb_str_dup(VALUE str) { VALUE dup = str_alloc(rb_obj_class(str)); rb_str_replace(dup, str); return dup; } /* * call-seq: * String.new(str="") => new_str * * Returns a new string object containing a copy of str. */ static VALUE rb_str_init(int argc, VALUE *argv, VALUE str) { VALUE orig; if (rb_scan_args(argc, argv, "01", &orig) == 1) rb_str_replace(str, orig); return str; } /* * call-seq: * str.length => integer * * Returns the length of str. */ static VALUE rb_str_length(VALUE str) { long len = RSTRING_LEN(str); return LONG2NUM(len); } /* * call-seq: * str.empty? => true or false * * Returns true if str has a length of zero. * * "hello".empty? #=> false * "".empty? #=> true */ static VALUE rb_str_empty(VALUE str) { if (RSTRING_LEN(str) == 0) return Qtrue; return Qfalse; } /* * call-seq: * str + other_str => new_str * * Concatenation---Returns a new String containing * other_str concatenated to str. * * "Hello from " + self.to_s #=> "Hello from main" */ VALUE rb_str_plus(VALUE str1, VALUE str2) { VALUE str3; StringValue(str2); str3 = rb_str_new(0, RSTRING_LEN(str1)+RSTRING_LEN(str2)); memcpy(RSTRING_PTR(str3), RSTRING_PTR(str1), RSTRING_LEN(str1)); memcpy(RSTRING_PTR(str3) + RSTRING_LEN(str1), RSTRING_PTR(str2), RSTRING_LEN(str2)); RSTRING_PTR(str3)[RSTRING_LEN(str3)] = '\0'; if (OBJ_TAINTED(str1) || OBJ_TAINTED(str2)) OBJ_TAINT(str3); return str3; } /* * call-seq: * str * integer => new_str * * Copy---Returns a new String containing integer copies of * the receiver. * * "Ho! " * 3 #=> "Ho! Ho! Ho! " */ VALUE rb_str_times(VALUE str, VALUE times) { VALUE str2; long i, len; len = NUM2LONG(times); if (len < 0) { rb_raise(rb_eArgError, "negative argument"); } if (len && LONG_MAX/len < RSTRING_LEN(str)) { rb_raise(rb_eArgError, "argument too big"); } str2 = rb_str_new5(str, 0, len *= RSTRING_LEN(str)); for (i = 0; i < len; i += RSTRING_LEN(str)) { memcpy(RSTRING_PTR(str2) + i, RSTRING_PTR(str), RSTRING_LEN(str)); } RSTRING_PTR(str2)[RSTRING_LEN(str2)] = '\0'; OBJ_INFECT(str2, str); return str2; } /* * call-seq: * str % arg => new_str * * Format---Uses str as a format specification, and returns the result * of applying it to arg. If the format specification contains more than * one substitution, then arg must be an Array containing * the values to be substituted. See Kernel::sprintf for details * of the format string. * * "%05d" % 123 #=> "00123" * "%-5s: %08x" % [ "ID", self.id ] #=> "ID : 200e14d6" */ static VALUE rb_str_format_m(VALUE str, VALUE arg) { if (TYPE(arg) == T_ARRAY) { return rb_str_format(RARRAY_LEN(arg), RARRAY_PTR(arg), str); } return rb_str_format(1, &arg, str); } static int str_independent(VALUE str) { if (FL_TEST(str, STR_TMPLOCK)) { rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked"); } if (OBJ_FROZEN(str)) rb_error_frozen("string"); if (!OBJ_TAINTED(str) && rb_safe_level() >= 4) rb_raise(rb_eSecurityError, "Insecure: can't modify string"); if (!STR_SHARED_P(str)) return 1; if (STR_EMBED_P(str)) return 1; return 0; } static void str_make_independent(VALUE str) { char *ptr; long len = RSTRING_LEN(str); ptr = ALLOC_N(char, len+1); if (RSTRING_PTR(str)) { memcpy(ptr, RSTRING_PTR(str), len); } STR_SET_NOEMBED(str); ptr[len] = 0; RSTRING(str)->as.heap.ptr = ptr; RSTRING(str)->as.heap.aux.capa = len; STR_UNSET_NOCAPA(str); } void rb_str_modify(VALUE str) { if (!str_independent(str)) str_make_independent(str); } void rb_str_associate(VALUE str, VALUE add) { if (STR_ASSOC_P(str)) { /* sanity check */ if (OBJ_FROZEN(str)) rb_error_frozen("string"); /* already associated */ rb_ary_concat(RSTRING(str)->as.heap.aux.shared, add); } else { if (STR_SHARED_P(str) || STR_EMBED_P(str)) { str_make_independent(str); } else if (RSTRING(str)->as.heap.aux.capa != RSTRING_LEN(str)) { RESIZE_CAPA(str, RSTRING_LEN(str)); } FL_SET(str, STR_ASSOC); RSTRING(str)->as.heap.aux.shared = add; } } VALUE rb_str_associated(VALUE str) { if (STR_ASSOC_P(str)) { if (OBJ_FROZEN(str)) return Qfalse; return RSTRING(str)->as.heap.aux.shared; } return Qfalse; } VALUE rb_string_value(volatile VALUE *ptr) { VALUE s = *ptr; if (TYPE(s) != T_STRING) { s = rb_str_to_str(s); *ptr = s; } return s; } char * rb_string_value_ptr(volatile VALUE *ptr) { return RSTRING_PTR(rb_string_value(ptr)); } char * rb_string_value_cstr(volatile VALUE *ptr) { VALUE str = rb_string_value(ptr); char *s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) != strlen(s)) { rb_raise(rb_eArgError, "string contains null byte"); } return s; } VALUE rb_check_string_type(VALUE str) { str = rb_check_convert_type(str, T_STRING, "String", "to_str"); return str; } VALUE rb_str_substr(VALUE str, long beg, long len) { VALUE str2; if (len < 0) return Qnil; if (beg > RSTRING_LEN(str)) return Qnil; if (beg < 0) { beg += RSTRING_LEN(str); if (beg < 0) return Qnil; } if (beg + len > RSTRING_LEN(str)) { len = RSTRING_LEN(str) - beg; } if (len < 0) { len = 0; } if (len == 0) { str2 = rb_str_new5(str,0,0); } else if (len > RSTRING_EMBED_LEN_MAX && beg + len == RSTRING_LEN(str) && !STR_ASSOC_P(str)) { str2 = rb_str_new3(rb_str_new4(str)); RSTRING(str2)->as.heap.ptr += RSTRING_LEN(str2) - len; RSTRING(str2)->as.heap.len = len; } else { str2 = rb_str_new5(str, RSTRING_PTR(str)+beg, len); } OBJ_INFECT(str2, str); return str2; } VALUE rb_str_freeze(VALUE str) { return rb_obj_freeze(str); } VALUE rb_str_dup_frozen(VALUE str) { if (STR_SHARED_P(str) && RSTRING(str)->as.heap.aux.shared) { VALUE shared = RSTRING(str)->as.heap.aux.shared; if (RSTRING_LEN(shared) == RSTRING_LEN(str)) { OBJ_FREEZE(shared); return shared; } } if (OBJ_FROZEN(str)) return str; str = rb_str_dup(str); OBJ_FREEZE(str); return str; } VALUE rb_str_locktmp(VALUE str) { if (FL_TEST(str, STR_TMPLOCK)) { rb_raise(rb_eRuntimeError, "temporal locking already locked string"); } FL_SET(str, STR_TMPLOCK); return str; } VALUE rb_str_unlocktmp(VALUE str) { if (!FL_TEST(str, STR_TMPLOCK)) { rb_raise(rb_eRuntimeError, "temporal unlocking already unlocked string"); } FL_UNSET(str, STR_TMPLOCK); return str; } void rb_str_set_len(VALUE str, long len) { STR_SET_LEN(str, len); RSTRING_PTR(str)[len] = '\0'; } VALUE rb_str_resize(VALUE str, long len) { if (len < 0) { rb_raise(rb_eArgError, "negative string size (or size too big)"); } rb_str_modify(str); if (len != RSTRING_LEN(str)) { if (STR_EMBED_P(str)) { char *ptr; if (len <= RSTRING_EMBED_LEN_MAX) { STR_SET_EMBED_LEN(str, len); RSTRING_PTR(str)[len] = '\0'; return str; } ptr = ALLOC_N(char,len+1); MEMCPY(ptr, RSTRING_PTR(str), char, RSTRING_LEN(str)); RSTRING(str)->as.heap.ptr = ptr; STR_SET_NOEMBED(str); } else if (RSTRING_LEN(str) < len || RSTRING_LEN(str) - len > 1024) { REALLOC_N(RSTRING(str)->as.heap.ptr, char, len+1); } if (!STR_NOCAPA_P(str)) { RSTRING(str)->as.heap.aux.capa = len; } RSTRING(str)->as.heap.len = len; RSTRING(str)->as.heap.ptr[len] = '\0'; /* sentinel */ } return str; } VALUE rb_str_buf_cat(VALUE str, const char *ptr, long len) { long capa, total; if (len == 0) return str; if (len < 0) { rb_raise(rb_eArgError, "negative string size (or size too big)"); } rb_str_modify(str); if (STR_ASSOC_P(str)) { FL_UNSET(str, STR_ASSOC); capa = RSTRING(str)->as.heap.aux.capa = RSTRING_LEN(str); } else if (STR_EMBED_P(str)) { capa = RSTRING_EMBED_LEN_MAX; } else { capa = RSTRING(str)->as.heap.aux.capa; } total = RSTRING_LEN(str)+len; if (capa <= total) { while (total > capa) { capa = (capa + 1) * 2; } RESIZE_CAPA(str, capa); } memcpy(RSTRING_PTR(str) + RSTRING_LEN(str), ptr, len); STR_SET_LEN(str, total); RSTRING_PTR(str)[total] = '\0'; /* sentinel */ return str; } VALUE rb_str_buf_cat2(VALUE str, const char *ptr) { return rb_str_buf_cat(str, ptr, strlen(ptr)); } VALUE rb_str_cat(VALUE str, const char *ptr, long len) { if (len < 0) { rb_raise(rb_eArgError, "negative string size (or size too big)"); } if (STR_ASSOC_P(str)) { rb_str_modify(str); if (STR_EMBED_P(str)) str_make_independent(str); REALLOC_N(RSTRING(str)->as.heap.ptr, char, RSTRING(str)->as.heap.len+len); memcpy(RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len, ptr, len); RSTRING(str)->as.heap.len += len; RSTRING(str)->as.heap.ptr[RSTRING(str)->as.heap.len] = '\0'; /* sentinel */ return str; } return rb_str_buf_cat(str, ptr, len); } VALUE rb_str_cat2(VALUE str, const char *ptr) { return rb_str_cat(str, ptr, strlen(ptr)); } VALUE rb_str_buf_append(VALUE str, VALUE str2) { long capa, len; rb_str_modify(str); if (STR_ASSOC_P(str)) { FL_UNSET(str, STR_ASSOC); capa = RSTRING(str)->as.heap.aux.capa = RSTRING_LEN(str); } else if (STR_EMBED_P(str)) { capa = RSTRING_EMBED_LEN_MAX; } else { capa = RSTRING(str)->as.heap.aux.capa; } len = RSTRING_LEN(str)+RSTRING_LEN(str2); if (capa <= len) { while (len > capa) { capa = (capa + 1) * 2; } RESIZE_CAPA(str, capa); } memcpy(RSTRING_PTR(str) + RSTRING_LEN(str), RSTRING_PTR(str2), RSTRING_LEN(str2)+1); STR_SET_LEN(str, len); OBJ_INFECT(str, str2); return str; } VALUE rb_str_append(VALUE str, VALUE str2) { StringValue(str2); rb_str_modify(str); if (RSTRING_LEN(str2) > 0) { if (STR_ASSOC_P(str)) { long len = RSTRING_LEN(str)+RSTRING_LEN(str2); REALLOC_N(RSTRING(str)->as.heap.ptr, char, len+1); memcpy(RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len, RSTRING_PTR(str2), RSTRING_LEN(str2)+1); RSTRING(str)->as.heap.len = len; } else { return rb_str_buf_append(str, str2); } } OBJ_INFECT(str, str2); return str; } /* * call-seq: * str << fixnum => str * str.concat(fixnum) => str * str << obj => str * str.concat(obj) => str * * Append---Concatenates the given object to str. If the object is a * Fixnum between 0 and 255, it is converted to a character before * concatenation. * * a = "hello " * a << "world" #=> "hello world" * a.concat(33) #=> "hello world!" */ VALUE rb_str_concat(VALUE str1, VALUE str2) { if (FIXNUM_P(str2)) { int i = FIX2INT(str2); if (0 <= i && i <= 0xff) { /* byte */ char c = i; return rb_str_cat(str1, &c, 1); } } return rb_str_append(str1, str2); } /* * hash_32 - 32 bit Fowler/Noll/Vo FNV-1a hash code * * @(#) $hash_32.Revision: 1.1 $ * @(#) $hash_32.Id: hash_32a.c,v 1.1 2003/10/03 20:38:53 chongo Exp $ * @(#) $hash_32.Source: /usr/local/src/cmd/fnv/RCS/hash_32a.c,v $ * *** * * Fowler/Noll/Vo hash * * The basis of this hash algorithm was taken from an idea sent * as reviewer comments to the IEEE POSIX P1003.2 committee by: * * Phong Vo (http://www.research.att.com/info/kpv/) * Glenn Fowler (http://www.research.att.com/~gsf/) * * In a subsequent ballot round: * * Landon Curt Noll (http://www.isthe.com/chongo/) * * improved on their algorithm. Some people tried this hash * and found that it worked rather well. In an EMail message * to Landon, they named it the ``Fowler/Noll/Vo'' or FNV hash. * * FNV hashes are designed to be fast while maintaining a low * collision rate. The FNV speed allows one to quickly hash lots * of data while maintaining a reasonable collision rate. See: * * http://www.isthe.com/chongo/tech/comp/fnv/index.html * * for more details as well as other forms of the FNV hash. *** * * To use the recommended 32 bit FNV-1a hash, pass FNV1_32A_INIT as the * Fnv32_t hashval argument to fnv_32a_buf() or fnv_32a_str(). * *** * * Please do not copyright this code. This code is in the public domain. * * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * * By: * chongo /\oo/\ * http://www.isthe.com/chongo/ * * Share and Enjoy! :-) */ /* * 32 bit FNV-1 and FNV-1a non-zero initial basis * * The FNV-1 initial basis is the FNV-0 hash of the following 32 octets: * * chongo /\../\ * * NOTE: The \'s above are not back-slashing escape characters. * They are literal ASCII backslash 0x5c characters. * * NOTE: The FNV-1a initial basis is the same value as FNV-1 by definition. */ #define FNV1_32A_INIT 0x811c9dc5 /* * 32 bit magic FNV-1a prime */ #define FNV_32_PRIME 0x01000193 int rb_memhash(const void *ptr, long len) { register const unsigned char *p = ptr; register unsigned int hval = FNV1_32A_INIT; /* * FNV-1a hash each octet in the buffer */ while (len--) { /* xor the bottom with the current octet */ hval ^= (unsigned int)*p++; /* multiply by the 32 bit FNV magic prime mod 2^32 */ #if defined(FNV_GCC_OPTIMIZATION) hval += (hval<<1) + (hval<<4) + (hval<<7) + (hval<<8) + (hval<<24); #else hval *= FNV_32_PRIME; #endif } return hval; } int rb_str_hash(VALUE str) { return rb_memhash(RSTRING_PTR(str), RSTRING_LEN(str)); } /* * call-seq: * str.hash => fixnum * * Return a hash based on the string's length and content. */ static VALUE rb_str_hash_m(VALUE str) { int hval = rb_str_hash(str); return INT2FIX(hval); } #define lesser(a,b) (((a)>(b))?(b):(a)) int rb_str_cmp(VALUE str1, VALUE str2) { long len; int retval; len = lesser(RSTRING_LEN(str1), RSTRING_LEN(str2)); retval = rb_memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len); if (retval == 0) { if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return 0; if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return 1; return -1; } if (retval > 0) return 1; return -1; } /* * call-seq: * str == obj => true or false * * Equality---If obj is not a String, returns * false. Otherwise, returns true if str * <=> obj returns zero. */ static VALUE rb_str_equal(VALUE str1, VALUE str2) { if (str1 == str2) return Qtrue; if (TYPE(str2) != T_STRING) { if (!rb_respond_to(str2, rb_intern("to_str"))) { return Qfalse; } return rb_equal(str2, str1); } if (RSTRING_LEN(str1) == RSTRING_LEN(str2) && rb_str_cmp(str1, str2) == 0) { return Qtrue; } return Qfalse; } /* * call-seq: * str.eql?(other) => true or false * * Two strings are equal if the have the same length and content. */ static VALUE rb_str_eql(VALUE str1, VALUE str2) { if (TYPE(str2) != T_STRING || RSTRING_LEN(str1) != RSTRING_LEN(str2)) return Qfalse; if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), lesser(RSTRING_LEN(str1), RSTRING_LEN(str2))) == 0) return Qtrue; return Qfalse; } /* * call-seq: * str <=> other_str => -1, 0, +1 * * Comparison---Returns -1 if other_str is less than, 0 if * other_str is equal to, and +1 if other_str is greater than * str. 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. If the variable $= is * false, the comparison is based on comparing the binary values * of each character in the string. In older versions of Ruby, setting * $= allowed case-insensitive comparisons; this is now deprecated * in favor of using String#casecmp. * * <=> is the basis for the methods <, * <=, >, >=, and between?, * included from module Comparable. The method * String#== does not use Comparable#==. * * "abcdef" <=> "abcde" #=> 1 * "abcdef" <=> "abcdef" #=> 0 * "abcdef" <=> "abcdefg" #=> -1 * "abcdef" <=> "ABCDEF" #=> 1 */ static VALUE rb_str_cmp_m(VALUE str1, VALUE str2) { long result; if (TYPE(str2) != T_STRING) { if (!rb_respond_to(str2, rb_intern("to_str"))) { return Qnil; } else if (!rb_respond_to(str2, rb_intern("<=>"))) { return Qnil; } else { VALUE tmp = rb_funcall(str2, rb_intern("<=>"), 1, str1); if (NIL_P(tmp)) return Qnil; if (!FIXNUM_P(tmp)) { return rb_funcall(LONG2FIX(0), '-', 1, tmp); } result = -FIX2LONG(tmp); } } else { result = rb_str_cmp(str1, str2); } return LONG2NUM(result); } /* * call-seq: * str.casecmp(other_str) => -1, 0, +1 * * Case-insensitive version of String#<=>. * * "abcdef".casecmp("abcde") #=> 1 * "aBcDeF".casecmp("abcdef") #=> 0 * "abcdef".casecmp("abcdefg") #=> -1 * "abcdef".casecmp("ABCDEF") #=> 0 */ static VALUE rb_str_casecmp(VALUE str1, VALUE str2) { long len; int retval; StringValue(str2); len = lesser(RSTRING_LEN(str1), RSTRING_LEN(str2)); retval = rb_memcicmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len); if (retval == 0) { if (RSTRING_LEN(str1) == RSTRING_LEN(str2)) return INT2FIX(0); if (RSTRING_LEN(str1) > RSTRING_LEN(str2)) return INT2FIX(1); return INT2FIX(-1); } if (retval == 0) return INT2FIX(0); if (retval > 0) return INT2FIX(1); return INT2FIX(-1); } static long rb_str_index(VALUE str, VALUE sub, long offset) { long pos; if (offset < 0) { offset += RSTRING_LEN(str); if (offset < 0) return -1; } if (RSTRING_LEN(str) - offset < RSTRING_LEN(sub)) return -1; if (RSTRING_LEN(sub) == 0) return offset; pos = rb_memsearch(RSTRING_PTR(sub), RSTRING_LEN(sub), RSTRING_PTR(str)+offset, RSTRING_LEN(str)-offset); if (pos < 0) return pos; return pos + offset; } /* * call-seq: * str.index(substring [, offset]) => fixnum or nil * str.index(fixnum [, offset]) => fixnum or nil * str.index(regexp [, offset]) => fixnum or nil * * Returns the index of the first occurrence of the given substring, * character (fixnum), or pattern (regexp) in str. Returns * nil if not found. If the second parameter is present, it * specifies the position in the string to begin the search. * * "hello".index('e') #=> 1 * "hello".index('lo') #=> 3 * "hello".index('a') #=> nil * "hello".index(101) #=> 1 * "hello".index(/[aeiou]/, -3) #=> 4 */ static VALUE rb_str_index_m(int argc, VALUE *argv, VALUE str) { VALUE sub; VALUE initpos; long pos; if (rb_scan_args(argc, argv, "11", &sub, &initpos) == 2) { pos = NUM2LONG(initpos); } else { pos = 0; } if (pos < 0) { pos += RSTRING_LEN(str); if (pos < 0) { if (TYPE(sub) == T_REGEXP) { rb_backref_set(Qnil); } return Qnil; } } switch (TYPE(sub)) { case T_REGEXP: pos = rb_reg_adjust_startpos(sub, str, pos, 0); pos = rb_reg_search(sub, str, pos, 0); break; case T_FIXNUM: { int c = FIX2INT(sub); long len = RSTRING_LEN(str); char *p = RSTRING_PTR(str); for (;pos fixnum or nil * str.rindex(fixnum [, fixnum]) => fixnum or nil * str.rindex(regexp [, fixnum]) => fixnum or nil * * Returns the index of the last occurrence of the given substring, * character (fixnum), or pattern (regexp) in str. Returns * nil if not found. If the second parameter is present, it * specifies the position in the string to end the search---characters beyond * this point will not be considered. * * "hello".rindex('e') #=> 1 * "hello".rindex('l') #=> 3 * "hello".rindex('a') #=> nil * "hello".rindex(101) #=> 1 * "hello".rindex(/[aeiou]/, -2) #=> 1 */ static VALUE rb_str_rindex_m(int argc, VALUE *argv, VALUE str) { VALUE sub; VALUE position; long pos; if (rb_scan_args(argc, argv, "11", &sub, &position) == 2) { pos = NUM2LONG(position); if (pos < 0) { pos += RSTRING_LEN(str); if (pos < 0) { if (TYPE(sub) == T_REGEXP) { rb_backref_set(Qnil); } return Qnil; } } if (pos > RSTRING_LEN(str)) pos = RSTRING_LEN(str); } else { pos = RSTRING_LEN(str); } switch (TYPE(sub)) { case T_REGEXP: if (RREGEXP(sub)->len) { pos = rb_reg_adjust_startpos(sub, str, pos, 1); pos = rb_reg_search(sub, str, pos, 1); } if (pos >= 0) return LONG2NUM(pos); break; case T_STRING: pos = rb_str_rindex(str, sub, pos); if (pos >= 0) return LONG2NUM(pos); break; case T_FIXNUM: { int c = FIX2INT(sub); char *p = RSTRING_PTR(str) + pos; char *pbeg = RSTRING_PTR(str); if (pos == RSTRING_LEN(str)) { if (pos == 0) return Qnil; --p; } while (pbeg <= p) { if ((unsigned char)*p == c) return LONG2NUM((char*)p - RSTRING_PTR(str)); p--; } return Qnil; } default: rb_raise(rb_eTypeError, "type mismatch: %s given", rb_obj_classname(sub)); } return Qnil; } /* * call-seq: * str =~ obj => fixnum or nil * * Match---If obj is a Regexp, use it as a pattern to match * against str,and returns the position the match starts, or * nil if there is no match. Otherwise, invokes * obj.=~, passing str as an argument. The default * =~ in Object returns false. * * "cat o' 9 tails" =~ /\d/ #=> 7 * "cat o' 9 tails" =~ 9 #=> false */ static VALUE rb_str_match(VALUE x, VALUE y) { switch (TYPE(y)) { case T_STRING: rb_raise(rb_eTypeError, "type mismatch: String given"); case T_REGEXP: return rb_reg_match(y, x); default: return rb_funcall(y, rb_intern("=~"), 1, x); } } static VALUE get_pat(VALUE, int); /* * call-seq: * str.match(pattern) => matchdata or nil * * Converts pattern to a Regexp (if it isn't already one), * then invokes its match method on str. If the second * parameter is present, it specifies the position in the string to begin the * search. * * 'hello'.match('(.)\1') #=> # * 'hello'.match('(.)\1')[0] #=> "ll" * 'hello'.match(/(.)\1/)[0] #=> "ll" * 'hello'.match('xx') #=> nil */ static VALUE rb_str_match_m(int argc, VALUE *argv, VALUE str) { VALUE re; if (argc < 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); re = argv[0]; argv[0] = str; return rb_funcall2(get_pat(re, 0), rb_intern("match"), argc, argv); } static char succ_char(char *s) { char c = *s; /* numerics */ if ('0' <= c && c < '9') (*s)++; else if (c == '9') { *s = '0'; return '1'; } /* small alphabets */ else if ('a' <= c && c < 'z') (*s)++; else if (c == 'z') { return *s = 'a'; } /* capital alphabets */ else if ('A' <= c && c < 'Z') (*s)++; else if (c == 'Z') { return *s = 'A'; } return 0; } /* * call-seq: * str.succ => new_str * str.next => new_str * * Returns the successor to str. The successor is calculated by * incrementing characters starting from the rightmost alphanumeric (or * the rightmost character if there are no alphanumerics) in the * string. Incrementing a digit always results in another digit, and * incrementing a letter results in another letter of the same case. * Incrementing nonalphanumerics uses the underlying character set's * collating sequence. * * If the increment generates a ``carry,'' the character to the left of * it is incremented. This process repeats until there is no carry, * adding an additional character if necessary. * * "abcd".succ #=> "abce" * "THX1138".succ #=> "THX1139" * "<>".succ #=> "<>" * "1999zzz".succ #=> "2000aaa" * "ZZZ9999".succ #=> "AAAA0000" * "***".succ #=> "**+" */ static VALUE rb_str_succ(VALUE orig) { VALUE str; char *sbeg, *s; int c = -1; long n = 0; str = rb_str_new5(orig, RSTRING_PTR(orig), RSTRING_LEN(orig)); OBJ_INFECT(str, orig); if (RSTRING_LEN(str) == 0) return str; sbeg = RSTRING_PTR(str); s = sbeg + RSTRING_LEN(str) - 1; while (sbeg <= s) { if (ISALNUM(*s)) { if ((c = succ_char(s)) == 0) break; n = s - sbeg; } s--; } if (c == -1) { /* str contains no alnum */ sbeg = RSTRING_PTR(str); s = sbeg + RSTRING_LEN(str) - 1; c = '\001'; while (sbeg <= s) { if ((*s += 1) != 0) break; s--; } } if (s < sbeg) { RESIZE_CAPA(str, RSTRING_LEN(str) + 1); s = RSTRING_PTR(str) + n; memmove(s+1, s, RSTRING_LEN(str) - n); *s = c; STR_SET_LEN(str, RSTRING_LEN(str) + 1); RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; } return str; } /* * call-seq: * str.succ! => str * str.next! => str * * Equivalent to String#succ, but modifies the receiver in * place. */ static VALUE rb_str_succ_bang(VALUE str) { rb_str_shared_replace(str, rb_str_succ(str)); return str; } VALUE rb_str_upto(VALUE beg, VALUE end, int excl) { VALUE current, after_end; ID succ = rb_intern("succ"); int n; StringValue(end); n = rb_str_cmp(beg, end); if (n > 0 || (excl && n == 0)) return beg; after_end = rb_funcall(end, succ, 0, 0); current = beg; while (!rb_str_equal(current, after_end)) { rb_yield(current); if (!excl && rb_str_equal(current, end)) break; current = rb_funcall(current, succ, 0, 0); StringValue(current); if (excl && rb_str_equal(current, end)) break; StringValue(current); if (RSTRING_LEN(current) > RSTRING_LEN(end)) break; } return beg; } /* * call-seq: * str.upto(other_str) {|s| block } => str * * Iterates through successive values, starting at str and * ending at other_str inclusive, passing each value in turn to * the block. The String#succ method is used to generate * each value. * * "a8".upto("b6") {|s| print s, ' ' } * for s in "a8".."b6" * print s, ' ' * end * * produces: * * a8 a9 b0 b1 b2 b3 b4 b5 b6 * a8 a9 b0 b1 b2 b3 b4 b5 b6 */ static VALUE rb_str_upto_m(VALUE beg, VALUE end) { return rb_str_upto(beg, end, Qfalse); } static VALUE rb_str_subpat(VALUE str, VALUE re, int nth) { if (rb_reg_search(re, str, 0, 0) >= 0) { return rb_reg_nth_match(nth, rb_backref_get()); } return Qnil; } static VALUE rb_str_aref(VALUE str, VALUE indx) { long idx; switch (TYPE(indx)) { case T_FIXNUM: idx = FIX2LONG(indx); num_index: if (idx < 0) { idx = RSTRING_LEN(str) + idx; } if (idx < 0 || RSTRING_LEN(str) <= idx) { return Qnil; } return rb_str_substr(str, idx, 1); case T_REGEXP: return rb_str_subpat(str, indx, 0); case T_STRING: if (rb_str_index(str, indx, 0) != -1) return rb_str_dup(indx); return Qnil; default: /* check if indx is Range */ { long beg, len; VALUE tmp; switch (rb_range_beg_len(indx, &beg, &len, RSTRING_LEN(str), 0)) { case Qfalse: break; case Qnil: return Qnil; default: tmp = rb_str_substr(str, beg, len); OBJ_INFECT(tmp, indx); return tmp; } } idx = NUM2LONG(indx); goto num_index; } return Qnil; /* not reached */ } /* * call-seq: * str[fixnum] => new_str or nil * str[fixnum, fixnum] => new_str or nil * str[range] => new_str or nil * str[regexp] => new_str or nil * str[regexp, fixnum] => new_str or nil * str[other_str] => new_str or nil * str.slice(fixnum) => new_str or nil * str.slice(fixnum, fixnum) => new_str or nil * str.slice(range) => new_str or nil * str.slice(regexp) => new_str or nil * str.slice(regexp, fixnum) => new_str or nil * str.slice(other_str) => new_str or nil * * Element Reference---If passed a single Fixnum, returns a * substring of one character at that position. If passed two Fixnum * objects, returns a substring starting at the offset given by the first, and * a length given by the second. If given a range, a substring containing * characters at offsets given by the range is returned. In all three cases, if * an offset is negative, it is counted from the end of str. Returns * nil if the initial offset falls outside the string, the length * is negative, or the beginning of the range is greater than the end. * * If a Regexp is supplied, the matching portion of str is * returned. If a numeric parameter follows the regular expression, that * component of the MatchData is returned instead. If a * String is given, that string is returned if it occurs in * str. In both cases, nil is returned if there is no * match. * * a = "hello there" * a[1] #=> "e" * a[1,3] #=> "ell" * a[1..3] #=> "ell" * a[-3,2] #=> "er" * a[-4..-2] #=> "her" * a[12..-1] #=> nil * a[-2..-4] #=> "" * a[/[aeiou](.)\1/] #=> "ell" * a[/[aeiou](.)\1/, 0] #=> "ell" * a[/[aeiou](.)\1/, 1] #=> "l" * a[/[aeiou](.)\1/, 2] #=> nil * a["lo"] #=> "lo" * a["bye"] #=> nil */ static VALUE rb_str_aref_m(int argc, VALUE *argv, VALUE str) { if (argc == 2) { if (TYPE(argv[0]) == T_REGEXP) { return rb_str_subpat(str, argv[0], NUM2INT(argv[1])); } return rb_str_substr(str, NUM2LONG(argv[0]), NUM2LONG(argv[1])); } if (argc != 1) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); } return rb_str_aref(str, argv[0]); } static void rb_str_splice(VALUE str, long beg, long len, VALUE val) { if (len < 0) rb_raise(rb_eIndexError, "negative length %ld", len); StringValue(val); rb_str_modify(str); if (RSTRING_LEN(str) < beg) { out_of_range: rb_raise(rb_eIndexError, "index %ld out of string", beg); } if (beg < 0) { if (-beg > RSTRING_LEN(str)) { goto out_of_range; } beg += RSTRING_LEN(str); } if (RSTRING_LEN(str) < beg + len) { len = RSTRING_LEN(str) - beg; } if (len < RSTRING_LEN(val)) { /* expand string */ RESIZE_CAPA(str, RSTRING_LEN(str) + RSTRING_LEN(val) - len + 1); } if (RSTRING_LEN(val) != len) { memmove(RSTRING_PTR(str) + beg + RSTRING_LEN(val), RSTRING_PTR(str) + beg + len, RSTRING_LEN(str) - (beg + len)); } if (RSTRING_LEN(str) < beg && len < 0) { MEMZERO(RSTRING_PTR(str) + RSTRING_LEN(str), char, -len); } if (RSTRING_LEN(val) > 0) { memmove(RSTRING_PTR(str)+beg, RSTRING_PTR(val), RSTRING_LEN(val)); } STR_SET_LEN(str, RSTRING_LEN(str) + RSTRING_LEN(val) - len); if (RSTRING_PTR(str)) { RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; } OBJ_INFECT(str, val); } void rb_str_update(VALUE str, long beg, long len, VALUE val) { rb_str_splice(str, beg, len, val); } static void rb_str_subpat_set(VALUE str, VALUE re, int nth, VALUE val) { VALUE match; long start, end, len; if (rb_reg_search(re, str, 0, 0) < 0) { rb_raise(rb_eIndexError, "regexp not matched"); } match = rb_backref_get(); if (nth >= RMATCH(match)->regs->num_regs) { out_of_range: rb_raise(rb_eIndexError, "index %d out of regexp", nth); } if (nth < 0) { if (-nth >= RMATCH(match)->regs->num_regs) { goto out_of_range; } nth += RMATCH(match)->regs->num_regs; } start = RMATCH(match)->BEG(nth); if (start == -1) { rb_raise(rb_eIndexError, "regexp group %d not matched", nth); } end = RMATCH(match)->END(nth); len = end - start; rb_str_splice(str, start, len, val); } static VALUE rb_str_aset(VALUE str, VALUE indx, VALUE val) { long idx, beg; switch (TYPE(indx)) { case T_FIXNUM: num_index: idx = FIX2LONG(indx); if (RSTRING_LEN(str) <= idx) { out_of_range: rb_raise(rb_eIndexError, "index %ld out of string", idx); } if (idx < 0) { if (-idx > RSTRING_LEN(str)) goto out_of_range; idx += RSTRING_LEN(str); } rb_str_splice(str, idx, 1, val); return val; case T_REGEXP: rb_str_subpat_set(str, indx, 0, val); return val; case T_STRING: beg = rb_str_index(str, indx, 0); if (beg < 0) { rb_raise(rb_eIndexError, "string not matched"); } rb_str_splice(str, beg, RSTRING_LEN(indx), val); return val; default: /* check if indx is Range */ { long beg, len; if (rb_range_beg_len(indx, &beg, &len, RSTRING_LEN(str), 2)) { rb_str_splice(str, beg, len, val); return val; } } idx = NUM2LONG(indx); goto num_index; } } /* * call-seq: * str[fixnum] = new_str * str[fixnum, fixnum] = new_str * str[range] = aString * str[regexp] = new_str * str[regexp, fixnum] = new_str * str[other_str] = new_str * * Element Assignment---Replaces some or all of the content of str. The * portion of the string affected is determined using the same criteria as * String#[]. If the replacement string is not the same length as * the text it is replacing, the string will be adjusted accordingly. If the * regular expression or string is used as the index doesn't match a position * in the string, IndexError is raised. If the regular expression * form is used, the optional second Fixnum allows you to specify * which portion of the match to replace (effectively using the * MatchData indexing rules. The forms that take a * Fixnum will raise an IndexError if the value is * out of range; the Range form will raise a * RangeError, and the Regexp and String * forms will silently ignore the assignment. */ static VALUE rb_str_aset_m(int argc, VALUE *argv, VALUE str) { if (argc == 3) { if (TYPE(argv[0]) == T_REGEXP) { rb_str_subpat_set(str, argv[0], NUM2INT(argv[1]), argv[2]); } else { rb_str_splice(str, NUM2LONG(argv[0]), NUM2LONG(argv[1]), argv[2]); } return argv[2]; } if (argc != 2) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); } return rb_str_aset(str, argv[0], argv[1]); } /* * call-seq: * str.insert(index, other_str) => str * * Inserts other_str before the character at the given * index, modifying str. Negative indices count from the * end of the string, and insert after the given character. * The intent is insert aString so that it starts at the given * index. * * "abcd".insert(0, 'X') #=> "Xabcd" * "abcd".insert(3, 'X') #=> "abcXd" * "abcd".insert(4, 'X') #=> "abcdX" * "abcd".insert(-3, 'X') #=> "abXcd" * "abcd".insert(-1, 'X') #=> "abcdX" */ static VALUE rb_str_insert(VALUE str, VALUE idx, VALUE str2) { long pos = NUM2LONG(idx); if (pos == -1) { pos = RSTRING_LEN(str); } else if (pos < 0) { pos++; } rb_str_splice(str, pos, 0, str2); return str; } /* * call-seq: * str.slice!(fixnum) => fixnum or nil * str.slice!(fixnum, fixnum) => new_str or nil * str.slice!(range) => new_str or nil * str.slice!(regexp) => new_str or nil * str.slice!(other_str) => new_str or nil * * Deletes the specified portion from str, and returns the portion * deleted. The forms that take a Fixnum will raise an * IndexError if the value is out of range; the Range * form will raise a RangeError, and the Regexp and * String forms will silently ignore the assignment. * * string = "this is a string" * string.slice!(2) #=> 105 * string.slice!(3..6) #=> " is " * string.slice!(/s.*t/) #=> "sa st" * string.slice!("r") #=> "r" * string #=> "thing" */ static VALUE rb_str_slice_bang(int argc, VALUE *argv, VALUE str) { VALUE result; VALUE buf[3]; int i; if (argc < 1 || 2 < argc) { rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc); } for (i=0; i str or nil * str.sub!(pattern) {|match| block } => str or nil * * Performs the substitutions of String#sub in place, * returning str, or nil if no substitutions were * performed. */ static VALUE rb_str_sub_bang(int argc, VALUE *argv, VALUE str) { VALUE pat, repl, match; struct re_registers *regs; int iter = 0; int tainted = 0; long plen; if (argc == 1 && rb_block_given_p()) { iter = 1; } else if (argc == 2) { repl = argv[1]; StringValue(repl); if (OBJ_TAINTED(repl)) tainted = 1; } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); } pat = get_pat(argv[0], 1); if (rb_reg_search(pat, str, 0, 0) >= 0) { rb_str_modify(str); match = rb_backref_get(); regs = RMATCH(match)->regs; if (iter) { char *p = RSTRING_PTR(str); long len = RSTRING_LEN(str); rb_match_busy(match); repl = rb_obj_as_string(rb_yield(rb_reg_nth_match(0, match))); str_mod_check(str, p, len); str_frozen_check(str); rb_backref_set(match); } else { repl = rb_reg_regsub(repl, str, regs, pat); } if (OBJ_TAINTED(repl)) tainted = 1; plen = END(0) - BEG(0); if (RSTRING_LEN(repl) > plen) { RESIZE_CAPA(str, RSTRING_LEN(str) + RSTRING_LEN(repl) - plen); } if (RSTRING_LEN(repl) != plen) { memmove(RSTRING_PTR(str) + BEG(0) + RSTRING_LEN(repl), RSTRING_PTR(str) + BEG(0) + plen, RSTRING_LEN(str) - BEG(0) - plen); } memcpy(RSTRING_PTR(str) + BEG(0), RSTRING_PTR(repl), RSTRING_LEN(repl)); STR_SET_LEN(str, RSTRING_LEN(str) + RSTRING_LEN(repl) - plen); RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; if (tainted) OBJ_TAINT(str); return str; } return Qnil; } /* * call-seq: * str.sub(pattern, replacement) => new_str * str.sub(pattern) {|match| block } => new_str * * Returns a copy of str with the first occurrence of * pattern replaced with either replacement or the value of the * block. The pattern will typically be a Regexp; if it is * a String then no regular expression metacharacters will be * interpreted (that is /\d/ will match a digit, but * '\d' will match a backslash followed by a 'd'). * * If the method call specifies replacement, special variables such as * $& will not be useful, as substitution into the string occurs * before the pattern match starts. However, the sequences \1, * \2, \k, etc., may be used. * * In the block form, the current match string is passed in as a parameter, and * variables such as $1, $2, $`, * $&, and $' will be set appropriately. The value * returned by the block will be substituted for the match on each call. * * The result inherits any tainting in the original string or any supplied * replacement string. * * "hello".sub(/[aeiou]/, '*') #=> "h*llo" * "hello".sub(/([aeiou])/, '<\1>') #=> "hllo" * "hello".sub(/./) {|s| s[0].to_s + ' ' } #=> "104 ello" * "hello".sub(/(?[aeiou])/, '*\k*') #=> "h*e*llo" */ static VALUE rb_str_sub(int argc, VALUE *argv, VALUE str) { str = rb_str_dup(str); rb_str_sub_bang(argc, argv, str); return str; } static VALUE str_gsub(int argc, VALUE *argv, VALUE str, int bang) { VALUE pat, val, repl, match, dest; struct re_registers *regs; long beg, n; long offset, blen, slen, len; int iter = 0; char *buf, *bp, *sp, *cp; int tainted = 0; switch (argc) { case 1: RETURN_ENUMERATOR(str, argc, argv); iter = 1; break; case 2: repl = argv[1]; StringValue(repl); if (OBJ_TAINTED(repl)) tainted = 1; break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc); } pat = get_pat(argv[0], 1); offset=0; n=0; beg = rb_reg_search(pat, str, 0, 0); if (beg < 0) { if (bang) return Qnil; /* no match, no substitution */ return rb_str_dup(str); } blen = RSTRING_LEN(str) + 30; /* len + margin */ dest = str_new(0, 0, blen); buf = RSTRING_PTR(dest); bp = buf; sp = cp = RSTRING_PTR(str); slen = RSTRING_LEN(str); rb_str_locktmp(dest); while (beg >= 0) { n++; match = rb_backref_get(); regs = RMATCH(match)->regs; if (iter) { rb_match_busy(match); val = rb_obj_as_string(rb_yield(rb_reg_nth_match(0, match))); str_mod_check(str, sp, slen); if (bang) str_frozen_check(str); if (val == dest) { /* paranoid chack [ruby-dev:24827] */ rb_raise(rb_eRuntimeError, "block should not cheat"); } rb_backref_set(match); } else { val = rb_reg_regsub(repl, str, regs, pat); } if (OBJ_TAINTED(val)) tainted = 1; len = (bp - buf) + (beg - offset) + RSTRING_LEN(val) + 3; if (blen < len) { while (blen < len) blen *= 2; len = bp - buf; RESIZE_CAPA(dest, blen); STR_SET_LEN(dest, blen); buf = RSTRING_PTR(dest); bp = buf + len; } len = beg - offset; /* copy pre-match substr */ memcpy(bp, cp, len); bp += len; memcpy(bp, RSTRING_PTR(val), RSTRING_LEN(val)); bp += RSTRING_LEN(val); offset = END(0); if (BEG(0) == END(0)) { /* * Always consume at least one character of the input string * in order to prevent infinite loops. */ if (RSTRING_LEN(str) <= END(0)) break; len = mbclen2(RSTRING_PTR(str)[END(0)], pat); memcpy(bp, RSTRING_PTR(str)+END(0), len); bp += len; offset = END(0) + len; } cp = RSTRING_PTR(str) + offset; if (offset > RSTRING_LEN(str)) break; beg = rb_reg_search(pat, str, offset, 0); } if (RSTRING_LEN(str) > offset) { len = bp - buf; if (blen - len < RSTRING_LEN(str) - offset) { blen = len + RSTRING_LEN(str) - offset; RESIZE_CAPA(dest, blen); buf = RSTRING_PTR(dest); bp = buf + len; } memcpy(bp, cp, RSTRING_LEN(str) - offset); bp += RSTRING_LEN(str) - offset; } rb_backref_set(match); *bp = '\0'; rb_str_unlocktmp(dest); if (bang) { if (str_independent(str) && !STR_EMBED_P(str)) { free(RSTRING_PTR(str)); } STR_SET_NOEMBED(str); STR_UNSET_NOCAPA(str); RSTRING(str)->as.heap.ptr = buf; RSTRING(str)->as.heap.aux.capa = blen; RSTRING(dest)->as.heap.ptr = 0; RSTRING(dest)->as.heap.len = 0; } else { RBASIC(dest)->klass = rb_obj_class(str); OBJ_INFECT(dest, str); str = dest; } STR_SET_LEN(str, bp - buf); if (tainted) OBJ_TAINT(str); return str; } /* * call-seq: * str.gsub!(pattern, replacement) => str or nil * str.gsub!(pattern) {|match| block } => str or nil * * Performs the substitutions of String#gsub in place, returning * str, or nil if no substitutions were performed. */ static VALUE rb_str_gsub_bang(int argc, VALUE *argv, VALUE str) { return str_gsub(argc, argv, str, 1); } /* * call-seq: * str.gsub(pattern, replacement) => new_str * str.gsub(pattern) {|match| block } => new_str * * Returns a copy of str with all occurrences of pattern * replaced with either replacement or the value of the block. The * pattern will typically be a Regexp; if it is a * String then no regular expression metacharacters will be * interpreted (that is /\d/ will match a digit, but * '\d' will match a backslash followed by a 'd'). * * If a string is used as the replacement, special variables from the match * (such as $& and $1) cannot be substituted into it, * as substitution into the string occurs before the pattern match * starts. However, the sequences \1, \2, * \k, and so on may be used to interpolate * successive groups in the match. * * In the block form, the current match string is passed in as a parameter, and * variables such as $1, $2, $`, * $&, and $' will be set appropriately. The value * returned by the block will be substituted for the match on each call. * * The result inherits any tainting in the original string or any supplied * replacement string. * * "hello".gsub(/[aeiou]/, '*') #=> "h*ll*" * "hello".gsub(/([aeiou])/, '<\1>') #=> "hll" * "hello".gsub(/./) {|s| s[0].to_s + ' '} #=> "104 101 108 108 111 " * "hello".gsub(/(?[aeiou])/, '{\k}') #=> "h{e}ll{o}" */ static VALUE rb_str_gsub(int argc, VALUE *argv, VALUE str) { return str_gsub(argc, argv, str, 0); } /* * call-seq: * str.replace(other_str) => str * * Replaces the contents and taintedness of str with the corresponding * values in other_str. * * s = "hello" #=> "hello" * s.replace "world" #=> "world" */ static VALUE rb_str_replace(VALUE str, VALUE str2) { long len; if (str == str2) return str; StringValue(str2); len = RSTRING_LEN(str2); if (STR_SHARED_P(str2)) { if (str_independent(str) && !STR_EMBED_P(str)) { free(RSTRING_PTR(str)); } STR_SET_NOEMBED(str); RSTRING(str)->as.heap.len = len; RSTRING(str)->as.heap.ptr = RSTRING_PTR(str2); FL_SET(str, ELTS_SHARED); FL_UNSET(str, STR_ASSOC); RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared; } else if (STR_ASSOC_P(str2)) { rb_str_modify(str); STR_SET_NOEMBED(str); RSTRING(str)->as.heap.ptr = ALLOC_N(char,len+1); memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), len+1); FL_SET(str, STR_ASSOC); RSTRING(str)->as.heap.aux.shared = RSTRING(str2)->as.heap.aux.shared; } else { rb_str_modify(str); rb_str_resize(str, len); memcpy(RSTRING_PTR(str), RSTRING_PTR(str2), len+1); } OBJ_INFECT(str, str2); return str; } /* * call-seq: * string.clear -> string * * Makes string empty. * * a = "abcde" * a.clear #=> "" */ static VALUE rb_str_clear(VALUE str) { /* rb_str_modify() */ /* no need for str_make_independent */ if (str_independent(str)) { free(RSTRING_PTR(str)); } STR_SET_EMBED(str); STR_SET_EMBED_LEN(str, 0); RSTRING_PTR(str)[0] = 0; return str; } /* * call-seq: * string.chr -> string * * Returns a one-character string at the beginning of the string. * * a = "abcde" * a.chr #=> "a" */ static VALUE rb_str_chr(VALUE str) { return rb_str_substr(str, 0, 1); } /* * call-seq: * str.reverse! => str * * Reverses str in place. */ static VALUE rb_str_reverse_bang(VALUE str) { char *s, *e; char c; if (RSTRING_LEN(str) > 1) { rb_str_modify(str); s = RSTRING_PTR(str); e = s + RSTRING_LEN(str) - 1; while (s < e) { c = *s; *s++ = *e; *e-- = c; } } return str; } /* * call-seq: * str.reverse => new_str * * Returns a new string with the characters from str in reverse order. * * "stressed".reverse #=> "desserts" */ static VALUE rb_str_reverse(VALUE str) { VALUE obj; char *s, *e, *p; if (RSTRING_LEN(str) <= 1) return rb_str_dup(str); obj = rb_str_new5(str, 0, RSTRING_LEN(str)); s = RSTRING_PTR(str); e = s + RSTRING_LEN(str) - 1; p = RSTRING_PTR(obj); while (e >= s) { *p++ = *e--; } OBJ_INFECT(obj, str); return obj; } /* * call-seq: * str.include? other_str => true or false * str.include? fixnum => true or false * * Returns true if str contains the given string or * character. * * "hello".include? "lo" #=> true * "hello".include? "ol" #=> false * "hello".include? ?h #=> true */ static VALUE rb_str_include(VALUE str, VALUE arg) { long i; if (FIXNUM_P(arg)) { if (memchr(RSTRING_PTR(str), FIX2INT(arg), RSTRING_LEN(str))) return Qtrue; return Qfalse; } StringValue(arg); i = rb_str_index(str, arg, 0); if (i == -1) return Qfalse; return Qtrue; } /* * call-seq: * str.to_i(base=10) => integer * * Returns the result of interpreting leading characters in str as an * integer base base (2, 8, 10, or 16). Extraneous characters past the * end of a valid number are ignored. If there is not a valid number at the * start of str, 0 is returned. This method never raises an * exception. * * "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) { VALUE b; int base; rb_scan_args(argc, argv, "01", &b); if (argc == 0) base = 10; else base = NUM2INT(b); if (base < 0) { rb_raise(rb_eArgError, "illegal radix %d", base); } return rb_str_to_inum(str, base, Qfalse); } /* * call-seq: * str.to_f => float * * Returns the result of interpreting leading characters in str as a * floating point number. Extraneous characters past the end of a valid number * are ignored. If there is not a valid number at the start of str, * 0.0 is returned. This method never raises an exception. * * "123.45e1".to_f #=> 1234.5 * "45.67 degrees".to_f #=> 45.67 * "thx1138".to_f #=> 0.0 */ static VALUE rb_str_to_f(VALUE str) { return rb_float_new(rb_str_to_dbl(str, Qfalse)); } /* * call-seq: * str.to_s => str * str.to_str => str * * Returns the receiver. */ static VALUE rb_str_to_s(VALUE str) { if (rb_obj_class(str) != rb_cString) { VALUE dup = str_alloc(rb_cString); rb_str_replace(dup, str); return dup; } return str; } #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{')) /* * call-seq: * str.inspect => string * * Returns a printable version of _str_, srrounded by quote marks, * with special characters escaped. * * str = "hello" * str[3] = "\b" * str.inspect #=> "\"hel\bo\"" */ VALUE rb_str_inspect(VALUE str) { char *p, *pend; VALUE result = rb_str_buf_new2("\""); char s[5]; p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); while (p < pend) { char c = *p++; if (ismbchar(c) && p < pend) { int len = mbclen(c); rb_str_buf_cat(result, p - 1, len); p += len - 1; } else if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p, pend))) { s[0] = '\\'; s[1] = c; rb_str_buf_cat(result, s, 2); } else if (ISPRINT(c)) { s[0] = c; rb_str_buf_cat(result, s, 1); } else if (c == '\n') { s[0] = '\\'; s[1] = 'n'; rb_str_buf_cat(result, s, 2); } else if (c == '\r') { s[0] = '\\'; s[1] = 'r'; rb_str_buf_cat(result, s, 2); } else if (c == '\t') { s[0] = '\\'; s[1] = 't'; rb_str_buf_cat(result, s, 2); } else if (c == '\f') { s[0] = '\\'; s[1] = 'f'; rb_str_buf_cat(result, s, 2); } else if (c == '\013') { s[0] = '\\'; s[1] = 'v'; rb_str_buf_cat(result, s, 2); } else if (c == '\010') { s[0] = '\\'; s[1] = 'b'; rb_str_buf_cat(result, s, 2); } else if (c == '\007') { s[0] = '\\'; s[1] = 'a'; rb_str_buf_cat(result, s, 2); } else if (c == 033) { s[0] = '\\'; s[1] = 'e'; rb_str_buf_cat(result, s, 2); } else { sprintf(s, "\\%03o", c & 0377); rb_str_buf_cat2(result, s); } } rb_str_buf_cat2(result, "\""); OBJ_INFECT(result, str); return result; } /* * call-seq: * str.dump => new_str * * Produces a version of str with all nonprinting characters replaced by * \nnn notation and all special characters escaped. */ VALUE rb_str_dump(VALUE str) { long len; char *p, *pend; char *q, *qend; VALUE result; len = 2; /* "" */ p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); while (p < pend) { char c = *p++; switch (c) { case '"': case '\\': case '\n': case '\r': case '\t': case '\f': case '\013': case '\010': case '\007': case '\033': len += 2; break; case '#': len += IS_EVSTR(p, pend) ? 2 : 1; break; default: if (ISPRINT(c)) { len++; } else { len += 4; /* \nnn */ } break; } } result = rb_str_new5(str, 0, len); p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); q = RSTRING_PTR(result); qend = q + len; *q++ = '"'; while (p < pend) { char c = *p++; if (c == '"' || c == '\\') { *q++ = '\\'; *q++ = c; } else if (c == '#') { if (IS_EVSTR(p, pend)) *q++ = '\\'; *q++ = '#'; } else if (ISPRINT(c)) { *q++ = c; } 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 { *q++ = '\\'; sprintf(q, "%03o", c&0xff); q += 3; } } *q++ = '"'; OBJ_INFECT(result, str); return result; } /* * call-seq: * str.upcase! => str or nil * * Upcases the contents of str, returning nil if no changes * were made. */ static VALUE rb_str_upcase_bang(VALUE str) { char *s, *send; int modify = 0; rb_str_modify(str); s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); while (s < send) { if (ismbchar(*s)) { s+=mbclen(*s) - 1; } else if (ISLOWER(*s)) { *s = toupper(*s); modify = 1; } s++; } if (modify) return str; return Qnil; } /* * call-seq: * str.upcase => new_str * * Returns a copy of str with all lowercase letters replaced with their * uppercase counterparts. The operation is locale insensitive---only * characters ``a'' to ``z'' are affected. * * "hEllO".upcase #=> "HELLO" */ static VALUE rb_str_upcase(VALUE str) { str = rb_str_dup(str); rb_str_upcase_bang(str); return str; } /* * call-seq: * str.downcase! => str or nil * * Downcases the contents of str, returning nil if no * changes were made. */ static VALUE rb_str_downcase_bang(VALUE str) { char *s, *send; int modify = 0; rb_str_modify(str); s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); while (s < send) { if (ismbchar(*s)) { s+=mbclen(*s) - 1; } else if (ISUPPER(*s)) { *s = tolower(*s); modify = 1; } s++; } if (modify) return str; return Qnil; } /* * call-seq: * str.downcase => new_str * * Returns a copy of str with all uppercase letters replaced with their * lowercase counterparts. The operation is locale insensitive---only * characters ``A'' to ``Z'' are affected. * * "hEllO".downcase #=> "hello" */ static VALUE rb_str_downcase(VALUE str) { str = rb_str_dup(str); rb_str_downcase_bang(str); return str; } /* * call-seq: * str.capitalize! => str or nil * * Modifies str by converting the first character to uppercase and the * remainder to lowercase. Returns nil if no changes are made. * * a = "hello" * a.capitalize! #=> "Hello" * a #=> "Hello" * a.capitalize! #=> nil */ static VALUE rb_str_capitalize_bang(VALUE str) { char *s, *send; int modify = 0; rb_str_modify(str); if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); if (ISLOWER(*s)) { *s = toupper(*s); modify = 1; } while (++s < send) { if (ismbchar(*s)) { s+=mbclen(*s) - 1; } else if (ISUPPER(*s)) { *s = tolower(*s); modify = 1; } } if (modify) return str; return Qnil; } /* * call-seq: * str.capitalize => new_str * * Returns a copy of str with the first character converted to uppercase * and the remainder to lowercase. * * "hello".capitalize #=> "Hello" * "HELLO".capitalize #=> "Hello" * "123ABC".capitalize #=> "123abc" */ static VALUE rb_str_capitalize(VALUE str) { str = rb_str_dup(str); rb_str_capitalize_bang(str); return str; } /* * call-seq: * str.swapcase! => str or nil * * Equivalent to String#swapcase, but modifies the receiver in * place, returning str, or nil if no changes were made. */ static VALUE rb_str_swapcase_bang(VALUE str) { char *s, *send; int modify = 0; rb_str_modify(str); s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); while (s < send) { if (ismbchar(*s)) { s+=mbclen(*s) - 1; } else if (ISUPPER(*s)) { *s = tolower(*s); modify = 1; } else if (ISLOWER(*s)) { *s = toupper(*s); modify = 1; } s++; } if (modify) return str; return Qnil; } /* * call-seq: * str.swapcase => new_str * * Returns a copy of str with uppercase alphabetic characters converted * to lowercase and lowercase characters converted to uppercase. * * "Hello".swapcase #=> "hELLO" * "cYbEr_PuNk11".swapcase #=> "CyBeR_pUnK11" */ static VALUE rb_str_swapcase(VALUE str) { str = rb_str_dup(str); rb_str_swapcase_bang(str); return str; } typedef unsigned char *USTR; struct tr { int gen, now, max; char *p, *pend; }; static int trnext(struct tr *t) { for (;;) { if (!t->gen) { if (t->p == t->pend) return -1; if (t->p < t->pend - 1 && *t->p == '\\') { t->p++; } t->now = *(USTR)t->p++; if (t->p < t->pend - 1 && *t->p == '-') { t->p++; if (t->p < t->pend) { if (t->now > *(USTR)t->p) { t->p++; continue; } t->gen = 1; t->max = *(USTR)t->p++; } } return t->now; } else if (++t->now < t->max) { return t->now; } else { t->gen = 0; return t->max; } } } static VALUE rb_str_delete_bang(int,VALUE*,VALUE); static VALUE tr_trans(VALUE str, VALUE src, VALUE repl, int sflag) { struct tr trsrc, trrepl; int cflag = 0; int trans[256]; int i, c, modify = 0; char *s, *send; StringValue(src); StringValue(repl); if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return Qnil; trsrc.p = RSTRING_PTR(src); trsrc.pend = trsrc.p + RSTRING_LEN(src); if (RSTRING_LEN(src) >= 2 && RSTRING_PTR(src)[0] == '^') { cflag++; trsrc.p++; } if (RSTRING_LEN(repl) == 0) { return rb_str_delete_bang(1, &src, str); } trrepl.p = RSTRING_PTR(repl); trrepl.pend = trrepl.p + RSTRING_LEN(repl); trsrc.gen = trrepl.gen = 0; trsrc.now = trrepl.now = 0; trsrc.max = trrepl.max = 0; if (cflag) { for (i=0; i<256; i++) { trans[i] = 1; } while ((c = trnext(&trsrc)) >= 0) { trans[c & 0xff] = -1; } while ((c = trnext(&trrepl)) >= 0) /* retrieve last replacer */; for (i=0; i<256; i++) { if (trans[i] >= 0) { trans[i] = trrepl.now; } } } else { int r; for (i=0; i<256; i++) { trans[i] = -1; } while ((c = trnext(&trsrc)) >= 0) { r = trnext(&trrepl); if (r == -1) r = trrepl.now; trans[c & 0xff] = r; } } rb_str_modify(str); s = RSTRING_PTR(str); send = s + RSTRING_LEN(str); if (sflag) { char *t = s; int c0, last = -1; while (s < send) { c0 = *s++; if ((c = trans[c0 & 0xff]) >= 0) { if (last == c) continue; last = c; *t++ = c & 0xff; modify = 1; } else { last = -1; *t++ = c0; } } if (RSTRING_LEN(str) > (t - RSTRING_PTR(str))) { STR_SET_LEN(str, (t - RSTRING_PTR(str))); modify = 1; *t = '\0'; } } else { while (s < send) { if ((c = trans[*s & 0xff]) >= 0) { *s = c & 0xff; modify = 1; } s++; } } if (modify) return str; return Qnil; } /* * call-seq: * str.tr!(from_str, to_str) => str or nil * * Translates str in place, using the same rules as * String#tr. Returns str, or nil if no * changes were made. */ static VALUE rb_str_tr_bang(VALUE str, VALUE src, VALUE repl) { return tr_trans(str, src, repl, 0); } /* * call-seq: * str.tr(from_str, to_str) => new_str * * Returns a copy of str with the characters in from_str replaced * by the corresponding characters in to_str. If to_str is * shorter than from_str, it is padded with its last character. Both * strings may use the c1--c2 notation to denote ranges of characters, and * from_str may start with a ^, which denotes all * characters except those listed. * * "hello".tr('aeiou', '*') #=> "h*ll*" * "hello".tr('^aeiou', '*') #=> "*e**o" * "hello".tr('el', 'ip') #=> "hippo" * "hello".tr('a-y', 'b-z') #=> "ifmmp" */ static VALUE rb_str_tr(VALUE str, VALUE src, VALUE repl) { str = rb_str_dup(str); tr_trans(str, src, repl, 0); return str; } static void tr_setup_table(VALUE str, char table[256], int init) { char buf[256]; struct tr tr; int i, c; int cflag = 0; tr.p = RSTRING_PTR(str); tr.pend = tr.p + RSTRING_LEN(str); tr.gen = tr.now = tr.max = 0; if (RSTRING_LEN(str) > 1 && RSTRING_PTR(str)[0] == '^') { cflag = 1; tr.p++; } if (init) { for (i=0; i<256; i++) { table[i] = 1; } } for (i=0; i<256; i++) { buf[i] = cflag; } while ((c = trnext(&tr)) >= 0) { buf[c & 0xff] = !cflag; } for (i=0; i<256; i++) { table[i] = table[i] && buf[i]; } } /* * call-seq: * str.delete!([other_str]+) => str or nil * * Performs a delete operation in place, returning str, or * nil if str was not modified. */ static VALUE rb_str_delete_bang(int argc, VALUE *argv, VALUE str) { char *s, *send, *t; char squeez[256]; int modify = 0; int init = 1; int i; if (argc < 1) { rb_raise(rb_eArgError, "wrong number of arguments"); } for (i=0; i new_str * * Returns a copy of str with all characters in the intersection of its * arguments deleted. Uses the same rules for building the set of characters as * String#count. * * "hello".delete "l","lo" #=> "heo" * "hello".delete "lo" #=> "he" * "hello".delete "aeiou", "^e" #=> "hell" * "hello".delete "ej-m" #=> "ho" */ static VALUE rb_str_delete(int argc, VALUE *argv, VALUE str) { str = rb_str_dup(str); rb_str_delete_bang(argc, argv, str); return str; } /* * call-seq: * str.squeeze!([other_str]*) => str or nil * * Squeezes str in place, returning either str, or * nil if no changes were made. */ static VALUE rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str) { char squeez[256]; char *s, *send, *t; int c, save, modify = 0; int init = 1; int i; if (argc == 0) { for (i=0; i<256; i++) { squeez[i] = 1; } } else { for (i=0; i new_str * * Builds a set of characters from the other_str parameter(s) using the * procedure described for String#count. Returns a new string * where runs of the same character that occur in this set are replaced by a * single character. If no arguments are given, all runs of identical * characters are replaced by a single character. * * "yellow moon".squeeze #=> "yelow mon" * " now is the".squeeze(" ") #=> " now is the" * "putters shoot balls".squeeze("m-z") #=> "puters shot balls" */ static VALUE rb_str_squeeze(int argc, VALUE *argv, VALUE str) { str = rb_str_dup(str); rb_str_squeeze_bang(argc, argv, str); return str; } /* * call-seq: * str.tr_s!(from_str, to_str) => str or nil * * Performs String#tr_s processing on str in place, * returning str, or nil if no changes were made. */ static VALUE rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl) { return tr_trans(str, src, repl, 1); } /* * call-seq: * str.tr_s(from_str, to_str) => new_str * * Processes a copy of str as described under String#tr, * then removes duplicate characters in regions that were affected by the * translation. * * "hello".tr_s('l', 'r') #=> "hero" * "hello".tr_s('el', '*') #=> "h*o" * "hello".tr_s('el', 'hx') #=> "hhxo" */ static VALUE rb_str_tr_s(VALUE str, VALUE src, VALUE repl) { str = rb_str_dup(str); tr_trans(str, src, repl, 1); return str; } /* * call-seq: * str.count([other_str]+) => fixnum * * Each other_str parameter defines a set of characters to count. The * intersection of these sets defines the characters to count in * str. Any other_str that starts with a caret (^) is * negated. The sequence c1--c2 means all characters between c1 and c2. * * a = "hello world" * a.count "lo" #=> 5 * a.count "lo", "o" #=> 2 * a.count "hello", "^l" #=> 4 * a.count "ej-m" #=> 4 */ static VALUE rb_str_count(int argc, VALUE *argv, VALUE str) { char table[256]; char *s, *send; int init = 1; int i; if (argc < 1) { rb_raise(rb_eArgError, "wrong number of arguments"); } for (i=0; i anArray * * Divides str into substrings based on a delimiter, returning an array * of these substrings. * * If pattern is a String, then its contents are used as * the delimiter when splitting str. If pattern is a single * space, str is split on whitespace, with leading whitespace and runs * of contiguous whitespace characters ignored. * * If pattern is a Regexp, str is divided where the * pattern matches. Whenever the pattern matches a zero-length string, * str is split into individual characters. If pattern contains * groups, the respective matches will be returned in the array as well. * * If pattern is omitted, the value of $; is used. If * $; is nil (which is the default), str is * split on whitespace as if ` ' were specified. * * If the limit parameter is omitted, trailing null fields are * suppressed. If limit is a positive number, at most that number of * fields will be returned (if limit is 1, the entire * string is returned as the only entry in an array). If negative, there is no * limit to the number of fields returned, and trailing null fields are not * suppressed. * * " 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", "", ""] */ static VALUE rb_str_split_m(int argc, VALUE *argv, VALUE str) { VALUE spat; VALUE limit; int awk_split = Qfalse; long beg, end, i = 0; int lim = 0; VALUE result, tmp; if (rb_scan_args(argc, argv, "02", &spat, &limit) == 2) { lim = NUM2INT(limit); if (lim <= 0) limit = Qnil; else if (lim == 1) { if (RSTRING_LEN(str) == 0) return rb_ary_new2(0); return rb_ary_new3(1, str); } i = 1; } if (NIL_P(spat)) { if (!NIL_P(rb_fs)) { spat = rb_fs; goto fs_set; } awk_split = Qtrue; } else { fs_set: if (TYPE(spat) == T_STRING && RSTRING_LEN(spat) == 1) { if (RSTRING_PTR(spat)[0] == ' ') { awk_split = Qtrue; } else { spat = rb_reg_regcomp(rb_reg_quote(spat)); } } else { spat = get_pat(spat, 1); } } result = rb_ary_new(); beg = 0; if (awk_split) { char *ptr = RSTRING_PTR(str); long len = RSTRING_LEN(str); char *eptr = ptr + len; int skip = 1; for (end = beg = 0; ptr= 0) { regs = RMATCH(rb_backref_get())->regs; if (start == end && BEG(0) == END(0)) { if (!RSTRING_PTR(str)) { rb_ary_push(result, rb_str_new("", 0)); break; } else if (last_null == 1) { rb_ary_push(result, rb_str_substr(str, beg, mbclen2(RSTRING_PTR(str)[beg],spat))); beg = start; } else { start += mbclen2(RSTRING_PTR(str)[start],spat); last_null = 1; continue; } } else { rb_ary_push(result, rb_str_substr(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 = rb_str_new5(str, 0, 0); else tmp = rb_str_substr(str, BEG(idx), END(idx)-BEG(idx)); rb_ary_push(result, tmp); } if (!NIL_P(limit) && lim <= ++i) break; } } if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) { if (RSTRING_LEN(str) == beg) tmp = rb_str_new5(str, 0, 0); else tmp = rb_str_substr(str, beg, RSTRING_LEN(str)-beg); rb_ary_push(result, tmp); } if (NIL_P(limit) && lim == 0) { while (RARRAY_LEN(result) > 0 && RSTRING_LEN(RARRAY_PTR(result)[RARRAY_LEN(result)-1]) == 0) rb_ary_pop(result); } return result; } VALUE rb_str_split(VALUE str, const char *sep0) { VALUE sep; StringValue(str); sep = rb_str_new2(sep0); return rb_str_split_m(1, &sep, str); } /* * call-seq: * str.lines => anEnumerator * * Returns an enumerator that gives each line in the string. * * "foo\nbar\n".lines.to_a #=> ["foo\n", "bar\n"] * "foo\nb ar".lines.sort #=> ["b ar", "foo\n"] */ static VALUE rb_str_lines(VALUE str) { return rb_enumeratorize(str, ID2SYM(rb_intern("each_line")), 0, 0); } /* * call-seq: * str.bytes => anEnumerator * * Returns an enumerator that gives each byte in the string. * * "hello".bytes.to_a #=> [104, 101, 108, 108, 111] */ static VALUE rb_str_bytes(VALUE str) { return rb_enumeratorize(str, ID2SYM(rb_intern("each_byte")), 0, 0); } /* * call-seq: * str.each(separator=$/) {|substr| block } => str * str.each_line(separator=$/) {|substr| block } => str * * Splits str using the supplied parameter as the record separator * ($/ by default), passing each substring in turn to the supplied * block. If a zero-length record separator is supplied, the string is split on * \n characters, except that multiple successive newlines are * appended together. * * print "Example one\n" * "hello\nworld".each {|s| p s} * print "Example two\n" * "hello\nworld".each('l') {|s| p s} * print "Example three\n" * "hello\n\n\nworld".each('') {|s| p s} * * produces: * * Example one * "hello\n" * "world" * Example two * "hel" * "l" * "o\nworl" * "d" * Example three * "hello\n\n\n" * "world" */ static VALUE rb_str_each_line(int argc, VALUE *argv, VALUE str) { VALUE rs; int newline; char *p = RSTRING_PTR(str), *pend = p + RSTRING_LEN(str), *s; char *ptr = p; long len = RSTRING_LEN(str), rslen; VALUE line; if (rb_scan_args(argc, argv, "01", &rs) == 0) { rs = rb_rs; } RETURN_ENUMERATOR(str, argc, argv); if (NIL_P(rs)) { rb_yield(str); return str; } StringValue(rs); rslen = RSTRING_LEN(rs); if (rslen == 0) { newline = '\n'; } else { newline = RSTRING_PTR(rs)[rslen-1]; } for (s = p, p += rslen; p < pend; p++) { if (rslen == 0 && *p == '\n') { if (*++p != '\n') continue; while (*p == '\n') p++; } if (RSTRING_PTR(str) < p && p[-1] == newline && (rslen <= 1 || rb_memcmp(RSTRING_PTR(rs), p-rslen, rslen) == 0)) { line = rb_str_new5(str, s, p - s); OBJ_INFECT(line, str); rb_yield(line); str_mod_check(str, ptr, len); s = p; } } if (s != pend) { if (p > pend) p = pend; line = rb_str_new5(str, s, p - s); OBJ_INFECT(line, str); rb_yield(line); } return str; } /* * call-seq: * str.each_byte {|fixnum| block } => str * * Passes each byte in str to the given block. * * "hello".each_byte {|c| print c, ' ' } * * produces: * * 104 101 108 108 111 */ static VALUE rb_str_each_byte(VALUE str) { long i; RETURN_ENUMERATOR(str, 0, 0); for (i=0; i str or nil * * Processes str as for String#chop, returning str, * or nil if str is the empty string. See also * String#chomp!. */ static VALUE rb_str_chop_bang(VALUE str) { if (RSTRING_LEN(str) > 0) { rb_str_modify(str); STR_DEC_LEN(str); if (RSTRING_PTR(str)[RSTRING_LEN(str)] == '\n') { if (RSTRING_LEN(str) > 0 && RSTRING_PTR(str)[RSTRING_LEN(str)-1] == '\r') { STR_DEC_LEN(str); } } RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; return str; } return Qnil; } /* * call-seq: * str.chop => new_str * * Returns a new String with the last character removed. If the * string ends with \r\n, both characters are removed. Applying * chop to an empty string returns an empty * string. String#chomp is often a safer alternative, as it leaves * the string unchanged if it doesn't end in a record separator. * * "string\r\n".chop #=> "string" * "string\n\r".chop #=> "string\n" * "string\n".chop #=> "string" * "string".chop #=> "strin" * "x".chop.chop #=> "" */ static VALUE rb_str_chop(VALUE str) { str = rb_str_dup(str); rb_str_chop_bang(str); return str; } /* * call-seq: * str.chomp!(separator=$/) => str or nil * * Modifies str in place as described for String#chomp, * returning str, or nil if no modifications were made. */ static VALUE rb_str_chomp_bang(int argc, VALUE *argv, VALUE str) { VALUE rs; int newline; char *p; long len, rslen; if (rb_scan_args(argc, argv, "01", &rs) == 0) { len = RSTRING_LEN(str); if (len == 0) return Qnil; p = RSTRING_PTR(str); rs = rb_rs; if (rs == rb_default_rs) { smart_chomp: rb_str_modify(str); if (RSTRING_PTR(str)[len-1] == '\n') { STR_DEC_LEN(str); if (RSTRING_LEN(str) > 0 && RSTRING_PTR(str)[RSTRING_LEN(str)-1] == '\r') { STR_DEC_LEN(str); } } else if (RSTRING_PTR(str)[len-1] == '\r') { STR_DEC_LEN(str); } else { return Qnil; } RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; return str; } } if (NIL_P(rs)) return Qnil; StringValue(rs); len = RSTRING_LEN(str); if (len == 0) return Qnil; p = RSTRING_PTR(str); rslen = RSTRING_LEN(rs); if (rslen == 0) { while (len>0 && p[len-1] == '\n') { len--; if (len>0 && p[len-1] == '\r') len--; } if (len < RSTRING_LEN(str)) { rb_str_modify(str); STR_SET_LEN(str, len); RSTRING_PTR(str)[len] = '\0'; return str; } return Qnil; } if (rslen > len) return Qnil; newline = RSTRING_PTR(rs)[rslen-1]; if (rslen == 1 && newline == '\n') goto smart_chomp; if (p[len-1] == newline && (rslen <= 1 || rb_memcmp(RSTRING_PTR(rs), p+len-rslen, rslen) == 0)) { rb_str_modify(str); STR_SET_LEN(str, RSTRING_LEN(str) - rslen); RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; return str; } return Qnil; } /* * call-seq: * str.chomp(separator=$/) => new_str * * Returns a new String with the given record separator removed * from the end of str (if present). If $/ has not been * changed from the default Ruby record separator, then chomp also * removes carriage return characters (that is it will remove \n, * \r, and \r\n). * * "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" */ static VALUE rb_str_chomp(int argc, VALUE *argv, VALUE str) { str = rb_str_dup(str); rb_str_chomp_bang(argc, argv, str); return str; } /* * call-seq: * str.lstrip! => self or nil * * Removes leading whitespace from str, returning nil if no * change was made. See also String#rstrip! and * String#strip!. * * " hello ".lstrip #=> "hello " * "hello".lstrip! #=> nil */ static VALUE rb_str_lstrip_bang(VALUE str) { char *s, *t, *e; s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qnil; e = t = s + RSTRING_LEN(str); /* remove spaces at head */ while (s < t && ISSPACE(*s)) s++; if (s > RSTRING_PTR(str)) { rb_str_modify(str); STR_SET_LEN(str, t-s); memmove(RSTRING_PTR(str), s, RSTRING_LEN(str)); RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; return str; } return Qnil; } /* * call-seq: * str.lstrip => new_str * * Returns a copy of str with leading whitespace removed. See also * String#rstrip and String#strip. * * " hello ".lstrip #=> "hello " * "hello".lstrip #=> "hello" */ static VALUE rb_str_lstrip(VALUE str) { str = rb_str_dup(str); rb_str_lstrip_bang(str); return str; } /* * call-seq: * str.rstrip! => self or nil * * Removes trailing whitespace from str, returning nil if * no change was made. See also String#lstrip! and * String#strip!. * * " hello ".rstrip #=> " hello" * "hello".rstrip! #=> nil */ static VALUE rb_str_rstrip_bang(VALUE str) { char *s, *t, *e; s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qnil; e = t = s + RSTRING_LEN(str); /* remove trailing '\0's */ while (s < t && t[-1] == '\0') t--; /* remove trailing spaces */ while (s < t && ISSPACE(*(t-1))) t--; if (t < e) { rb_str_modify(str); STR_SET_LEN(str, t-s); RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; return str; } return Qnil; } /* * call-seq: * str.rstrip => new_str * * Returns a copy of str with trailing whitespace removed. See also * String#lstrip and String#strip. * * " hello ".rstrip #=> " hello" * "hello".rstrip #=> "hello" */ static VALUE rb_str_rstrip(VALUE str) { str = rb_str_dup(str); rb_str_rstrip_bang(str); return str; } /* * call-seq: * str.strip! => str or nil * * Removes leading and trailing whitespace from str. Returns * nil if str was not altered. */ static VALUE rb_str_strip_bang(VALUE str) { VALUE l = rb_str_lstrip_bang(str); VALUE r = rb_str_rstrip_bang(str); if (NIL_P(l) && NIL_P(r)) return Qnil; return str; } /* * call-seq: * str.strip => new_str * * Returns a copy of str with leading and trailing whitespace removed. * * " hello ".strip #=> "hello" * "\tgoodbye\r\n".strip #=> "goodbye" */ static VALUE rb_str_strip(VALUE str) { str = rb_str_dup(str); rb_str_strip_bang(str); return str; } static VALUE scan_once(VALUE str, VALUE pat, long *start) { VALUE result, match; struct re_registers *regs; long i; if (rb_reg_search(pat, str, *start, 0) >= 0) { match = rb_backref_get(); regs = RMATCH(match)->regs; if (BEG(0) == END(0)) { /* * Always consume at least one character of the input string */ if (RSTRING_LEN(str) > END(0)) *start = END(0)+mbclen2(RSTRING_PTR(str)[END(0)],pat); else *start = END(0)+1; } else { *start = END(0); } if (regs->num_regs == 1) { return rb_reg_nth_match(0, match); } result = rb_ary_new2(regs->num_regs); for (i=1; i < regs->num_regs; i++) { rb_ary_push(result, rb_reg_nth_match(i, match)); } return result; } return Qnil; } /* * call-seq: * str.scan(pattern) => array * str.scan(pattern) {|match, ...| block } => str * * Both forms iterate through str, matching the pattern (which may be a * Regexp or a String). For each match, a result is * generated and either added to the result array or passed to the block. If * the pattern contains no groups, each individual result consists of the * matched string, $&. If the pattern contains groups, each * individual result is itself an array containing one entry per group. * * a = "cruel world" * a.scan(/\w+/) #=> ["cruel", "world"] * a.scan(/.../) #=> ["cru", "el ", "wor"] * a.scan(/(...)/) #=> [["cru"], ["el "], ["wor"]] * a.scan(/(..)(..)/) #=> [["cr", "ue"], ["l ", "wo"]] * * And the block form: * * a.scan(/\w+/) {|w| print "<<#{w}>> " } * print "\n" * a.scan(/(.)(.)/) {|x,y| print y, x } * print "\n" * * produces: * * <> <> * rceu lowlr */ static VALUE rb_str_scan(VALUE str, VALUE pat) { VALUE result; long start = 0; VALUE match = Qnil; char *p = RSTRING_PTR(str); long len = RSTRING_LEN(str); pat = get_pat(pat, 1); if (!rb_block_given_p()) { VALUE ary = rb_ary_new(); while (!NIL_P(result = scan_once(str, pat, &start))) { match = rb_backref_get(); rb_ary_push(ary, result); } rb_backref_set(match); return ary; } while (!NIL_P(result = scan_once(str, pat, &start))) { match = rb_backref_get(); rb_match_busy(match); rb_yield(result); str_mod_check(str, p, len); rb_backref_set(match); /* restore $~ value */ } rb_backref_set(match); return str; } /* * call-seq: * str.hex => integer * * Treats leading characters from str as a string of hexadecimal digits * (with an optional sign and an optional 0x) and returns the * corresponding number. Zero is returned on error. * * "0x0a".hex #=> 10 * "-1234".hex #=> -4660 * "0".hex #=> 0 * "wombat".hex #=> 0 */ static VALUE rb_str_hex(VALUE str) { return rb_str_to_inum(str, 16, Qfalse); } /* * call-seq: * str.oct => integer * * Treats leading characters of str as a string of octal digits (with an * optional sign) and returns the corresponding number. Returns 0 if the * conversion fails. * * "123".oct #=> 83 * "-377".oct #=> -255 * "bad".oct #=> 0 * "0377bad".oct #=> 255 */ static VALUE rb_str_oct(VALUE str) { return rb_str_to_inum(str, -8, Qfalse); } /* * call-seq: * str.crypt(other_str) => new_str * * Applies a one-way cryptographic hash to str by invoking the standard * library function crypt. The argument is the salt string, which * should be two characters long, each character drawn from * [a-zA-Z0-9./]. */ static VALUE rb_str_crypt(VALUE str, VALUE salt) { extern char *crypt(const char *, const char *); VALUE result; const char *s; StringValue(salt); if (RSTRING_LEN(salt) < 2) rb_raise(rb_eArgError, "salt too short (need >=2 bytes)"); if (RSTRING_PTR(str)) s = RSTRING_PTR(str); else s = ""; result = rb_str_new2(crypt(s, RSTRING_PTR(salt))); OBJ_INFECT(result, str); OBJ_INFECT(result, salt); return result; } /* * call-seq: * str.intern => symbol * str.to_sym => symbol * * Returns the Symbol corresponding to str, creating the * symbol if it did not previously exist. See Symbol#id2name. * * "Koala".intern #=> :Koala * s = 'cat'.to_sym #=> :cat * s == :cat #=> true * s = '@cat'.to_sym #=> :@cat * s == :@cat #=> true * * This can also be used to create symbols that cannot be represented using the * :xxx notation. * * 'cat and dog'.to_sym #=> :"cat and dog" */ VALUE rb_str_intern(VALUE s) { volatile VALUE str = s; ID id; if (OBJ_TAINTED(str) && rb_safe_level() >= 1 && !rb_sym_interned_p(str)) { rb_raise(rb_eSecurityError, "Insecure: can't intern tainted string"); } id = rb_intern2(RSTRING_PTR(str), RSTRING_LEN(str)); return ID2SYM(id); } /* * call-seq: * str.ord => integer * * Return the Integer ordinal of a one-character string. * * "a".ord #=> 97 */ VALUE rb_str_ord(VALUE s) { int c; if (RSTRING_LEN(s) != 1) { rb_raise(rb_eTypeError, "expacted a characer, but string of size %ld given", RSTRING_LEN(s)); } c = RSTRING_PTR(s)[0] & 0xff; return INT2NUM(c); } /* * call-seq: * str.sum(n=16) => integer * * Returns a basic n-bit checksum of the characters in str, * where n is the optional Fixnum parameter, defaulting * to 16. The result is simply the sum of the binary value of each character in * str modulo 2n - 1. This is not a particularly good * checksum. */ static VALUE rb_str_sum(int argc, VALUE *argv, VALUE str) { VALUE vbits; int bits; char *ptr, *p, *pend; long len; if (rb_scan_args(argc, argv, "01", &vbits) == 0) { bits = 16; } else bits = NUM2INT(vbits); ptr = p = RSTRING_PTR(str); len = RSTRING_LEN(str); pend = p + len; if (bits >= sizeof(long)*CHAR_BIT) { VALUE sum = INT2FIX(0); while (p < pend) { str_mod_check(str, ptr, len); sum = rb_funcall(sum, '+', 1, INT2FIX((unsigned char)*p)); p++; } if (bits != 0) { VALUE mod; mod = rb_funcall(INT2FIX(1), rb_intern("<<"), 1, INT2FIX(bits)); mod = rb_funcall(mod, '-', 1, INT2FIX(1)); sum = rb_funcall(sum, '&', 1, mod); } return sum; } else { unsigned long sum = 0; while (p < pend) { str_mod_check(str, ptr, len); sum += (unsigned char)*p; p++; } if (bits != 0) { sum &= (((unsigned long)1)<= width) return rb_str_dup(str); res = rb_str_new5(str, 0, width); p = RSTRING_PTR(res); if (jflag != 'l') { n = width - RSTRING_LEN(str); pend = p + ((jflag == 'r') ? n : n/2); if (flen <= 1) { while (p < pend) { *p++ = *f; } } else { char *q = f; while (p + flen <= pend) { memcpy(p,f,flen); p += flen; } while (p < pend) { *p++ = *q++; } } } memcpy(p, RSTRING_PTR(str), RSTRING_LEN(str)+1); if (jflag != 'r') { p += RSTRING_LEN(str); pend = RSTRING_PTR(res) + width; if (flen <= 1) { while (p < pend) { *p++ = *f; } } else { while (p + flen <= pend) { memcpy(p,f,flen); p += flen; } while (p < pend) { *p++ = *f++; } } } OBJ_INFECT(res, str); if (flen > 0) OBJ_INFECT(res, pad); return res; } /* * call-seq: * str.ljust(integer, padstr=' ') => new_str * * If integer is greater than the length of str, returns a new * String of length integer with str left justified * and padded with padstr; otherwise, returns str. * * "hello".ljust(4) #=> "hello" * "hello".ljust(20) #=> "hello " * "hello".ljust(20, '1234') #=> "hello123412341234123" */ static VALUE rb_str_ljust(int argc, VALUE *argv, VALUE str) { return rb_str_justify(argc, argv, str, 'l'); } /* * call-seq: * str.rjust(integer, padstr=' ') => new_str * * If integer is greater than the length of str, returns a new * String of length integer with str right justified * and padded with padstr; otherwise, returns str. * * "hello".rjust(4) #=> "hello" * "hello".rjust(20) #=> " hello" * "hello".rjust(20, '1234') #=> "123412341234123hello" */ static VALUE rb_str_rjust(int argc, VALUE *argv, VALUE str) { return rb_str_justify(argc, argv, str, 'r'); } /* * call-seq: * str.center(integer, padstr) => new_str * * If integer is greater than the length of str, returns a new * String of length integer with str centered and * padded with padstr; otherwise, returns str. * * "hello".center(4) #=> "hello" * "hello".center(20) #=> " hello " * "hello".center(20, '123') #=> "1231231hello12312312" */ static VALUE rb_str_center(int argc, VALUE *argv, VALUE str) { return rb_str_justify(argc, argv, str, 'c'); } /* * call-seq: * str.partition {| obj | block } => [true_array, false_array] * str.partition(sep) => [head, sep, tail] * * If a block is given, returns two arrays of true elements and false * elements classified by the block evaluation. Otherwise, searches * sep in the string and returns the part before it, the * sep, and the part after it. If sep is not found, * returns str and two empty strings. * * "hello".partition("l") #=> ["he", "l", "lo"] * "hello".partition("x") #=> ["hello", "", ""] */ static VALUE rb_str_partition(VALUE str, VALUE sep) { long pos; int regex = Qfalse; if (TYPE(sep) == T_REGEXP) { pos = rb_reg_search(sep, str, 0, 0); regex = Qtrue; } else { VALUE tmp; tmp = rb_check_string_type(sep); if (NIL_P(tmp)) { rb_raise(rb_eTypeError, "type mismatch: %s given", rb_obj_classname(sep)); } pos = rb_str_index(str, sep, 0); } if (pos < 0) { failed: return rb_ary_new3(3, str, rb_str_new(0,0),rb_str_new(0,0)); } if (regex) { sep = rb_str_subpat(str, sep, 0); if (pos == 0 && RSTRING_LEN(sep) == 0) goto failed; } return rb_ary_new3(3, rb_str_substr(str, 0, pos), sep, rb_str_substr(str, pos+RSTRING_LEN(sep), RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); } /* * call-seq: * str.rpartition(sep) => [head, sep, tail] * * Searches sep in the string from the end of the string, and * returns the part before it, the sep, and the part after it. * If sep is not found, returns two empty strings and * str. * * "hello".rpartition("l") #=> ["hel", "l", "o"] * "hello".rpartition("x") #=> ["", "", "hello"] */ static VALUE rb_str_rpartition(VALUE str, VALUE sep) { long pos = RSTRING_LEN(str); int regex = Qfalse; if (TYPE(sep) == T_REGEXP) { pos = rb_reg_search(sep, str, pos, 1); regex = Qtrue; } else { VALUE tmp; tmp = rb_check_string_type(sep); if (NIL_P(tmp)) { rb_raise(rb_eTypeError, "type mismatch: %s given", rb_obj_classname(sep)); } pos = rb_str_rindex(str, sep, pos); } if (pos < 0) { return rb_ary_new3(3, rb_str_new(0,0),rb_str_new(0,0), str); } if (regex) { sep = rb_reg_nth_match(0, rb_backref_get()); } return rb_ary_new3(3, rb_str_substr(str, 0, pos), sep, rb_str_substr(str, pos+RSTRING_LEN(sep), RSTRING_LEN(str)-pos-RSTRING_LEN(sep))); } /* * call-seq: * str.start_with?([prefix]+) => true or false * * Returns true if str starts with the prefix given. */ static VALUE rb_str_start_with(int argc, VALUE *argv, VALUE str) { int i; for (i=0; i true or false * * Returns true if str ends with the suffix given. */ static VALUE rb_str_end_with(int argc, VALUE *argv, VALUE str) { int i; for (i=0; iSymbol objects represent names and some strings * inside the Ruby * interpreter. They are generated using the :name and * :"string" literals * syntax, and by the various to_sym methods. The same * Symbol object will be created for a given name or string * for the duration of a program's execution, regardless of the context * or meaning of that name. Thus if Fred is a constant in * one context, a method in another, and a class in a third, the * Symbol :Fred will be the same object in * all three contexts. * * module One * class Fred * end * $f1 = :Fred * end * module Two * Fred = 1 * $f2 = :Fred * end * def Fred() * end * $f3 = :Fred * $f1.id #=> 2514190 * $f2.id #=> 2514190 * $f3.id #=> 2514190 * */ /* * call-seq: * Symbol.intern(str) => new_sym * * Returns a new symbol corresponding to str. */ static VALUE rb_sym_s_intern(VALUE s) { if (rb_class_real(s) == rb_cSymbol) { return s; } StringValue(s); return rb_intern2(RSTRING_PTR(s), RSTRING_LEN(s)); } /* * call-seq: * sym == obj => true or false * * Equality---If sym and obj are exactly the same * symbol, returns true. Otherwise, compares them * as strings. */ static VALUE sym_equal(VALUE sym1, VALUE sym2) { if (sym1 == sym2) return Qtrue; if (SYMBOL_P(sym2)) return Qfalse; return rb_str_equal(sym1, sym2); } /* * call-seq: * sym.eql?(other) => true or false * * Two symbols are equal if they are exactly same symbols. */ static VALUE sym_eql(VALUE sym1, VALUE sym2) { if (sym1 == sym2) return Qtrue; if (SYMBOL_P(sym2)) return Qfalse; return rb_str_eql(sym1, sym2); } /* * call-seq: * sym.hash => fixnum * * Return a hash based on the symbol's length and content. */ static VALUE sym_hash(VALUE sym) { int h; VALUE hval; if (STR_SHARED_P(sym)) { /* if a symbol has shared value, that's a hash value. */ return RSTRING(sym)->as.heap.aux.shared; } h = rb_str_hash(sym); hval = INT2FIX(h); if (!STR_EMBED_P(sym)) { FL_SET(sym, STR_ASSOC); RSTRING(sym)->as.heap.aux.shared = hval; } return hval; } /* * call-seq: * sym.to_i => fixnum * * Returns an integer that is unique for each symbol within a * particular execution of a program. * * :fred.to_i #=> 9809 * "fred".to_sym.to_i #=> 9809 */ static VALUE sym_to_i(VALUE sym) { ID id = SYM2ID(sym); return LONG2FIX(id); } /* * call-seq: * sym.inspect => string * * Returns the representation of sym as a symbol literal. * * :fred.inspect #=> ":fred" */ static VALUE sym_inspect(VALUE sym) { VALUE str; str = rb_str_new(0, RSTRING_LEN(sym)+1); RSTRING_PTR(str)[0] = ':'; memcpy(RSTRING_PTR(str)+1, RSTRING_PTR(sym), RSTRING_LEN(sym)); if (RSTRING_LEN(sym) != strlen(RSTRING_PTR(sym)) || !rb_symname_p(RSTRING_PTR(sym))) { str = rb_str_dump(str); strncpy(RSTRING_PTR(str), ":\"", 2); } return str; } /* * call-seq: * sym.id2name => string * sym.to_s => string * * Returns the name or string corresponding to sym. * * :fred.id2name #=> "fred" */ static VALUE sym_to_s(VALUE sym) { return rb_str_new(RSTRING_PTR(sym), RSTRING_LEN(sym)); } /* * call-seq: * sym.to_sym => sym * sym.intern => sym * * In general, to_sym returns the Symbol corresponding * to an object. As sym is already a symbol, self is returned * in this case. */ static VALUE sym_to_sym(VALUE sym) { return sym; } static VALUE sym_call(VALUE args, VALUE sym) { VALUE obj; if (RARRAY_LEN(args) < 1) { rb_raise(rb_eArgError, "no receiver given"); } obj = RARRAY_PTR(args)[0]; return rb_funcall3(obj, (ID)sym, RARRAY_LEN(args) - 1, RARRAY_PTR(args) + 1); } /* * call-seq: * sym.to_proc * * Returns a _Proc_ object which respond to the given method by _sym_. * * (1..3).collect(&:to_s) #=> ["1", "2", "3"] */ static VALUE sym_to_proc(VALUE sym) { return rb_proc_new(sym_call, (VALUE)SYM2ID(sym)); } static ID str_to_id(VALUE str) { VALUE sym = rb_str_intern(str); return SYM2ID(sym); } ID rb_to_id(VALUE name) { VALUE tmp; ID id; switch (TYPE(name)) { case T_STRING: return str_to_id(name); case T_FIXNUM: rb_warn("do not use Fixnums as Symbols"); id = FIX2LONG(name); if (!rb_id2name(id)) { rb_raise(rb_eArgError, "%ld is not a symbol", id); } break; case T_SYMBOL: return SYM2ID(name); break; default: tmp = rb_check_string_type(name); if (!NIL_P(tmp)) { return str_to_id(tmp); } rb_raise(rb_eTypeError, "%s is not a symbol", RSTRING_PTR(rb_inspect(name))); } return id; } /* * A String object holds and manipulates an arbitrary sequence of * bytes, typically representing characters. String objects may be created * using String::new or as literals. * * Because of aliasing issues, users of strings should be aware of the methods * that modify the contents of a String object. Typically, * methods with names ending in ``!'' modify their receiver, while those * without a ``!'' return a new String. However, there are * exceptions, such as String#[]=. * */ void Init_String(void) { rb_cString = rb_define_class("String", rb_cObject); rb_include_module(rb_cString, rb_mComparable); rb_define_alloc_func(rb_cString, str_alloc); rb_define_method(rb_cString, "initialize", rb_str_init, -1); rb_define_method(rb_cString, "initialize_copy", rb_str_replace, 1); rb_define_method(rb_cString, "<=>", rb_str_cmp_m, 1); rb_define_method(rb_cString, "==", rb_str_equal, 1); rb_define_method(rb_cString, "eql?", rb_str_eql, 1); rb_define_method(rb_cString, "hash", rb_str_hash_m, 0); rb_define_method(rb_cString, "casecmp", rb_str_casecmp, 1); rb_define_method(rb_cString, "+", rb_str_plus, 1); rb_define_method(rb_cString, "*", rb_str_times, 1); rb_define_method(rb_cString, "%", rb_str_format_m, 1); rb_define_method(rb_cString, "[]", rb_str_aref_m, -1); rb_define_method(rb_cString, "[]=", rb_str_aset_m, -1); rb_define_method(rb_cString, "insert", rb_str_insert, 2); rb_define_method(rb_cString, "length", rb_str_length, 0); rb_define_method(rb_cString, "size", rb_str_length, 0); rb_define_method(rb_cString, "empty?", rb_str_empty, 0); rb_define_method(rb_cString, "=~", rb_str_match, 1); rb_define_method(rb_cString, "match", rb_str_match_m, -1); rb_define_method(rb_cString, "succ", rb_str_succ, 0); rb_define_method(rb_cString, "succ!", rb_str_succ_bang, 0); rb_define_method(rb_cString, "next", rb_str_succ, 0); rb_define_method(rb_cString, "next!", rb_str_succ_bang, 0); rb_define_method(rb_cString, "upto", rb_str_upto_m, 1); rb_define_method(rb_cString, "index", rb_str_index_m, -1); rb_define_method(rb_cString, "rindex", rb_str_rindex_m, -1); rb_define_method(rb_cString, "replace", rb_str_replace, 1); rb_define_method(rb_cString, "clear", rb_str_clear, 0); rb_define_method(rb_cString, "chr", rb_str_chr, 0); rb_define_method(rb_cString, "to_i", rb_str_to_i, -1); rb_define_method(rb_cString, "to_f", rb_str_to_f, 0); rb_define_method(rb_cString, "to_s", rb_str_to_s, 0); rb_define_method(rb_cString, "to_str", rb_str_to_s, 0); rb_define_method(rb_cString, "inspect", rb_str_inspect, 0); rb_define_method(rb_cString, "dump", rb_str_dump, 0); rb_define_method(rb_cString, "upcase", rb_str_upcase, 0); rb_define_method(rb_cString, "downcase", rb_str_downcase, 0); rb_define_method(rb_cString, "capitalize", rb_str_capitalize, 0); rb_define_method(rb_cString, "swapcase", rb_str_swapcase, 0); rb_define_method(rb_cString, "upcase!", rb_str_upcase_bang, 0); rb_define_method(rb_cString, "downcase!", rb_str_downcase_bang, 0); rb_define_method(rb_cString, "capitalize!", rb_str_capitalize_bang, 0); rb_define_method(rb_cString, "swapcase!", rb_str_swapcase_bang, 0); rb_define_method(rb_cString, "hex", rb_str_hex, 0); rb_define_method(rb_cString, "oct", rb_str_oct, 0); rb_define_method(rb_cString, "split", rb_str_split_m, -1); rb_define_method(rb_cString, "lines", rb_str_lines, 0); rb_define_method(rb_cString, "bytes", rb_str_bytes, 0); rb_define_method(rb_cString, "reverse", rb_str_reverse, 0); rb_define_method(rb_cString, "reverse!", rb_str_reverse_bang, 0); rb_define_method(rb_cString, "concat", rb_str_concat, 1); rb_define_method(rb_cString, "<<", rb_str_concat, 1); rb_define_method(rb_cString, "crypt", rb_str_crypt, 1); rb_define_method(rb_cString, "intern", rb_str_intern, 0); rb_define_method(rb_cString, "to_sym", rb_str_intern, 0); rb_define_method(rb_cString, "ord", rb_str_ord, 0); rb_define_method(rb_cString, "include?", rb_str_include, 1); rb_define_method(rb_cString, "start_with?", rb_str_start_with, -1); rb_define_method(rb_cString, "end_with?", rb_str_end_with, -1); rb_define_method(rb_cString, "scan", rb_str_scan, 1); rb_define_method(rb_cString, "ljust", rb_str_ljust, -1); rb_define_method(rb_cString, "rjust", rb_str_rjust, -1); rb_define_method(rb_cString, "center", rb_str_center, -1); rb_define_method(rb_cString, "sub", rb_str_sub, -1); rb_define_method(rb_cString, "gsub", rb_str_gsub, -1); rb_define_method(rb_cString, "chop", rb_str_chop, 0); rb_define_method(rb_cString, "chomp", rb_str_chomp, -1); rb_define_method(rb_cString, "strip", rb_str_strip, 0); rb_define_method(rb_cString, "lstrip", rb_str_lstrip, 0); rb_define_method(rb_cString, "rstrip", rb_str_rstrip, 0); rb_define_method(rb_cString, "sub!", rb_str_sub_bang, -1); rb_define_method(rb_cString, "gsub!", rb_str_gsub_bang, -1); rb_define_method(rb_cString, "chop!", rb_str_chop_bang, 0); rb_define_method(rb_cString, "chomp!", rb_str_chomp_bang, -1); rb_define_method(rb_cString, "strip!", rb_str_strip_bang, 0); rb_define_method(rb_cString, "lstrip!", rb_str_lstrip_bang, 0); rb_define_method(rb_cString, "rstrip!", rb_str_rstrip_bang, 0); rb_define_method(rb_cString, "tr", rb_str_tr, 2); rb_define_method(rb_cString, "tr_s", rb_str_tr_s, 2); rb_define_method(rb_cString, "delete", rb_str_delete, -1); rb_define_method(rb_cString, "squeeze", rb_str_squeeze, -1); rb_define_method(rb_cString, "count", rb_str_count, -1); rb_define_method(rb_cString, "tr!", rb_str_tr_bang, 2); rb_define_method(rb_cString, "tr_s!", rb_str_tr_s_bang, 2); rb_define_method(rb_cString, "delete!", rb_str_delete_bang, -1); rb_define_method(rb_cString, "squeeze!", rb_str_squeeze_bang, -1); rb_define_method(rb_cString, "each_line", rb_str_each_line, -1); rb_define_method(rb_cString, "each_byte", rb_str_each_byte, 0); rb_define_method(rb_cString, "sum", rb_str_sum, -1); rb_define_method(rb_cString, "slice", rb_str_aref_m, -1); rb_define_method(rb_cString, "slice!", rb_str_slice_bang, -1); rb_define_method(rb_cString, "partition", rb_str_partition, 1); rb_define_method(rb_cString, "rpartition", rb_str_rpartition, 1); id_to_s = rb_intern("to_s"); rb_fs = Qnil; rb_define_variable("$;", &rb_fs); rb_define_variable("$-F", &rb_fs); rb_cSymbol = rb_define_class("Symbol", rb_cString); rb_undef_alloc_func(rb_cSymbol); rb_undef_method(CLASS_OF(rb_cSymbol), "new"); rb_define_singleton_method(rb_cSymbol, "all_symbols", rb_sym_all_symbols, 0); /* in parse.y */ rb_define_singleton_method(rb_cSymbol, "intern", rb_sym_s_intern, 1); rb_define_method(rb_cSymbol, "==", sym_equal, 1); rb_define_method(rb_cSymbol, "eql?", sym_eql, 1); rb_define_method(rb_cSymbol, "hash", sym_hash, 0); rb_define_method(rb_cSymbol, "to_i", sym_to_i, 0); rb_define_method(rb_cSymbol, "inspect", sym_inspect, 0); rb_define_method(rb_cSymbol, "to_s", sym_to_s, 0); rb_define_method(rb_cSymbol, "id2name", sym_to_s, 0); rb_define_method(rb_cSymbol, "intern", sym_to_sym, 0); rb_define_method(rb_cSymbol, "to_sym", sym_to_sym, 0); rb_define_method(rb_cSymbol, "to_proc", sym_to_proc, 0); }