#include <float.h>

#include <limits.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <mruby.h>

#include <mruby/array.h>

#include <mruby/class.h>

#include <mruby/range.h>

#include <mruby/string.h>

#include <mruby/re.h>

typedef struct mrb_shared_string {

} mrb_shared_string;

const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";

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

static struct RString*

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

{

struct RString *s;

if (len >= MRB_INT_MAX) {

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

}

s = mrb_obj_alloc_string(mrb);

s->as.heap.len = len;

s->as.heap.aux.capa = 0; /* nofree */

s->as.heap.ptr = (char *)p;

s->flags = MRB_STR_NOFREE;

return s;

}

static struct RString*

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

{

struct RString *s;

if (p && mrb_ro_data_p(p)) {

return str_new_static(mrb, p, len);

}

s = mrb_obj_alloc_string(mrb);

if (len < RSTRING_EMBED_LEN_MAX) {

RSTR_SET_EMBED_FLAG(s);

RSTR_SET_EMBED_LEN(s, len);

if (p) {

memcpy(s->as.ary, p, len);

}

} else {

if (len >= MRB_INT_MAX) {

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

}

s->as.heap.len = len;

s->as.heap.aux.capa = len;

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

if (p) {

memcpy(s->as.heap.ptr, p, len);

}

}

RSTR_PTR(s)[len] = '\0';

return s;

}

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

}

#ifndef MRB_STR_BUF_MIN_SIZE

# define MRB_STR_BUF_MIN_SIZE 128

MRB_API mrb_value

mrb_str_buf_new(mrb_state *mrb, size_t capa)

{

struct RString *s;

s = mrb_obj_alloc_string(mrb);

if (capa >= MRB_INT_MAX) {

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

}

if (capa < MRB_STR_BUF_MIN_SIZE) {

capa = MRB_STR_BUF_MIN_SIZE;

}

s->as.heap.len = 0;

s->as.heap.aux.capa = capa;

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

RSTR_PTR(s)[0] = '\0';

return mrb_obj_value(s);

}

static inline void

resize_capa(mrb_state *mrb, struct RString *s, mrb_int capacity)

{

if (RSTR_EMBED_P(s)) {

if (RSTRING_EMBED_LEN_MAX < capacity) {

char *const tmp = (char *)mrb_malloc(mrb, capacity+1);

const mrb_int len = RSTR_EMBED_LEN(s);

memcpy(tmp, s->as.ary, len);

RSTR_UNSET_EMBED_FLAG(s);

s->as.heap.ptr = tmp;

s->as.heap.len = len;

s->as.heap.aux.capa = capacity;

}

}

else {

s->as.heap.ptr = (char *)mrb_realloc(mrb, RSTR_PTR(s), capacity+1);

s->as.heap.aux.capa = capacity;

}

}

static void

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

{

size_t capa;

size_t total;

ptrdiff_t off = -1;

if (len == 0) return;

mrb_str_modify(mrb, s);

if (ptr >= RSTR_PTR(s) && ptr <= RSTR_PTR(s) + (size_t)RSTR_LEN(s)) {

off = ptr - RSTR_PTR(s);

}

if (RSTR_EMBED_P(s))

capa = RSTRING_EMBED_LEN_MAX;

else

capa = s->as.heap.aux.capa;

if (RSTR_LEN(s) >= MRB_INT_MAX - (mrb_int)len) {

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

}

total = RSTR_LEN(s)+len;

if (capa <= total) {

while (total > capa) {

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

capa = (total + 4095) / 4096;

break;

}

capa = (capa + 1) * 2;

}

resize_capa(mrb, s, capa);

}

if (off != -1) {

ptr = RSTR_PTR(s) + off;

}

memcpy(RSTR_PTR(s) + RSTR_LEN(s), ptr, len);

mrb_assert_int_fit(size_t, total, mrb_int, MRB_INT_MAX);

RSTR_SET_LEN(s, total);

RSTR_PTR(s)[total] = '\0'; /* sentinel */

}

MRB_API mrb_value

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

{

return mrb_obj_value(str_new(mrb, p, len));

}

MRB_API mrb_value

mrb_str_new_cstr(mrb_state *mrb, const char *p)

{

struct RString *s;

size_t len;

if (p) {

len = strlen(p);

}

else {

len = 0;

}

s = str_new(mrb, p, len);

return mrb_obj_value(s);

}

MRB_API mrb_value

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

{

struct RString *s = str_new_static(mrb, p, len);

return mrb_obj_value(s);

}

static void

str_decref(mrb_state *mrb, mrb_shared_string *shared)

{

shared->refcnt--;

if (shared->refcnt == 0) {

if (!shared->nofree) {

mrb_free(mrb, shared->ptr);

}

mrb_free(mrb, shared);

}

}

mrb_gc_free_str(mrb_state *mrb, struct RString *str)

{

if (RSTR_EMBED_P(str))

/* no code */;

else if (RSTR_SHARED_P(str))

str_decref(mrb, str->as.heap.aux.shared);

else if (!RSTR_NOFREE_P(str))

mrb_free(mrb, str->as.heap.ptr);

}

#ifdef MRB_UTF8_STRING

static const char utf8len_codepage[256] =

{

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,

3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1,

};

static mrb_int

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

{

mrb_int len;

mrb_int i;

len = utf8len_codepage[(unsigned char)*p];

if (p + len > e) return 1;

for (i = 1; i < len; ++i)

if ((p[i] & 0xc0) != 0x80)

return 1;

return len;

}

static mrb_int

utf8_strlen(mrb_value str, mrb_int len)

{

mrb_int total = 0;

char* p = RSTRING_PTR(str);

char* e = p;

e += len < 0 ? RSTRING_LEN(str) : len;

while (p<e) {

p += utf8len(p, e);

total++;

}

return total;

}

#define RSTRING_CHAR_LEN(s) utf8_strlen(s, -1)

static mrb_int

chars2bytes(mrb_value s, mrb_int off, mrb_int idx)

{

mrb_int i, b, n;

const char *p = RSTRING_PTR(s) + off;

const char *e = RSTRING_END(s);

for (b=i=0; p<e && i<idx; i++) {

n = utf8len(p, e);

b += n;

p += n;

}

return b;

}

static mrb_int

bytes2chars(char *p, mrb_int bi)

{

mrb_int i, b, n;

for (b=i=0; b<bi; i++) {

n = utf8len(p, p+bi);

b += n;

p += n;

}

return i;

}

#define RSTRING_CHAR_LEN(s) RSTRING_LEN(s)

#define chars2bytes(p, off, ci) (ci)

#define bytes2chars(p, bi) (bi)

static inline mrb_int

mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mrb_int 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 mrb_int

mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_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 void

str_make_shared(mrb_state *mrb, struct RString *s)

{

if (!RSTR_SHARED_P(s)) {

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

shared->refcnt = 1;

if (RSTR_EMBED_P(s)) {

const mrb_int len = RSTR_EMBED_LEN(s);

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

memcpy(tmp, s->as.ary, len);

tmp[len] = '\0';

RSTR_UNSET_EMBED_FLAG(s);

s->as.heap.ptr = tmp;

s->as.heap.len = len;

shared->nofree = FALSE;

shared->ptr = s->as.heap.ptr;

}

else if (RSTR_NOFREE_P(s)) {

shared->nofree = TRUE;

shared->ptr = s->as.heap.ptr;

RSTR_UNSET_NOFREE_FLAG(s);

}

else {

shared->nofree = FALSE;

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

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

}

else {

shared->ptr = s->as.heap.ptr;

}

}

shared->len = s->as.heap.len;

s->as.heap.aux.shared = shared;

RSTR_SET_SHARED_FLAG(s);

}

}

static mrb_value

byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)

{

struct RString *orig, *s;

mrb_shared_string *shared;

orig = mrb_str_ptr(str);

if (RSTR_EMBED_P(orig)) {

s = str_new(mrb, orig->as.ary+beg, len);

}

else {

str_make_shared(mrb, orig);

shared = orig->as.heap.aux.shared;

s = mrb_obj_alloc_string(mrb);

s->as.heap.ptr = orig->as.heap.ptr + beg;

s->as.heap.len = len;

s->as.heap.aux.shared = shared;

RSTR_SET_SHARED_FLAG(s);

shared->refcnt++;

}

return mrb_obj_value(s);

}

#ifdef MRB_UTF8_STRING

static inline mrb_value

str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)

{

beg = chars2bytes(str, 0, beg);

len = chars2bytes(str, beg, len);

return byte_subseq(mrb, str, beg, len);

}

#define str_subseq(mrb, str, beg, len) byte_subseq(mrb, str, beg, len)

static mrb_value

str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)

{

mrb_int clen = RSTRING_CHAR_LEN(str);

if (len < 0) return mrb_nil_value();

if (clen == 0) {

len = 0;

}

else if (beg < 0) {

beg = clen + beg;

}

if (beg > clen) return mrb_nil_value();

if (beg < 0) {

beg += clen;

if (beg < 0) return mrb_nil_value();

}

if (beg + len > clen)

len = clen - beg;

if (len <= 0) {

len = 0;

}

return str_subseq(mrb, str, beg, len);

}

static mrb_int

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

{

mrb_int pos;

char *s, *sptr;

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

}

static void

check_frozen(mrb_state *mrb, struct RString *s)

{

if (RSTR_FROZEN_P(s)) {

mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen string");

}

}

static mrb_value

str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)

{

long len;

check_frozen(mrb, s1);

len = RSTR_LEN(s2);

if (RSTR_SHARED_P(s1)) {

str_decref(mrb, s1->as.heap.aux.shared);

}

else if (!RSTR_EMBED_P(s1) && !RSTR_NOFREE_P(s1)) {

mrb_free(mrb, s1->as.heap.ptr);

}

RSTR_UNSET_NOFREE_FLAG(s1);

if (RSTR_SHARED_P(s2)) {

L_SHARE:

RSTR_UNSET_EMBED_FLAG(s1);

s1->as.heap.ptr = s2->as.heap.ptr;

s1->as.heap.len = len;

s1->as.heap.aux.shared = s2->as.heap.aux.shared;

RSTR_SET_SHARED_FLAG(s1);

s1->as.heap.aux.shared->refcnt++;

}

else {

if (len <= RSTRING_EMBED_LEN_MAX) {

RSTR_UNSET_SHARED_FLAG(s1);

RSTR_SET_EMBED_FLAG(s1);

memcpy(s1->as.ary, RSTR_PTR(s2), len);

RSTR_SET_EMBED_LEN(s1, len);

}

else {

str_make_shared(mrb, s2);

goto L_SHARE;

}

}

return mrb_obj_value(s1);

}

static mrb_int

str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos)

{

char *s, *sbeg, *t;

struct RString *ps = mrb_str_ptr(str);

mrb_int len = RSTRING_LEN(sub);

/* substring longer than string */

if (RSTR_LEN(ps) < len) return -1;

if (RSTR_LEN(ps) - pos < len) {

pos = RSTR_LEN(ps) - len;

}

sbeg = RSTR_PTR(ps);

s = RSTR_PTR(ps) + pos;

t = RSTRING_PTR(sub);

if (len) {

while (sbeg <= s) {

if (memcmp(s, t, len) == 0) {

return s - RSTR_PTR(ps);

}

s--;

}

return -1;

}

else {

return pos;

}

}

MRB_API mrb_int

mrb_str_strlen(mrb_state *mrb, struct RString *s)

{

mrb_int i, max = RSTR_LEN(s);

char *p = RSTR_PTR(s);

if (!p) return 0;

for (i=0; i<max; i++) {

if (p[i] == '\0') {

mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");

}

}

return max;

}

#ifdef _WIN32

#include <windows.h>

mrb_utf8_from_locale(const char *str, size_t len)

{

wchar_t* wcsp;

char* mbsp;

size_t mbssize, wcssize;

if (len == 0)

return strdup("");

if (len == -1)

len = strlen(str);

wcssize = MultiByteToWideChar(GetACP(), 0, str, len, NULL, 0);

wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t));

if (!wcsp)

return NULL;

wcssize = MultiByteToWideChar(GetACP(), 0, str, len, wcsp, wcssize + 1);

wcsp[wcssize] = 0;

mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL);

mbsp = (char*) malloc((mbssize + 1));

if (!mbsp) {

free(wcsp);

return NULL;

}

mbssize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL);

mbsp[mbssize] = 0;

free(wcsp);

return mbsp;

}

mrb_locale_from_utf8(const char *utf8, size_t len)

{

wchar_t* wcsp;

char* mbsp;

size_t mbssize, wcssize;

if (len == 0)

return strdup("");

if (len == -1)

len = strlen(utf8);

wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len, NULL, 0);

wcsp = (wchar_t*) malloc((wcssize + 1) * sizeof(wchar_t));

if (!wcsp)

return NULL;

wcssize = MultiByteToWideChar(CP_UTF8, 0, utf8, len, wcsp, wcssize + 1);

wcsp[wcssize] = 0;

mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, NULL, 0, NULL, NULL);

mbsp = (char*) malloc((mbssize + 1));

if (!mbsp) {

free(wcsp);

return NULL;

}

mbssize = WideCharToMultiByte(GetACP(), 0, (LPCWSTR) wcsp, -1, mbsp, mbssize, NULL, NULL);

mbsp[mbssize] = 0;

free(wcsp);

return mbsp;

}

MRB_API void

mrb_str_modify(mrb_state *mrb, struct RString *s)

{

check_frozen(mrb, s);

if (RSTR_SHARED_P(s)) {

mrb_shared_string *shared = s->as.heap.aux.shared;

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

s->as.heap.ptr = shared->ptr;

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

RSTR_PTR(s)[s->as.heap.len] = '\0';

mrb_free(mrb, shared);

}

else {

char *ptr, *p;

mrb_int len;

p = RSTR_PTR(s);

len = s->as.heap.len;

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

if (p) {

memcpy(ptr, p, len);

}

ptr[len] = '\0';

s->as.heap.ptr = ptr;

s->as.heap.aux.capa = len;

str_decref(mrb, shared);

}

RSTR_UNSET_SHARED_FLAG(s);

return;

}

if (RSTR_NOFREE_P(s)) {

char *p = s->as.heap.ptr;

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

if (p) {

memcpy(RSTR_PTR(s), p, s->as.heap.len);

}

RSTR_PTR(s)[s->as.heap.len] = '\0';

s->as.heap.aux.capa = s->as.heap.len;

RSTR_UNSET_NOFREE_FLAG(s);

return;

}

}

static mrb_value

mrb_str_freeze(mrb_state *mrb, mrb_value str)

{

struct RString *s = mrb_str_ptr(str);

RSTR_SET_FROZEN_FLAG(s);

return str;

}

MRB_API mrb_value

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

{

mrb_int slen;

struct RString *s = mrb_str_ptr(str);

mrb_str_modify(mrb, s);

slen = RSTR_LEN(s);

if (len != slen) {

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

resize_capa(mrb, s, len);

}

RSTR_SET_LEN(s, len);

RSTR_PTR(s)[len] = '\0'; /* sentinel */

}

return str;

}

MRB_API char*

mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)

{

struct RString *s;

if (!mrb_string_p(str0)) {

mrb_raise(mrb, E_TYPE_ERROR, "expected String");

}

s = str_new(mrb, RSTRING_PTR(str0), RSTRING_LEN(str0));

if ((strlen(RSTR_PTR(s)) ^ RSTR_LEN(s)) != 0) {

mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");

}

return RSTR_PTR(s);

}

MRB_API void

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

{

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

mrb_int len;

mrb_str_modify(mrb, s1);

if (!mrb_string_p(other)) {

other = mrb_str_to_str(mrb, other);

}

s2 = mrb_str_ptr(other);

len = RSTR_LEN(s1) + RSTR_LEN(s2);

if (RSTRING_CAPA(self) < len) {

resize_capa(mrb, s1, len);

}

memcpy(RSTR_PTR(s1)+RSTR_LEN(s1), RSTR_PTR(s2), RSTR_LEN(s2));

RSTR_SET_LEN(s1, len);

RSTR_PTR(s1)[len] = '\0';

}

MRB_API 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, RSTR_LEN(s) + RSTR_LEN(s2));

memcpy(RSTR_PTR(t), RSTR_PTR(s), RSTR_LEN(s));

memcpy(RSTR_PTR(t) + RSTR_LEN(s), RSTR_PTR(s2), RSTR_LEN(s2));

return mrb_obj_value(t);

}

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

}

static mrb_value

mrb_str_size(mrb_state *mrb, mrb_value self)

{

mrb_int len = RSTRING_CHAR_LEN(self);

return mrb_fixnum_value(len);

}

static mrb_value

mrb_str_bytesize(mrb_state *mrb, mrb_value self)

{

mrb_int len = RSTRING_LEN(self);

return mrb_fixnum_value(len);

}

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 && MRB_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 = RSTR_PTR(str2);

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[RSTR_LEN(str2)] = '\0';

return mrb_obj_value(str2);

}

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

MRB_API 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(RSTR_LEN(s1), RSTR_LEN(s2));

retval = memcmp(RSTR_PTR(s1), RSTR_PTR(s2), len);

if (retval == 0) {

if (RSTR_LEN(s1) == RSTR_LEN(s2)) return 0;

if (RSTR_LEN(s1) > RSTR_LEN(s2)) return 1;

return -1;

}

if (retval > 0) return 1;

return -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_lit(mrb, "to_s"))) {

return mrb_nil_value();

}

else if (!mrb_respond_to(mrb, str2, mrb_intern_lit(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 mrb_bool

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

{

const mrb_int len = RSTRING_LEN(str1);

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

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

return TRUE;

return FALSE;

}

MRB_API mrb_bool

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

{

if (mrb_immediate_p(str2)) return FALSE;

if (!mrb_string_p(str2)) {

if (mrb_nil_p(str2)) return FALSE;

if (!mrb_respond_to(mrb, str2, mrb_intern_lit(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);

}

static mrb_value

mrb_str_equal_m(mrb_state *mrb, mrb_value str1)

{

mrb_value str2;

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

return mrb_bool_value(mrb_str_equal(mrb, str1, str2));

}

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