/*

** string.c - String class

**

** See Copyright Notice in mruby.h

*/

#include "mruby.h"

#include <stdarg.h>

#include <string.h>

#include "mruby/string.h"

#include <ctype.h>

#include <limits.h>

#include "mruby/range.h"

#include "mruby/array.h"

#include "mruby/class.h"

#include <stdio.h>

#ifdef ENABLE_REGEXP

#include "re.h"

#include "regex.h"

#endif //ENABLE_REGEXP

const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";

#ifdef ENABLE_REGEXP

static mrb_value get_pat(mrb_state *mrb, mrb_value pat, mrb_int quote);

#endif //ENABLE_REGEXP

static mrb_value str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2);

static mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, int beg, int len);

#define RESIZE_CAPA(s,capacity) do {\

s->ptr = (char *)mrb_realloc(mrb, s->ptr, (capacity)+1);\

s->aux.capa = capacity;\

} while (0)

void

mrb_str_decref(mrb_state *mrb, struct mrb_shared_string *shared)

{

shared->refcnt--;

if (shared->refcnt == 0) {

mrb_free(mrb, shared->ptr);

mrb_free(mrb, shared);

}

}

static void

str_modify(mrb_state *mrb, struct RString *s)

{

if (s->flags & MRB_STR_SHARED) {

struct mrb_shared_string *shared = s->aux.shared;

if (shared->refcnt == 1 && s->ptr == shared->ptr) {

s->ptr = shared->ptr;

s->aux.capa = shared->len;

mrb_free(mrb, shared);

}

else {

char *ptr, *p;

long len;

p = s->ptr;

len = s->len;

ptr = (char *)mrb_malloc(mrb, len+1);

if (p) {

memcpy(ptr, p, len);

}

ptr[len] = 0;

s->ptr = ptr;

s->aux.capa = len;

mrb_str_decref(mrb, shared);

}

s->flags &= ~MRB_STR_SHARED;

}

}

mrb_value

mrb_str_resize(mrb_state *mrb, mrb_value str, int len)

{

int slen;

struct RString *s = mrb_str_ptr(str);

str_modify(mrb, s);

slen = s->len;

if (len != slen) {

if (slen < len || slen -len > 1024) {

s->ptr = (char *)mrb_realloc(mrb, s->ptr, len+1);

}

s->aux.capa = len;

s->len = len;

s->ptr[len] = '\0'; /* sentinel */

}

return str;

}

static inline void

str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len)

{

struct RString *s = mrb_str_ptr(str);

if (s->ptr != p || s->len != len) {

mrb_raise(mrb, E_RUNTIME_ERROR, "string modified");

}

}

#define mrb_obj_alloc_string(mrb) ((struct RString*)mrb_obj_alloc((mrb), MRB_TT_STRING, (mrb)->string_class))

static struct RString*

str_alloc(mrb_state *mrb, struct RClass *c)

{

struct RString* s;

s = mrb_obj_alloc_string(mrb);

s->c = c;

s->ptr = 0;

s->len = 0;

s->aux.capa = 0;

return s;

}

/* char offset to byte offset */

int

mrb_str_offset(mrb_state *mrb, mrb_value str, int pos)

{

return pos;

}

static struct RString*

str_new(mrb_state *mrb, const char *p, int len)

{

struct RString *s = str_alloc(mrb, mrb->string_class);

s->len = len;

s->aux.capa = len;

s->ptr = (char *)mrb_malloc(mrb, len+1);

if (p) {

memcpy(s->ptr, p, len);

}

s->ptr[len] = '\0';

return s;

}

void

str_with_class(mrb_state *mrb, struct RString *s, mrb_value obj)

{

s->c = mrb_str_ptr(obj)->c;

}

static mrb_value

mrb_str_new_empty(mrb_state *mrb, mrb_value str)

{

struct RString *s = str_new(mrb, 0, 0);

str_with_class(mrb, s, str);

return mrb_obj_value(s);

}

mrb_value

mrb_str_buf_new(mrb_state *mrb, int capa)

{

struct RString *s;

s = mrb_obj_alloc_string(mrb);

if (capa < STR_BUF_MIN_SIZE) {

capa = STR_BUF_MIN_SIZE;

}

s->len = 0;

s->aux.capa = capa;

s->ptr = (char *)mrb_malloc(mrb, capa+1);

s->ptr[0] = '\0';

return mrb_obj_value(s);

}

static void

str_buf_cat(mrb_state *mrb, struct RString *s, const char *ptr, int len)

{

long capa, total, off = -1;

str_modify(mrb, s);

if (ptr >= s->ptr && ptr <= s->ptr + s->len) {

off = ptr - s->ptr;

}

if (len == 0) return;

capa = s->aux.capa;

if (s->len >= INT_MAX - len) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "string sizes too big");

}

total = s->len+len;

if (capa <= total) {

while (total > capa) {

if (capa + 1 >= INT_MAX / 2) {

capa = (total + 4095) / 4096;

break;

}

capa = (capa + 1) * 2;

}

RESIZE_CAPA(s, capa);

}

if (off != -1) {

ptr = s->ptr + off;

}

memcpy(s->ptr + s->len, ptr, len);

s->len = total;

s->ptr[total] = '\0'; /* sentinel */

}

mrb_value

mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, int len)

{

if (len == 0) return str;

str_buf_cat(mrb, mrb_str_ptr(str), ptr, len);

return str;

}

mrb_value

mrb_str_new(mrb_state *mrb, const char *p, int len)

{

struct RString *s;

s = str_new(mrb, p, len);

return mrb_obj_value(s);

}

mrb_value

mrb_str_new2(mrb_state *mrb, const char *ptr)

{

struct RString *s;

if (!ptr) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "NULL pointer given");

}

s = str_new(mrb, ptr, strlen(ptr));

return mrb_obj_value(s);

}

/*

* call-seq: (Caution! NULL string)

* String.new(str="") => new_str

*

* Returns a new string object containing a copy of <i>str</i>.

*/

mrb_value

mrb_str_new_cstr(mrb_state *mrb, const char *p)

{

struct RString *s;

int len = strlen(p);

s = mrb_obj_alloc_string(mrb);

s->ptr = (char *)mrb_malloc(mrb, len+1);

memcpy(s->ptr, p, len);

s->ptr[len] = 0;

s->len = len;

s->aux.capa = len;

return mrb_obj_value(s);

}

static void

str_make_shared(mrb_state *mrb, struct RString *s)

{

if (!(s->flags & MRB_STR_SHARED)) {

struct mrb_shared_string *shared = (struct mrb_shared_string *)mrb_malloc(mrb, sizeof(struct mrb_shared_string));

shared->refcnt = 1;

if (s->aux.capa > s->len) {

s->ptr = shared->ptr = (char *)mrb_realloc(mrb, s->ptr, s->len+1);

}

else {

shared->ptr = s->ptr;

}

shared->len = s->len;

s->aux.shared = shared;

s->flags |= MRB_STR_SHARED;

}

}

/*

* call-seq: (Caution! string literal)

* String.new(str="") => new_str

*

* Returns a new string object containing a copy of <i>str</i>.

*/

mrb_value

mrb_str_literal(mrb_state *mrb, mrb_value str)

{

struct RString *s, *orig;

struct mrb_shared_string *shared;

s = str_alloc(mrb, mrb->string_class);

orig = mrb_str_ptr(str);

if (!(orig->flags & MRB_STR_SHARED)) {

str_make_shared(mrb, mrb_str_ptr(str));

}

shared = orig->aux.shared;

shared->refcnt++;

s->ptr = shared->ptr;

s->len = shared->len;

s->aux.shared = shared;

s->flags |= MRB_STR_SHARED;

return mrb_obj_value(s);

}

/*

* call-seq:

* char* str = String("abcd"), len=strlen("abcd")

*

* Returns a new string object containing a copy of <i>str</i>.

*/

const char*

mrb_str_body(mrb_value str, int *len_p)

{

struct RString *s = mrb_str_ptr(str);

*len_p = s->len;

return s->ptr;

}

/*

* call-seq: (Caution! String("abcd") change)

* String("abcdefg") = String("abcd") + String("efg")

*

* Returns a new string object containing a copy of <i>str</i>.

*/

void

mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)

{

struct RString *s1 = mrb_str_ptr(self), *s2;

int len;

str_modify(mrb, s1);

if (!mrb_string_p(other)) {

other = mrb_str_to_str(mrb, other);

}

s2 = mrb_str_ptr(other);

len = s1->len + s2->len;

if (s1->aux.capa < len) {

s1->aux.capa = len;

s1->ptr = (char *)mrb_realloc(mrb, s1->ptr, len+1);

}

memcpy(s1->ptr+s1->len, s2->ptr, s2->len);

s1->len = len;

s1->ptr[len] = 0;

}

/*

* call-seq: (Caution! String("abcd") remain)

* String("abcdefg") = String("abcd") + String("efg")

*

* Returns a new string object containing a copy of <i>str</i>.

*/

mrb_value

mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b)

{

struct RString *s = mrb_str_ptr(a);

struct RString *s2 = mrb_str_ptr(b);

struct RString *t;

t = str_new(mrb, 0, s->len + s2->len);

memcpy(t->ptr, s->ptr, s->len);

memcpy(t->ptr + s->len, s2->ptr, s2->len);

return mrb_obj_value(t);

}

/* 15.2.10.5.2 */

/*

* call-seq: (Caution! String("abcd") remain) for stack_argument

* String("abcdefg") = String("abcd") + String("efg")

*

* Returns a new string object containing a copy of <i>str</i>.

*/

static mrb_value

mrb_str_plus_m(mrb_state *mrb, mrb_value self)

{

mrb_value str;

mrb_get_args(mrb, "S", &str);

return mrb_str_plus(mrb, self, str);

}

/*

* call-seq:

* len = strlen(String("abcd"))

*

* Returns a new string object containing a copy of <i>str</i>.

*/

static mrb_value

mrb_str_bytesize(mrb_state *mrb, mrb_value self)

{

struct RString *s = mrb_str_ptr(self);

return mrb_fixnum_value(s->len);

}

/* 15.2.10.5.26 */

/* 15.2.10.5.33 */

/*

* call-seq:

* len = strlen(String("abcd"))

*

* Returns a new string object containing a copy of <i>str</i>.

*/

mrb_value

mrb_str_size(mrb_state *mrb, mrb_value self)

{

struct RString *s = mrb_str_ptr(self);

return mrb_fixnum_value(s->len);

}

/* 15.2.10.5.1 */

/*

* call-seq:

* str * integer => new_str

*

* Copy---Returns a new <code>String</code> containing <i>integer</i> copies of

* the receiver.

*

* "Ho! " * 3 #=> "Ho! Ho! Ho! "

*/

static mrb_value

mrb_str_times(mrb_state *mrb, mrb_value self)

{

mrb_int n,len,times;

struct RString *str2;

char *p;

mrb_get_args(mrb, "i", &times);

if (times < 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "negative argument");

}

if (times && INT_MAX/times < RSTRING_LEN(self)) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "argument too big");

}

len = RSTRING_LEN(self)*times;

str2 = str_new(mrb, 0, len);

str_with_class(mrb, str2, self);

p = str2->ptr;

if (len > 0) {

n = RSTRING_LEN(self);

memcpy(p, RSTRING_PTR(self), n);

while (n <= len/2) {

memcpy(p + n, p, n);

n *= 2;

}

memcpy(p + n, p, len-n);

}

p[str2->len] = '\0';

return mrb_obj_value(str2);

}

/* -------------------------------------------------------------- */

#define lesser(a,b) (((a)>(b))?(b):(a))

/* ---------------------------*/

/*

* call-seq:

* mrb_value str1 <=> mrb_value str2 => int

* > 1

* = 0

* < -1

*/

int

mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2)

{

mrb_int len;

mrb_int retval;

struct RString *s1 = mrb_str_ptr(str1);

struct RString *s2 = mrb_str_ptr(str2);

len = lesser(s1->len, s2->len);

retval = memcmp(s1->ptr, s2->ptr, len);

if (retval == 0) {

if (s1->len == s2->len) return 0;

if (s1->len > s2->len) return 1;

return -1;

}

if (retval > 0) return 1;

return -1;

}

/* 15.2.10.5.3 */

/*

* call-seq:

* str <=> other_str => -1, 0, +1

*

* Comparison---Returns -1 if <i>other_str</i> is less than, 0 if

* <i>other_str</i> is equal to, and +1 if <i>other_str</i> is greater than

* <i>str</i>. 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 <code>$=</code> is

* <code>false</code>, the comparison is based on comparing the binary values

* of each character in the string. In older versions of Ruby, setting

* <code>$=</code> allowed case-insensitive comparisons; this is now deprecated

* in favor of using <code>String#casecmp</code>.

*

* <code><=></code> is the basis for the methods <code><</code>,

* <code><=</code>, <code>></code>, <code>>=</code>, and <code>between?</code>,

* included from module <code>Comparable</code>. The method

* <code>String#==</code> does not use <code>Comparable#==</code>.

*

* "abcdef" <=> "abcde" #=> 1

* "abcdef" <=> "abcdef" #=> 0

* "abcdef" <=> "abcdefg" #=> -1

* "abcdef" <=> "ABCDEF" #=> 1

*/

static mrb_value

mrb_str_cmp_m(mrb_state *mrb, mrb_value str1)

{

mrb_value str2;

mrb_int result;

mrb_get_args(mrb, "o", &str2);

if (!mrb_string_p(str2)) {

if (!mrb_respond_to(mrb, str2, mrb_intern(mrb, "to_s"))) {

return mrb_nil_value();

}

else if (!mrb_respond_to(mrb, str2, mrb_intern(mrb, "<=>"))) {

return mrb_nil_value();

}

else {

mrb_value tmp = mrb_funcall(mrb, str2, "<=>", 1, str1);

if (mrb_nil_p(tmp)) return mrb_nil_value();

if (!mrb_fixnum(tmp)) {

return mrb_funcall(mrb, mrb_fixnum_value(0), "-", 1, tmp);

}

result = -mrb_fixnum(tmp);

}

}

else {

result = mrb_str_cmp(mrb, str1, str2);

}

return mrb_fixnum_value(result);

}

static int

str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2)

{

const long len = RSTRING_LEN(str1);

if (len != RSTRING_LEN(str2)) return FALSE;

if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len) == 0)

return TRUE;

return FALSE;

}

int

mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2)

{

if (mrb_obj_equal(mrb, str1, str2)) return TRUE;

if (!mrb_string_p(str2)) {

if (mrb_nil_p(str2)) return FALSE;

if (!mrb_respond_to(mrb, str2, mrb_intern(mrb, "to_str"))) {

return FALSE;

}

str2 = mrb_funcall(mrb, str2, "to_str", 0);

return mrb_equal(mrb, str2, str1);

}

return str_eql(mrb, str1, str2);

}

/* 15.2.10.5.4 */

/*

* call-seq:

* str == obj => true or false

*

* Equality---

* If <i>obj</i> is not a <code>String</code>, returns <code>false</code>.

* Otherwise, returns <code>false</code> or <code>true</code>

*

* caution:if <i>str</i> <code><=></code> <i>obj</i> returns zero.

*/

static mrb_value

mrb_str_equal_m(mrb_state *mrb, mrb_value str1)

{

mrb_value str2;

mrb_get_args(mrb, "o", &str2);

if (mrb_str_equal(mrb, str1, str2))

return mrb_true_value();

return mrb_false_value();

}

/* ---------------------------------- */

mrb_value

mrb_str_to_str(mrb_state *mrb, mrb_value str)

{

mrb_value s;

if (!mrb_string_p(str)) {

s = mrb_check_convert_type(mrb, str, MRB_TT_STRING, "String", "to_str");

if (mrb_nil_p(s)) {

s = mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s");

}

return s;

}

return str;

}

mrb_value

mrb_string_value(mrb_state *mrb, mrb_value *ptr)

{

mrb_value s = *ptr;

if (!mrb_string_p(s)) {

s = mrb_str_to_str(mrb, s);

*ptr = s;

}

return s;

}

char *

mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr)

{

mrb_value str = mrb_string_value(mrb, &ptr);

return RSTRING_PTR(str);

}

/* 15.2.10.5.5 */

/*

* call-seq:

* str =~ obj -> fixnum or nil

*

* Match---If <i>obj</i> is a <code>Regexp</code>, use it as a pattern to match

* against <i>str</i>,and returns the position the match starts, or

* <code>nil</code> if there is no match. Otherwise, invokes

* <i>obj.=~</i>, passing <i>str</i> as an argument. The default

* <code>=~</code> in <code>Object</code> returns <code>nil</code>.

*

* "cat o' 9 tails" =~ /\d/ #=> 7

* "cat o' 9 tails" =~ 9 #=> nil

*/

static mrb_value

mrb_str_match(mrb_state *mrb, mrb_value self/* x */)

{

return mrb_nil_value();

}

static inline long

mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long n)

{

const unsigned char *x = xs, *xe = xs + m;

const unsigned char *y = ys;

int i, qstable[256];

/* Preprocessing */

for (i = 0; i < 256; ++i)

qstable[i] = m + 1;

for (; x < xe; ++x)

qstable[*x] = xe - x;

/* Searching */

for (; y + m <= ys + n; y += *(qstable + y[m])) {

if (*xs == *y && memcmp(xs, y, m) == 0)

return y - ys;

}

return -1;

}

static int

mrb_memsearch(const void *x0, int m, const void *y0, int n)

{

const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0;

if (m > n) return -1;

else if (m == n) {

return memcmp(x0, y0, m) == 0 ? 0 : -1;

}

else if (m < 1) {

return 0;

}

else if (m == 1) {

const unsigned char *ys = y, *ye = ys + n;

for (; y < ye; ++y) {

if (*x == *y)

return y - ys;

}

return -1;

}

return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n);

}

static mrb_int

mrb_str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset)

{

mrb_int pos;

char *s, *sptr;

int len, slen;

len = RSTRING_LEN(str);

slen = RSTRING_LEN(sub);

if (offset < 0) {

offset += len;

if (offset < 0) return -1;

}

if (len - offset < slen) return -1;

s = RSTRING_PTR(str);

if (offset) {

s += offset;

}

if (slen == 0) return offset;

/* need proceed one character at a time */

sptr = RSTRING_PTR(sub);

slen = RSTRING_LEN(sub);

len = RSTRING_LEN(str) - offset;

pos = mrb_memsearch(sptr, slen, s, len);

if (pos < 0) return pos;

return pos + offset;

}

mrb_value

mrb_str_dup(mrb_state *mrb, mrb_value str)

{

/* should return shared string */

struct RString *s = mrb_str_ptr(str);

return mrb_str_new(mrb, s->ptr, s->len);

}

static mrb_value

mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)

{

long idx;

switch (mrb_type(indx)) {

case MRB_TT_FIXNUM:

idx = mrb_fixnum(indx);

num_index:

str = mrb_str_substr(mrb, str, idx, 1);

if (!mrb_nil_p(str) && RSTRING_LEN(str) == 0) return mrb_nil_value();

return str;

case MRB_TT_REGEX:

#ifdef ENABLE_REGEXP

return mrb_str_subpat(mrb, str, indx, 0); //mrb_str_subpat(str, indx, INT2FIX(0));

#else

mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");

return mrb_nil_value();

#endif //ENABLE_REGEXP

case MRB_TT_STRING:

if (mrb_str_index(mrb, str, indx, 0) != -1)

return mrb_str_dup(mrb, indx);

return mrb_nil_value();

default:

/* check if indx is Range */

{

mrb_int beg, len;

mrb_value tmp;

len = RSTRING_LEN(str);

switch (mrb_range_beg_len(mrb, indx, &beg, &len, len, 0)) {

case FALSE:

break;

case 2/*OTHER*/:

return mrb_nil_value();

default:

tmp = mrb_str_subseq(mrb, str, beg, len);

return tmp;

}

}

idx = mrb_fixnum(indx);

goto num_index;

}

return mrb_nil_value(); /* not reached */

}

/* 15.2.10.5.6 */

/* 15.2.10.5.34 */

/*

* call-seq:

* str[fixnum] => fixnum 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) => 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(regexp, fixnum) => new_str or nil

* str.slice(other_str) => new_str or nil

*

* Element Reference---If passed a single <code>Fixnum</code>, returns the code

* of the character at that position. If passed two <code>Fixnum</code>

* 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 <i>str</i>. Returns

* <code>nil</code> if the initial offset falls outside the string, the length

* is negative, or the beginning of the range is greater than the end.

*

* If a <code>Regexp</code> is supplied, the matching portion of <i>str</i> is

* returned. If a numeric parameter follows the regular expression, that

* component of the <code>MatchData</code> is returned instead. If a

* <code>String</code> is given, that string is returned if it occurs in

* <i>str</i>. In both cases, <code>nil</code> is returned if there is no

* match.

*

* a = "hello there"

* a[1] #=> 101(1.8.7) "e"(1.9.2)

* 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 mrb_value

mrb_str_aref_m(mrb_state *mrb, mrb_value str)

{

mrb_value a1, a2;

int argc;

argc = mrb_get_args(mrb, "o|o", &a1, &a2);

if (argc == 2) {

if (mrb_type(a1) == MRB_TT_REGEX) {

#ifdef ENABLE_REGEXP

return mrb_str_subpat(mrb, str, argv[0], mrb_fixnum(argv[1]));

#else

mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported");

return mrb_nil_value();

#endif //ENABLE_REGEXP

}

return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));

}

if (argc != 1) {

mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc);

}

return mrb_str_aref(mrb, str, a1);

}

/* 15.2.10.5.8 */

/*

* call-seq:

* str.capitalize! => str or nil

*

* Modifies <i>str</i> by converting the first character to uppercase and the

* remainder to lowercase. Returns <code>nil</code> if no changes are made.

*

* a = "hello"

* a.capitalize! #=> "Hello"

* a #=> "Hello"

* a.capitalize! #=> nil

*/

static mrb_value

mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str)

{

char *p, *pend;

int modify = 0;

struct RString *s = mrb_str_ptr(str);

str_modify(mrb, s);

if (s->len == 0 || !s->ptr) return mrb_nil_value();

p = s->ptr; pend = s->ptr + s->len;

if (ISLOWER(*p)) {

*p = TOUPPER(*p);

modify = 1;

}

while (++p < pend) {

if (ISUPPER(*p)) {

*p = TOLOWER(*p);

modify = 1;

}

}

if (modify) return str;

return mrb_nil_value();

}

/* 15.2.10.5.7 */

/*

* call-seq:

* str.capitalize => new_str

*

* Returns a copy of <i>str</i> with the first character converted to uppercase

* and the remainder to lowercase.

*

* "hello".capitalize #=> "Hello"

* "HELLO".capitalize #=> "Hello"

* "123ABC".capitalize #=> "123abc"

*/

static mrb_value

mrb_str_capitalize(mrb_state *mrb, mrb_value self)

{

mrb_value str;

str = mrb_str_dup(mrb, self);

mrb_str_capitalize_bang(mrb, str);

return str;

}

/* 15.2.10.5.10 */

/*

* call-seq:

* str.chomp!(separator=$/) => str or nil

*

* Modifies <i>str</i> in place as described for <code>String#chomp</code>,

* returning <i>str</i>, or <code>nil</code> if no modifications were made.

*/

static mrb_value

mrb_str_chomp_bang(mrb_state *mrb, mrb_value str)

{

mrb_value rs;

mrb_int newline;

char *p, *pp;

long len, rslen;

struct RString *s = mrb_str_ptr(str);

str_modify(mrb, s);

len = s->len;

if (mrb_get_args(mrb, "|S", &rs) == 0) {

if (len == 0) return mrb_nil_value();

smart_chomp:

if (s->ptr[len-1] == '\n') {

s->len--;

if (s->len > 0 &&

s->ptr[s->len-1] == '\r') {

s->len--;

}

}

else if (s->ptr[len-1] == '\r') {

s->len--;

}

else {

return mrb_nil_value();

}

s->ptr[s->len] = '\0';

return str;

}

if (len == 0 || mrb_nil_p(rs)) return mrb_nil_value();

p = s->ptr;

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 < s->len) {

s->len = len;

p[len] = '\0';

return str;

}

return mrb_nil_value();

}

if (rslen > len) return mrb_nil_value();

newline = RSTRING_PTR(rs)[rslen-1];

if (rslen == 1 && newline == '\n')

newline = RSTRING_PTR(rs)[rslen-1];

if (rslen == 1 && newline == '\n')

goto smart_chomp;

pp = p + len - rslen;

if (p[len-1] == newline &&

(rslen <= 1 ||

memcmp(RSTRING_PTR(rs), pp, rslen) == 0)) {

s->len = len - rslen;

p[s->len] = '\0';

return str;

}

return mrb_nil_value();

}

/* 15.2.10.5.9 */

/*

* call-seq:

* str.chomp(separator=$/) => new_str

*

* Returns a new <code>String</code> with the given record separator removed

* from the end of <i>str</i> (if present). If <code>$/</code> has not been

* changed from the default Ruby record separator, then <code>chomp</code> also

* removes carriage return characters (that is it will remove <code>\n</code>,

* <code>\r</code>, and <code>\r\n</code>).

*

* "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 mrb_value

mrb_str_chomp(mrb_state *mrb, mrb_value self)