#include "mruby.h"

#include <stdarg.h>

#include <string.h>

#include "mruby/string.h"

#include "mruby/numeric.h"

#include "mruby/range.h"

#include <ctype.h>

#include "mruby/array.h"

#include "mruby/class.h"

#include "variable.h"

#include "mruby/hash.h"

#include <stdio.h>

#include "variable.h"

#include "re.h"

#ifdef INCLUDE_REGEXP

#include "regex.h"

#include "st.h"

#endif //INCLUDE_REGEXP

#define mrb_usascii_str_new2 mrb_usascii_str_new_cstr

#ifndef FALSE

#define FALSE 0

#endif

#ifndef TRUE

#define TRUE 1

#endif

const char ruby_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";

#ifdef INCLUDE_REGEXP

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

#endif //INCLUDE_REGEXP

#ifdef INCLUDE_ENCODING

static void mrb_enc_cr_str_copy_for_substr(mrb_state *mrb, mrb_value dest, mrb_value src);

#else

#define mrb_enc_cr_str_copy_for_substr(mrb, dest, src)

#endif //INCLUDE_ENCODING

static mrb_value str_replace(mrb_state *mrb, mrb_value str, mrb_value str2);

#ifdef INCLUDE_ENCODING

static long str_strlen(mrb_state *mrb, mrb_value str, mrb_encoding *enc);

#endif //INCLUDE_ENCODING

int mrb_block_given_p();

#ifdef INCLUDE_ENCODING

#define is_ascii_string(mrb, str) (mrb_enc_str_coderange(mrb, str) == ENC_CODERANGE_7BIT)

#define is_broken_string(mrb, str) (mrb_enc_str_coderange(mrb, str) == ENC_CODERANGE_BROKEN)

#define STR_ENC_GET(mrb, str) mrb_enc_from_index(mrb, ENCODING_GET(mrb, str))

#endif //INCLUDE_ENCODING

void

mrb_str_set_len(mrb_state *mrb, mrb_value str, long len)

{

mrb_str_modify(mrb, str);

RSTRING_LEN(str) = len;

RSTRING_PTR(str)[len] = '\0';

}

#define RESIZE_CAPA(str,capacity) do {\

RSTRING(str)->buf = mrb_realloc(mrb, RSTRING(str)->buf, (capacity)+1);\

if (!MRB_STR_NOCAPA_P(str))\

RSTRING_CAPA(str) = capacity;\

} while (0)

#define STR_SET_LEN(str, n) do { \

RSTRING(str)->len = (n);\

} while (0)

#define STR_DEC_LEN(str) do {\

RSTRING(str)->len--;\

} while (0)

#ifdef INCLUDE_ENCODING

static mrb_value mrb_enc_cr_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len,

int ptr_encindex, int ptr_cr, int *ptr_cr_ret);

#endif //INCLUDE_ENCODING

mrb_value

mrb_tainted_str_new(mrb_state *mrb, const char *ptr, long len)

{

mrb_value str = mrb_str_new(mrb, ptr, len);

//OBJ_TAINT(str);

return str;

}

#ifdef INCLUDE_ENCODING

mrb_value

mrb_usascii_str_new_cstr(mrb_state *mrb, const char *ptr)

{

mrb_value str = mrb_str_new_cstr(mrb, ptr);//mrb_str_new2(ptr);

ENCODING_CODERANGE_SET(mrb, str, mrb_usascii_encindex(), ENC_CODERANGE_7BIT);

return str;

}

mrb_value

mrb_external_str_new_with_enc(mrb_state *mrb, const char *ptr, long len, mrb_encoding *eenc)

{

mrb_value str;

str = mrb_tainted_str_new(mrb, ptr, len);

if (eenc == mrb_usascii_encoding(mrb) &&

mrb_enc_str_coderange(mrb, str) != ENC_CODERANGE_7BIT) {

mrb_enc_associate(mrb, str, mrb_ascii8bit_encoding(mrb));

return str;

}

mrb_enc_associate(mrb, str, eenc);

return mrb_str_conv_enc(mrb, str, eenc, mrb_default_internal_encoding(mrb));

}

mrb_value

mrb_locale_str_new(mrb_state *mrb, const char *ptr, long len)

{

return mrb_external_str_new_with_enc(mrb, ptr, len, mrb_locale_encoding(mrb));

}

mrb_value

mrb_str_buf_cat_ascii(mrb_state *mrb, mrb_value str, const char *ptr)

{

/* ptr must reference NUL terminated ASCII string. */

int encindex = ENCODING_GET(mrb, str);

mrb_encoding *enc = mrb_enc_from_index(mrb, encindex);

if (mrb_enc_asciicompat(mrb, enc)) {

return mrb_enc_cr_str_buf_cat(mrb, str, ptr, strlen(ptr),

encindex, ENC_CODERANGE_7BIT, 0);

}

else {

//char *buf = ALLOCA_N(char, mrb_enc_mbmaxlen(enc));

char *buf = mrb_malloc(mrb, mrb_enc_mbmaxlen(enc));

while (*ptr) {

unsigned int c = (unsigned char)*ptr;

int len = mrb_enc_codelen(mrb, c, enc);

mrb_enc_mbcput(c, buf, enc);

mrb_enc_cr_str_buf_cat(mrb, str, buf, len,

encindex, ENC_CODERANGE_VALID, 0);

ptr++;

}

return str;

}

}

mrb_value

mrb_filesystem_str_new_cstr(mrb_state *mrb, const char *ptr)

{

return mrb_external_str_new_with_enc(mrb, ptr, strlen(ptr), mrb_filesystem_encoding(mrb));

}

#endif //INCLUDE_ENCODING

mrb_value

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

{

size_t slen;

if (len < 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");

}

mrb_str_modify(mrb, str);

slen = RSTRING_LEN(str);

if (len != slen) {

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

RSTRING_PTR(str) = mrb_realloc(mrb, RSTRING_PTR(str), len+1);

}

if (!MRB_STR_NOCAPA_P(str)) {

RSTRING(str)->aux.capa = len;

}

RSTRING(str)->len = len;

RSTRING(str)->buf[len] = '\0'; /* sentinel */

}

return str;

}

#ifdef INCLUDE_ENCODING

mrb_value

mrb_usascii_str_new(mrb_state *mrb, const char *ptr, long len)

{

mrb_value str = mrb_str_new(mrb, ptr, len);

ENCODING_CODERANGE_SET(mrb, str, mrb_usascii_encindex(), ENC_CODERANGE_7BIT);

return str;

}

#endif //INCLUDE_ENCODING

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->buf != p || s->len != len) {

mrb_raise(mrb, mrb->eRuntimeError_class, "string modified");

}

}

#ifdef INCLUDE_ENCODING

static inline int

single_byte_optimizable(mrb_state *mrb, mrb_value str)

{

mrb_encoding *enc;

/* Conservative. It may be ENC_CODERANGE_UNKNOWN. */

if (ENC_CODERANGE(str) == ENC_CODERANGE_7BIT)

return 1;

enc = STR_ENC_GET(mrb, str);

if (mrb_enc_mbmaxlen(enc) == 1)

return 1;

/* Conservative. Possibly single byte.

* "\xa1" in Shift_JIS for example. */

return 0;

}

static inline const char *

search_nonascii(const char *p, const char *e)

{

#if SIZEOF_VALUE == 8

# define NONASCII_MASK 0x8080808080808080ULL

#elif SIZEOF_VALUE == 4

# define NONASCII_MASK 0x80808080UL

#endif

#ifdef NONASCII_MASK

if ((int)sizeof(intptr_t) * 2 < e - p) {

const intptr_t *s, *t;

const intptr_t lowbits = sizeof(intptr_t) - 1;

s = (const intptr_t*)(~lowbits & ((intptr_t)p + lowbits));

while (p < (const char *)s) {

if (!ISASCII(*p))

return p;

p++;

}

t = (const intptr_t*)(~lowbits & (intptr_t)e);

while (s < t) {

if (*s & (intptr_t)NONASCII_MASK) {

t = s;

break;

}

s++;

}

p = (const char *)t;

}

#endif

while (p < e) {

if (!ISASCII(*p))

return p;

p++;

}

return NULL;

}

#endif //INCLUDE_ENCODING

static inline void

str_modifiable(mrb_value str)

{

;

}

static inline int

str_independent(mrb_value str)

{

str_modifiable(str);

if (!MRB_STR_SHARED_P(str)) return 1;

return 0;

}

#ifdef INCLUDE_ENCODING

static inline void

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

{

unsigned int tmp;

tmp = ENCODING_GET_INLINED(str2);

mrb_enc_set_index(mrb, str1, ENCODING_GET(mrb, str2));

}

static inline long

enc_strlen(const char *p, const char *e, mrb_encoding *enc, int cr)

{

long c;

const char *q;

if (mrb_enc_mbmaxlen(enc) == mrb_enc_mbminlen(enc)) {

return (e - p + mrb_enc_mbminlen(enc) - 1) / mrb_enc_mbminlen(enc);

}

else if (mrb_enc_asciicompat(mrb, enc)) {

c = 0;

if (cr == ENC_CODERANGE_7BIT || cr == ENC_CODERANGE_VALID) {

while (p < e) {

if (ISASCII(*p)) {

q = search_nonascii(p, e);

if (!q)

return c + (e - p);

c += q - p;

p = q;

}

p += mrb_enc_fast_mbclen(p, e, enc);

c++;

}

}

else {

while (p < e) {

if (ISASCII(*p)) {

q = search_nonascii(p, e);

if (!q)

return c + (e - p);

c += q - p;

p = q;

}

p += mrb_enc_mbclen(p, e, enc);

c++;

}

}

return c;

}

for (c=0; p<e; c++) {

p += mrb_enc_mbclen(p, e, enc);

}

return c;

}

size_t

mrb_str_capacity(mrb_value str)

{

if (MRB_STR_NOCAPA_P(str)) {

return RSTRING_LEN(str);

}

else {

return RSTRING_CAPA(str);

}

}

#endif //INCLUDE_ENCODING

static inline mrb_value

str_alloc(mrb_state *mrb)

{

struct RString* s;

s = mrb_obj_alloc(mrb, MRB_TT_STRING, mrb->string_class);

//NEWOBJ(str, struct RString);

//OBJSETUP(str, klass, T_STRING);

s->buf = 0;

s->len = 0;

s->aux.capa = 0;

return mrb_obj_value(s);

}

#ifdef INCLUDE_ENCODING

long

mrb_enc_strlen(const char *p, const char *e, mrb_encoding *enc)

{

return enc_strlen(p, e, enc, ENC_CODERANGE_UNKNOWN);

}

#endif //INCLUDE_ENCODING

static void

str_make_independent(mrb_state *mrb, mrb_value str)

{

char *ptr;

long len = RSTRING_LEN(str);

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

if (RSTRING_PTR(str)) {

memcpy(ptr, RSTRING_PTR(str), len);

}

ptr[len] = 0;

RSTRING(str)->buf = ptr;

RSTRING(str)->len = len;

RSTRING(str)->aux.capa = len;

MRB_STR_UNSET_NOCAPA(str);

}

#ifdef INCLUDE_ENCODING

static int

coderange_scan(const char *p, long len, mrb_encoding *enc)

{

const char *e = p + len;

if (mrb_enc_to_index(enc) == 0) {

/* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */

p = search_nonascii(p, e);

return p ? ENC_CODERANGE_VALID : ENC_CODERANGE_7BIT;

}

if (mrb_enc_asciicompat(mrb, enc)) {

p = search_nonascii(p, e);

if (!p) {

return ENC_CODERANGE_7BIT;

}

while (p < e) {

int ret = mrb_enc_precise_mbclen(p, e, enc);

if (!MBCLEN_CHARFOUND_P(ret)) {

return ENC_CODERANGE_BROKEN;

}

p += MBCLEN_CHARFOUND_LEN(ret);

if (p < e) {

p = search_nonascii(p, e);

if (!p) {

return ENC_CODERANGE_VALID;

}

}

}

if (e < p) {

return ENC_CODERANGE_BROKEN;

}

return ENC_CODERANGE_VALID;

}

while (p < e) {

int ret = mrb_enc_precise_mbclen(p, e, enc);

if (!MBCLEN_CHARFOUND_P(ret)) {

return ENC_CODERANGE_BROKEN;

}

p += MBCLEN_CHARFOUND_LEN(ret);

}

if (e < p) {

return ENC_CODERANGE_BROKEN;

}

return ENC_CODERANGE_VALID;

}

int

mrb_enc_str_coderange(mrb_state *mrb, mrb_value str)

{

int cr = ENC_CODERANGE(str);

if (cr == ENC_CODERANGE_UNKNOWN) {

mrb_encoding *enc = STR_ENC_GET(mrb, str);

cr = coderange_scan(RSTRING_PTR(str), RSTRING_LEN(str), enc);

ENC_CODERANGE_SET(str, cr);

}

return cr;

}

char*

mrb_enc_nth(mrb_state *mrb, const char *p, const char *e, long nth, mrb_encoding *enc)

{

if (mrb_enc_mbmaxlen(enc) == 1) {

p += nth;

}

else if (mrb_enc_mbmaxlen(enc) == mrb_enc_mbminlen(enc)) {

p += nth * mrb_enc_mbmaxlen(enc);

}

else if (mrb_enc_asciicompat(mrb, enc)) {

const char *p2, *e2;

int n;

while (p < e && 0 < nth) {

e2 = p + nth;

if (e < e2)

return (char *)e;

if (ISASCII(*p)) {

p2 = search_nonascii(p, e2);

if (!p2)

return (char *)e2;

nth -= p2 - p;

p = p2;

}

n = mrb_enc_mbclen(p, e, enc);

p += n;

nth--;

}

if (nth != 0)

return (char *)e;

return (char *)p;

}

else {

while (p<e && nth--) {

p += mrb_enc_mbclen(p, e, enc);

}

}

if (p > e) p = e;

return (char*)p;

}

static char*

str_nth(mrb_state *mrb, const char *p, const char *e, long nth, mrb_encoding *enc, int singlebyte)

{

if (singlebyte)

p += nth;

else {

p = mrb_enc_nth(mrb, p, e, nth, enc);

}

if (!p) return 0;

if (p > e) p = e;

return (char *)p;

}

/* char offset to byte offset */

static long

str_offset(mrb_state *mrb, const char *p, const char *e, long nth, mrb_encoding *enc, int singlebyte)

{

const char *pp = str_nth(mrb, p, e, nth, enc, singlebyte);

if (!pp) return e - p;

return pp - p;

}

long

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

{

return str_offset(mrb, RSTRING_PTR(str), RSTRING_END(str), pos,

STR_ENC_GET(mrb, str), single_byte_optimizable(mrb, str));

}

static void

mrb_enc_cr_str_exact_copy(mrb_state *mrb, mrb_value dest, mrb_value src)

{

str_enc_copy(mrb, dest, src);

ENC_CODERANGE_SET(dest, ENC_CODERANGE(src));

}

#else

#define mrb_enc_cr_str_exact_copy(mrb, dest, src)

#endif //INCLUDE_ENCODING

mrb_value

str_new4(mrb_state *mrb, enum mrb_vtype ttype, mrb_value str)

{

mrb_value str2;

str2 = mrb_obj_value(mrb_obj_alloc(mrb, ttype, mrb->string_class));//str_alloc(klass);

RSTRING(str2)->len = RSTRING_LEN(str);

RSTRING(str2)->buf = RSTRING_PTR(str);

if (MRB_STR_SHARED_P(str)) {

mrb_value shared = RSTRING_SHARED(str);

FL_SET(str2, MRB_STR_SHARED);

RSTRING_SHARED(str2) = shared;

}

else {

FL_SET(str, MRB_STR_SHARED);

RSTRING_SHARED(str) = str2;

}

mrb_enc_cr_str_exact_copy(mrb, str2, str);

return str2;

}

static mrb_value

str_new(mrb_state *mrb, enum mrb_vtype ttype, const char *p, size_t len)

{

mrb_value str;

if (len < 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");

}

//str = str_alloc(mrb);

str = mrb_str_buf_new(mrb, len);

#ifdef INCLUDE_ENCODING

if (len == 0) {

ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT);

}

#endif //INCLUDE_ENCODING

if (p) {

memcpy(RSTRING_PTR(str), p, len);

}

STR_SET_LEN(str, len);

RSTRING_PTR(str)[len] = '\0';

return str;

}

mrb_value

mrb_str_new_with_class(mrb_state *mrb, mrb_value obj, const char *ptr, long len)

{

return str_new(mrb, mrb_type(obj), ptr, len);

}

#define mrb_str_new5 mrb_str_new_with_class

static mrb_value

str_new_empty(mrb_state *mrb, mrb_value str)

{

mrb_value v = mrb_str_new5(mrb, str, 0, 0);

return v;

}

mrb_value

mrb_str_buf_new(mrb_state *mrb, size_t capa)

{

struct RString *s;

s = mrb_obj_alloc(mrb, MRB_TT_STRING, mrb->string_class);

if (capa < STR_BUF_MIN_SIZE) {

capa = STR_BUF_MIN_SIZE;

}

s->len = 0;

s->aux.capa = capa;

s->buf = mrb_malloc(mrb, capa+1);

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

return mrb_obj_value(s);

}

mrb_value

str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len)

{

long capa, total, off = -1;

if (ptr >= RSTRING_PTR(str) && ptr <= RSTRING_END(str)) {

off = ptr - RSTRING_PTR(str);

}

mrb_str_modify(mrb, str);

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

capa = RSTRING_CAPA(str);

if (RSTRING_LEN(str) >= LONG_MAX - len) {

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

}

total = RSTRING_LEN(str)+len;

if (capa <= total) {

while (total > capa) {

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

capa = (total + 4095) / 4096;

break;

}

capa = (capa + 1) * 2;

}

RESIZE_CAPA(str, capa);

}

if (off != -1) {

ptr = RSTRING_PTR(str) + off;

}

memcpy(RSTRING_PTR(str) + RSTRING_LEN(str), ptr, len);

STR_SET_LEN(str, total);

RSTRING_PTR(str)[total] = '\0'; /* sentinel */

return str;

}

mrb_value

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

{

if (len == 0) return str;

if (len < 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)");

}

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

}

/*

* call-seq:

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

*

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

*/

mrb_value

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

{

struct RString *s;

if (len == 0) {

return mrb_str_buf_new(mrb, len);

}

s = mrb_obj_alloc(mrb, MRB_TT_STRING, mrb->string_class);

s->buf = mrb_malloc(mrb, len+1);

if (p) {

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

}

s->len = len;

s->aux.capa = len;

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

return mrb_obj_value(s);

}

/* ptr==0 is error */

mrb_value

mrb_str_new2(mrb_state *mrb, const char *ptr)

{

if (!ptr) {

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

}

#ifdef INCLUDE_ENCODING

return mrb_usascii_str_new2(mrb, ptr);

#else

return mrb_str_new(mrb, ptr, strlen(ptr));

#endif //INCLUDE_ENCODING

}

#ifdef INCLUDE_ENCODING

mrb_value

mrb_enc_str_new(mrb_state *mrb, const char *ptr, long len, mrb_encoding *enc)

{

mrb_value str = mrb_str_new(mrb, ptr, len);

mrb_enc_associate(mrb, str, enc);

return str;

}

#endif //INCLUDE_ENCODING

/*

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

size_t len = strlen(p);

s = mrb_obj_alloc(mrb, MRB_TT_STRING, mrb->string_class);

s->buf = mrb_malloc(mrb, len+1);

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

s->buf[len] = 0;

s->len = len;

s->aux.capa = len;

return mrb_obj_value(s);

}

/*

* 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 lit)

{

struct RString *s = mrb_str_ptr(lit);

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

}

/*

* 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->buf;

}

/*

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

size_t len;

if (mrb_type(other) != MRB_TT_STRING) {

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->buf = mrb_realloc(mrb, s1->buf, len+1);

}

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

s1->len = len;

s1->buf[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;

mrb_value r;

r = mrb_str_new(mrb, 0, s->len + s2->len);

t = mrb_str_ptr(r);

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

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

return r;

}

/* 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 str3;

mrb_value str2;

#ifdef INCLUDE_ENCODING

mrb_encoding *enc;

#endif //INCLUDE_ENCODING

//mrb_get_args(mrb, "s", &p, &len);

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

mrb_string_value(mrb, &str2);

#ifdef INCLUDE_ENCODING

enc = mrb_enc_check(mrb, self, str2);

#endif //INCLUDE_ENCODING

str3 = mrb_str_new(mrb, 0, RSTRING_LEN(self)+RSTRING_LEN(str2));

memcpy(RSTRING_PTR(str3), RSTRING_PTR(self), RSTRING_LEN(self));

memcpy(RSTRING_PTR(str3) + RSTRING_LEN(self),

RSTRING_PTR(str2), RSTRING_LEN(str2));

RSTRING_PTR(str3)[RSTRING_LEN(str3)] = '\0';

#ifdef INCLUDE_ENCODING

//if (OBJ_TAINTED(str1) || OBJ_TAINTED(str2))

// OBJ_TAINT(str3);

ENCODING_CODERANGE_SET(mrb, str3, mrb_enc_to_index(enc),

ENC_CODERANGE_AND(ENC_CODERANGE(self), ENC_CODERANGE(str2)));

#endif //INCLUDE_ENCODING

return str3;

}

/*

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

{

#ifdef INCLUDE_ENCODING

long len;

len = str_strlen(mrb, self, STR_ENC_GET(mrb, self));

return mrb_fixnum_value(len);

#else

return mrb_str_bytesize(mrb, self);

#endif //INCLUDE_ENCODING

}

void

mrb_str_modify(mrb_state *mrb, mrb_value str)

{

if (!str_independent(str))

str_make_independent(mrb, str);

}

/* 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_value str2;

mrb_int n,len,times;

char *ptr2;

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

if (times < 0) {

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

}

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

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

}

str2 = mrb_str_new5(mrb, self, 0, len = RSTRING_LEN(self)*times);

ptr2 = RSTRING_PTR(str2);

if (len > 0) {

n = RSTRING_LEN(self);

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

while (n <= len/2) {

memcpy(ptr2 + n, ptr2, n);

n *= 2;

}

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

}

ptr2[RSTRING_LEN(str2)] = '\0';

//OBJ_INFECT(str2, str);

mrb_enc_cr_str_copy_for_substr(mrb, str2, self);

return 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->buf, s2->buf, 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_type(str2) != MRB_TT_STRING) {

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);