diff options
Diffstat (limited to 'src/string.c')
| -rw-r--r-- | src/string.c | 2379 |
1 files changed, 129 insertions, 2250 deletions
diff --git a/src/string.c b/src/string.c index 22e3dad60..257286144 100644 --- a/src/string.c +++ b/src/string.c @@ -9,13 +9,12 @@ #include <stdarg.h> #include <string.h> #include "mruby/string.h" +#include <ctype.h> #include "mruby/numeric.h" #include "mruby/range.h" -#include <ctype.h> #include "mruby/array.h" #include "mruby/class.h" #include "mruby/variable.h" -#include "mruby/hash.h" #include <stdio.h> #include "re.h" #ifdef INCLUDE_REGEXP @@ -23,8 +22,6 @@ #include "st.h" #endif //INCLUDE_REGEXP -#define mrb_usascii_str_new2 mrb_usascii_str_new_cstr - #ifndef FALSE #define FALSE 0 #endif @@ -38,33 +35,11 @@ const char mrb_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 -#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;\ + RSTRING_CAPA(str) = capacity;\ } while (0) #define STR_SET_LEN(str, n) do { \ @@ -75,86 +50,18 @@ mrb_str_set_len(mrb_state *mrb, mrb_value str, long len) 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 - -#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_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; - 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_CAPA(str) = len; } RSTRING(str)->len = len; RSTRING(str)->buf[len] = '\0'; /* sentinel */ @@ -162,16 +69,6 @@ mrb_str_resize(mrb_state *mrb, mrb_value str, size_t len) 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) { @@ -182,36 +79,6 @@ str_mod_check(mrb_state *mrb, mrb_value str, char *p, mrb_int len) } } -#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) -{ - while (p < e) { - if (!ISASCII(*p)) - return p; - p++; - } - return NULL; -} -#endif //INCLUDE_ENCODING - static inline void str_modifiable(mrb_value str) { @@ -226,71 +93,6 @@ str_independent(mrb_value str) return 0; } -#ifdef INCLUDE_ENCODING -static inline void -str_enc_copy(mrb_state *mrb, mrb_value str1, mrb_value 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 - #define mrb_obj_alloc_string(mrb) ((struct RString*)mrb_obj_alloc((mrb), MRB_TT_STRING, (mrb)->string_class)) static inline mrb_value @@ -299,204 +101,28 @@ str_alloc(mrb_state *mrb) struct RString* s; s = mrb_obj_alloc_string(mrb); - //NEWOBJ(str, struct RString); - //OBJSETUP(str, klass, T_STRING); s->buf = 0; s->len = 0; - s->aux.capa = 0; + s->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)); + return pos; } -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, mrb_value str) +static mrb_value +str_dup(mrb_state *mrb, mrb_value str) { - mrb_value str2; - - str2 = mrb_obj_value(mrb_obj_alloc_string(mrb)); - RSTRING(str2)->len = RSTRING_LEN(str); - RSTRING(str2)->buf = RSTRING_PTR(str); + /* should return shared string */ + struct RString *s = mrb_str_ptr(str); - if (MRB_STR_SHARED_P(str)) { - struct RString *shared = RSTRING_SHARED(str); - FL_SET(str2, MRB_STR_SHARED); - RSTRING_SHARED(str2) = shared; - } - else { - FL_SET(str, MRB_STR_SHARED); - RSTRING_SHARED(str) = mrb_str_ptr(str2); - } - mrb_enc_cr_str_exact_copy(mrb, str2, str); - return str2; + return mrb_str_new(mrb, s->buf, s->len); } static mrb_value @@ -506,11 +132,6 @@ str_new(mrb_state *mrb, enum mrb_vtype ttype, const char *p, size_t len) //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); } @@ -519,19 +140,16 @@ str_new(mrb_state *mrb, enum mrb_vtype ttype, const char *p, size_t len) return str; } -mrb_value +static 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; + return mrb_str_new_with_class(mrb, str, 0, 0); } mrb_value @@ -545,7 +163,7 @@ mrb_str_buf_new(mrb_state *mrb, size_t capa) capa = STR_BUF_MIN_SIZE; } s->len = 0; - s->aux.capa = capa; + s->capa = capa; s->buf = mrb_malloc(mrb, capa+1); s->buf[0] = '\0'; @@ -560,7 +178,6 @@ str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) 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) { @@ -615,7 +232,7 @@ mrb_str_new(mrb_state *mrb, const char *p, size_t len) memcpy(s->buf, p, len); } s->len = len; - s->aux.capa = len; + s->capa = len; s->buf[len] ='\0'; return mrb_obj_value(s); } @@ -627,23 +244,9 @@ 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 @@ -662,7 +265,7 @@ mrb_str_new_cstr(mrb_state *mrb, const char *p) memcpy(s->buf, p, len); s->buf[len] = 0; s->len = len; - s->aux.capa = len; + s->capa = len; return mrb_obj_value(s); } @@ -715,8 +318,8 @@ mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other) s2 = mrb_str_ptr(other); len = s1->len + s2->len; - if (s1->aux.capa < len) { - s1->aux.capa = len; + if (s1->capa < len) { + s1->capa = len; s1->buf = mrb_realloc(mrb, s1->buf, len+1); } memcpy(s1->buf+s1->len, s2->buf, s2->len); @@ -757,30 +360,7 @@ mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b) 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 - ENCODING_CODERANGE_SET(mrb, str3, mrb_enc_to_index(enc), - ENC_CODERANGE_AND(ENC_CODERANGE(self), ENC_CODERANGE(str2))); -#endif //INCLUDE_ENCODING - - return str3; + return mrb_nil_value(); } /* @@ -792,9 +372,7 @@ mrb_str_plus_m(mrb_state *mrb, mrb_value self) 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); + return mrb_nil_value(); } /* 15.2.10.5.26 */ @@ -808,26 +386,10 @@ mrb_str_bytesize(mrb_state *mrb, mrb_value self) 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 + return mrb_fixnum_value(RSTRING_LEN(self)); } -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 @@ -840,35 +402,7 @@ mrb_str_modify(mrb_state *mrb, mrb_value str) 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", ×); - - 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'; - - mrb_enc_cr_str_copy_for_substr(mrb, str2, self); - - return str2; + return mrb_nil_value(); } /* -------------------------------------------------------------- */ @@ -930,73 +464,8 @@ mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2) 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); - } - return mrb_fixnum_value(result); -} - -#ifdef INCLUDE_ENCODING -int -mrb_str_comparable(mrb_state *mrb, mrb_value str1, mrb_value str2) -{ - int idx1, idx2; - int rc1, rc2; - - if (RSTRING_LEN(str1) == 0) return TRUE; - if (RSTRING_LEN(str2) == 0) return TRUE; - idx1 = ENCODING_GET(mrb, str1); - idx2 = ENCODING_GET(mrb, str2); - if (idx1 == idx2) return TRUE; - rc1 = mrb_enc_str_coderange(mrb, str1); - rc2 = mrb_enc_str_coderange(mrb, str2); - if (rc1 == ENC_CODERANGE_7BIT) { - if (rc2 == ENC_CODERANGE_7BIT) return TRUE; - if (mrb_enc_asciicompat(mrb, mrb_enc_from_index(mrb, idx2))) - return TRUE; - } - if (rc2 == ENC_CODERANGE_7BIT) { - if (mrb_enc_asciicompat(mrb, mrb_enc_from_index(mrb, idx1))) - return TRUE; - } - return FALSE; -} - -int -mrb_str_hash_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2) -{ - long len; - - if (!mrb_str_comparable(mrb, str1, str2)) return 1; - if (RSTRING_LEN(str1) == (len = RSTRING_LEN(str2)) && - memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len) == 0) { - return 0; - } - return 1; + return mrb_nil_value(); } -#endif //INCLUDE_ENCODING static int str_eql(mrb_state *mrb, const mrb_value str1, const mrb_value str2) @@ -1004,9 +473,6 @@ 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; -#ifdef INCLUDE_ENCODING - if (!mrb_str_comparable(mrb, str1, str2)) return FALSE; -#endif //INCLUDE_ENCODING if (memcmp(RSTRING_PTR(str1), RSTRING_PTR(str2), len) == 0) return TRUE; return FALSE; @@ -1100,202 +566,9 @@ mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr) static mrb_value mrb_str_match(mrb_state *mrb, mrb_value self/* x */) { - mrb_value y; - - mrb_get_args(mrb, "o", &y); - switch (mrb_type(y)) { - case MRB_TT_STRING: - mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: String given"); - case MRB_TT_REGEX: -#ifdef INCLUDE_REGEXP - return mrb_reg_match_str(mrb, y, self); -#else - mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP - default: - if (mrb_respond_to(mrb, y, mrb_intern(mrb, "=~"))) { - return mrb_funcall(mrb, y, "=~", 1, self); - } - else { - return mrb_nil_value(); - } - } -} -/* ---------------------------------- */ -mrb_value -mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, int len) -{ -#ifdef INCLUDE_ENCODING - mrb_encoding *enc = STR_ENC_GET(mrb, str); -#endif //INCLUDE_ENCODING - mrb_value str2; -#ifdef INCLUDE_ENCODING - char *p, *s = RSTRING_PTR(str), *e = s + RSTRING_LEN(str); -#else - char *p, *s = RSTRING_PTR(str); -#endif //INCLUDE_ENCODING - - if (len < 0) return mrb_nil_value(); - if (!RSTRING_LEN(str)) { - len = 0; - } -#ifdef INCLUDE_ENCODING - if (single_byte_optimizable(mrb, str)) { -#endif //INCLUDE_ENCODING - if (beg > RSTRING_LEN(str)) return mrb_nil_value(); - if (beg < 0) { - beg += RSTRING_LEN(str); - if (beg < 0) return mrb_nil_value(); - } - if (beg + len > RSTRING_LEN(str)) - len = RSTRING_LEN(str) - beg; - if (len <= 0) { - len = 0; - p = 0; - } - else - p = s + beg; -#ifdef INCLUDE_ENCODING - goto sub; - } - if (beg < 0) { - if (len > -beg) len = -beg; - if (-beg * mrb_enc_mbmaxlen(enc) < RSTRING_LEN(str) / 8) { - beg = -beg; - while (beg-- > len && (e = mrb_enc_prev_char(s, e, e, enc)) != 0); - p = e; - if (!p) return mrb_nil_value(); - while (len-- > 0 && (p = mrb_enc_prev_char(s, p, e, enc)) != 0); - if (!p) return mrb_nil_value(); - len = e - p; - goto sub; - } - else { - beg += str_strlen(mrb, str, enc); - if (beg < 0) return mrb_nil_value(); - } - } - else if (beg > 0 && beg > str_strlen(mrb, str, enc)) { - return mrb_nil_value(); - } - if (len == 0) { - p = 0; - } - else if (mrb_enc_mbmaxlen(enc) == mrb_enc_mbminlen(enc)) { - int char_sz = mrb_enc_mbmaxlen(enc); - - p = s + beg * char_sz; - if (p > e) { - p = e; - len = 0; - } - else if (len * char_sz > e - p) - len = e - p; - else - len *= char_sz; - } - else if ((p = str_nth(mrb, s, e, beg, enc, 0)) == e) { - len = 0; - } - else { - len = str_offset(mrb, p, e, len, enc, 0); - } -sub: -#endif //INCLUDE_ENCODING - if (len > STR_BUF_MIN_SIZE && beg + len == RSTRING_LEN(str)) { -#ifdef INCLUDE_ENCODING - str2 = mrb_str_new4(mrb, str); - str2 = str_new3(mrb, mrb_obj_class(mrb, str2), str2); -#else - str2 = mrb_str_new(mrb, s, RSTRING_LEN(str)); -#endif //INCLUDE_ENCODING - RSTRING(str2)->buf += RSTRING(str2)->len - len; - RSTRING(str2)->len = len; - } - else { - str2 = mrb_str_new5(mrb, str, p, len); - mrb_enc_cr_str_copy_for_substr(mrb, str2, str); - } - - return str2; -} - -#ifdef INCLUDE_REGEXP -static mrb_value -mrb_str_subpat(mrb_state *mrb, mrb_value str, mrb_value re, mrb_int backref) -{ - if (mrb_reg_search(mrb, re, str, 0, 0) >= 0) { - mrb_value match = mrb_backref_get(mrb); - int nth = mrb_reg_backref_number(mrb, match, mrb_fixnum_value(backref)); - return mrb_reg_nth_match(mrb, nth, mrb_backref_get(mrb)); - } return mrb_nil_value(); } -#endif //INCLUDE_REGEXP -/* --- 1-8-7parse.c --> */ - -#ifdef INCLUDE_ENCODING -long -mrb_enc_strlen_cr(mrb_state *mrb, const char *p, const char *e, mrb_encoding *enc, int *cr) -{ - long c; - const char *q; - int ret; - - *cr = 0; - 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; - while (p < e) { - if (ISASCII(*p)) { - q = search_nonascii(p, e); - if (!q) { - if (!*cr) *cr = ENC_CODERANGE_7BIT; - return c + (e - p); - } - c += q - p; - p = q; - } - ret = mrb_enc_precise_mbclen(p, e, enc); - if (MBCLEN_CHARFOUND_P(ret)) { - *cr |= ENC_CODERANGE_VALID; - p += MBCLEN_CHARFOUND_LEN(ret); - } - else { - *cr = ENC_CODERANGE_BROKEN; - p++; - } - c++; - } - if (!*cr) *cr = ENC_CODERANGE_7BIT; - return c; - } - - for (c=0; p<e; c++) { - ret = mrb_enc_precise_mbclen(p, e, enc); - if (MBCLEN_CHARFOUND_P(ret)) { - *cr |= ENC_CODERANGE_VALID; - p += MBCLEN_CHARFOUND_LEN(ret); - } - else { - *cr = ENC_CODERANGE_BROKEN; - if (p + mrb_enc_mbminlen(enc) <= e) - p += mrb_enc_mbminlen(enc); - else - p = e; - } - } - if (!*cr) *cr = ENC_CODERANGE_7BIT; - return c; -} -#endif //INCLUDE_ENCODING - -/* --- 1-8-7parse.c --< */ - -#ifndef INCLUDE_ENCODING static inline long mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long n) { @@ -1308,7 +581,7 @@ mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long qstable[i] = m + 1; for (; x < xe; ++x) qstable[*x] = xe - x; - /* Searching */ + /* Searching */ for (; y + m <= ys + n; y += *(qstable + y[m])) { if (*xs == *y && memcmp(xs, y, m) == 0) return y - ys; @@ -1316,7 +589,7 @@ mrb_memsearch_qs(const unsigned char *xs, long m, const unsigned char *ys, long return -1; } -int +static int mrb_memsearch(const void *x0, int m, const void *y0, int n) { const unsigned char *x = x0, *y = y0; @@ -1328,7 +601,7 @@ mrb_memsearch(const void *x0, int m, const void *y0, int n) else if (m < 1) { return 0; } - else if (m == 1) { + else if (m == 1) { const unsigned char *ys = y, *ye = ys + n; for (; y < ye; ++y) { if (*x == *y) @@ -1338,60 +611,22 @@ mrb_memsearch(const void *x0, int m, const void *y0, int n) } return mrb_memsearch_qs(x0, m, y0, n); } -#endif //INCLUDE_ENCODING - -/* --- 1-8-7parse.c --< */ -#ifdef INCLUDE_ENCODING -static long -str_strlen(mrb_state *mrb, mrb_value str, mrb_encoding *enc) -{ - const char *p, *e; - long n; - int cr; - - if (single_byte_optimizable(mrb, str)) return RSTRING_LEN(str); - if (!enc) enc = STR_ENC_GET(mrb, str); - p = RSTRING_PTR(str); - e = RSTRING_END(str); - cr = ENC_CODERANGE(str); - n = mrb_enc_strlen_cr(mrb, p, e, enc, &cr); - if (cr) { - ENC_CODERANGE_SET(str, cr); - } - return n; -} -#endif //INCLUDE_ENCODING static mrb_int mrb_str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset) { mrb_int pos; - char *s, *sptr, *e; + char *s, *sptr; int len, slen; -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; - - enc = mrb_enc_check(mrb, str, sub); - if (is_broken_string(mrb, sub)) { - return -1; - } - len = str_strlen(mrb, str, enc); - slen = str_strlen(mrb, sub, enc); -#else len = RSTRING_LEN(str); slen = RSTRING_LEN(sub); -#endif //INCLUDE_ENCODING if (offset < 0) { offset += len; if (offset < 0) return -1; } if (len - offset < slen) return -1; s = RSTRING_PTR(str); - e = s + RSTRING_LEN(str); if (offset) { -#ifdef INCLUDE_ENCODING - offset = str_offset(mrb, s, RSTRING_END(str), offset, enc, single_byte_optimizable(mrb, str)); -#endif //INCLUDE_ENCODING s += offset; } if (slen == 0) return offset; @@ -1399,21 +634,9 @@ mrb_str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset) sptr = RSTRING_PTR(sub); slen = RSTRING_LEN(sub); len = RSTRING_LEN(str) - offset; -#ifdef INCLUDE_ENCODING - for (;;) { - char *t; - pos = mrb_memsearch(mrb, sptr, slen, s, len, enc); - if (pos < 0) return pos; - t = mrb_enc_right_char_head(s, s+pos, e, enc); - if (t == s + pos) break; - if ((len -= t - s) <= 0) return -1; - offset += t - s; - s = t; - } -#else pos = mrb_memsearch(sptr, slen, s, len); + if (pos < 0) return pos; -#endif //INCLUDE_ENCODING return pos + offset; } @@ -1430,7 +653,7 @@ mrb_str_dup(mrb_state *mrb, mrb_value str) dup->buf[s->len] = 0; } dup->len = s->len; - dup->aux.capa = s->len; + dup->capa = s->len; return mrb_obj_value(dup); } @@ -1444,7 +667,7 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx) idx = mrb_fixnum(indx); num_index: - str = mrb_str_substr(mrb, str, idx, 1); + str = mrb_str_subseq(mrb, str, idx, 1); if (!mrb_nil_p(str) && RSTRING_LEN(str) == 0) return mrb_nil_value(); return str; @@ -1467,18 +690,14 @@ num_index: mrb_int beg, len; mrb_value tmp; -#ifdef INCLUDE_ENCODING - len = str_strlen(mrb, str, STR_ENC_GET(mrb, str)); -#else len = RSTRING_LEN(str); -#endif //INCLUDE_ENCODING switch (mrb_range_beg_len(mrb, indx, &beg, &len, len, 0)) { case 0/*FLASE*/: break; case 2/*OTHER*/: return mrb_nil_value(); default: - tmp = mrb_str_substr(mrb, str, beg, len); + tmp = mrb_str_subseq(mrb, str, beg, len); return tmp; } } @@ -1539,12 +758,12 @@ num_index: static mrb_value mrb_str_aref_m(mrb_state *mrb, mrb_value str) { + mrb_value a1, a2; int argc; - mrb_value *argv; - mrb_get_args(mrb, "*", &argv, &argc); + argc = mrb_get_args(mrb, "o|o", &a1, &a2); if (argc == 2) { - if (mrb_type(argv[0]) == MRB_TT_REGEX) { + if (mrb_type(a1) == MRB_TT_REGEX) { #ifdef INCLUDE_REGEXP return mrb_str_subpat(mrb, str, argv[0], mrb_fixnum(argv[1])); #else @@ -1552,38 +771,14 @@ mrb_str_aref_m(mrb_state *mrb, mrb_value str) return mrb_nil_value(); #endif //INCLUDE_REGEXP } - return mrb_str_substr(mrb, str, mrb_fixnum(argv[0]), mrb_fixnum(argv[1])); + return mrb_str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2)); } if (argc != 1) { mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1)", argc); } - return mrb_str_aref(mrb, str, argv[0]); + return mrb_str_aref(mrb, str, a1); } -#ifdef INCLUDE_ENCODING -/* As mrb_str_modify(), but don't clear coderange */ -static void -str_modify_keep_cr(mrb_state *mrb, mrb_value str) -{ - if (!str_independent(str)) - str_make_independent(mrb, str); - if (ENC_CODERANGE(str) == ENC_CODERANGE_BROKEN) - /* Force re-scan later */ - ENC_CODERANGE_CLEAR(str); -} - -static void -mrb_str_check_dummy_enc(mrb_state *mrb, mrb_encoding *enc) -{ - if (mrb_enc_dummy_p(enc)) { - mrb_raise(mrb, E_ENCODING_ERROR, "incompatible encoding with this operation: %s", - mrb_enc_name(enc)); - } -} -#else -#define str_modify_keep_cr(mrb, str) mrb_str_modify((mrb), (str)) -#endif //INCLUDE_ENCODING - /* 15.2.10.5.8 */ /* * call-seq: @@ -1600,51 +795,6 @@ mrb_str_check_dummy_enc(mrb_state *mrb, mrb_encoding *enc) static mrb_value mrb_str_capitalize_bang(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING - char *s, *send; - int modify = 0; -#ifdef INCLUDE_ENCODING - unsigned int c; - int n; -#endif //INCLUDE_ENCODING - - str_modify_keep_cr(mrb, str); -#ifdef INCLUDE_ENCODING - enc = STR_ENC_GET(mrb, str); - mrb_str_check_dummy_enc(mrb, enc); -#endif //INCLUDE_ENCODING - if (RSTRING_LEN(str) == 0 || !RSTRING_PTR(str)) return mrb_nil_value(); - s = RSTRING_PTR(str); send = RSTRING_END(str); -#ifdef INCLUDE_ENCODING - c = mrb_enc_codepoint_len(mrb, s, send, &n, enc); - if (mrb_enc_islower(c, enc)) { - mrb_enc_mbcput(mrb_enc_toupper(c, enc), s, enc); - modify = 1; - } - s += n; - while (s < send) { - c = mrb_enc_codepoint_len(mrb, s, send, &n, enc); - if (mrb_enc_isupper(c, enc)) { - mrb_enc_mbcput(mrb_enc_tolower(c, enc), s, enc); - modify = 1; - } - s += n; - } -#else - if (ISLOWER(*s)) { - *s = toupper(*s); - modify = 1; - } - while (++s < send) { - if (ISUPPER(*s)) { - *s = tolower(*s); - modify = 1; - } - } -#endif //INCLUDE_ENCODING - if (modify) return str; return mrb_nil_value(); } @@ -1681,113 +831,6 @@ mrb_str_capitalize(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_chomp_bang(mrb_state *mrb, mrb_value str) { - mrb_value *argv; - int argc; -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING - mrb_value rs; - mrb_int newline; - char *p, *pp, *e; - long len, rslen; - - str_modify_keep_cr(mrb, str); - len = RSTRING_LEN(str); - if (len == 0) return mrb_nil_value(); - p = RSTRING_PTR(str); - e = p + len; - //if (mrb_scan_args(argc, argv, "01", &rs) == 0) { - mrb_get_args(mrb, "*", &argv, &argc); - if (argc == 0) { - rs = mrb_str_new2(mrb, "\n"); -smart_chomp: -#ifdef INCLUDE_ENCODING - enc = mrb_enc_get(mrb, str); - if (mrb_enc_mbminlen(enc) > 1) { - pp = mrb_enc_left_char_head(p, e-mrb_enc_mbminlen(enc), e, enc); - if (mrb_enc_is_newline(pp, e, enc)) { - e = pp; - } - pp = e - mrb_enc_mbminlen(enc); - if (pp >= p) { - pp = mrb_enc_left_char_head(p, pp, e, enc); - if (mrb_enc_ascget(mrb, pp, e, 0, enc) == '\r') { - e = pp; - } - } - if (e == RSTRING_END(str)) { - return mrb_nil_value(); - } - len = e - RSTRING_PTR(str); - STR_SET_LEN(str, len); - } - else { -#endif //INCLUDE_ENCODING - 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 mrb_nil_value(); - } -#ifdef INCLUDE_ENCODING - } -#endif //INCLUDE_ENCODING - RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; - return str; - } - rs = argv[0]; - if (mrb_nil_p(rs)) return mrb_nil_value(); - //StringValue(rs); - mrb_string_value(mrb, &rs); - 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)) { - STR_SET_LEN(str, len); - RSTRING_PTR(str)[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') - goto smart_chomp; - -#ifdef INCLUDE_ENCODING - enc = mrb_enc_check(mrb, str, rs); - if (is_broken_string(mrb, rs)) { - return mrb_nil_value(); - } - pp = e - rslen; -#else - pp = p + len - rslen; -#endif //INCLUDE_ENCODING - if (p[len-1] == newline && - (rslen <= 1 || - memcmp(RSTRING_PTR(rs), pp, rslen) == 0)) { -#ifdef INCLUDE_ENCODING - if (mrb_enc_left_char_head(p, pp, e, enc) != pp) - return mrb_nil_value(); - if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) { - ENC_CODERANGE_CLEAR(str); - } -#endif //INCLUDE_ENCODING - STR_SET_LEN(str, RSTRING_LEN(str) - rslen); - RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0'; - return str; - } return mrb_nil_value(); } @@ -1820,26 +863,6 @@ mrb_str_chomp(mrb_state *mrb, mrb_value self) return str; } -#ifdef INCLUDE_ENCODING -static long -chopped_length(mrb_state *mrb, mrb_value str) -{ - mrb_encoding *enc = STR_ENC_GET(mrb, str); - const char *p, *p2, *beg, *end; - - beg = RSTRING_PTR(str); - end = beg + RSTRING_LEN(str); - if (beg > end) return 0; - p = mrb_enc_prev_char(beg, end, end, enc); - if (!p) return 0; - if (p > beg && mrb_enc_ascget(mrb, p, end, 0, enc) == '\n') { - p2 = mrb_enc_prev_char(beg, p, end, enc); - if (p2 && mrb_enc_ascget(mrb, p2, end, 0, enc) == '\r') p = p2; - } - return p - beg; -} -#endif //INCLUDE_ENCODING - /* 15.2.10.5.12 */ /* * call-seq: @@ -1852,12 +875,7 @@ chopped_length(mrb_state *mrb, mrb_value str) static mrb_value mrb_str_chop_bang(mrb_state *mrb, mrb_value str) { - str_modify_keep_cr(mrb, str); if (RSTRING_LEN(str) > 0) { -#ifdef INCLUDE_ENCODING - long len; - len = chopped_length(mrb, str); -#else size_t len; len = RSTRING_LEN(str) - 1; if (RSTRING_PTR(str)[len] == '\n') { @@ -1866,14 +884,8 @@ mrb_str_chop_bang(mrb_state *mrb, mrb_value str) len--; } } -#endif //INCLUDE_ENCODING STR_SET_LEN(str, len); RSTRING_PTR(str)[len] = '\0'; -#ifdef INCLUDE_ENCODING - if (ENC_CODERANGE(str) != ENC_CODERANGE_7BIT) { - ENC_CODERANGE_CLEAR(str); - } -#endif //INCLUDE_ENCODING return str; } return mrb_nil_value(); @@ -1900,13 +912,8 @@ static mrb_value mrb_str_chop(mrb_state *mrb, mrb_value self) { mrb_value str; -#ifdef INCLUDE_ENCODING - str = mrb_str_new5(mrb, self, RSTRING_PTR(self), chopped_length(mrb, self)); - mrb_enc_cr_str_copy_for_substr(mrb, str, self); -#else str = mrb_str_dup(mrb, self); mrb_str_chop_bang(mrb, str); -#endif //INCLUDE_ENCODING return str; } @@ -1921,63 +928,6 @@ mrb_str_chop(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_downcase_bang(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING - char *s, *send; - int modify = 0; - - str_modify_keep_cr(mrb, str); -#ifdef INCLUDE_ENCODING - enc = STR_ENC_GET(mrb, str); - mrb_str_check_dummy_enc(mrb, enc); -#endif //INCLUDE_ENCODING - s = RSTRING_PTR(str); send = RSTRING_END(str); -#ifdef INCLUDE_ENCODING - if (single_byte_optimizable(mrb, str)) { -#endif //INCLUDE_ENCODING - while (s < send) { - unsigned int c = *(unsigned char*)s; - -#ifdef INCLUDE_ENCODING - if (mrb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') { -#else - if ('A' <= c && c <= 'Z') { -#endif //INCLUDE_ENCODING - *s = 'a' + (c - 'A'); - modify = 1; - } - s++; - } -#ifdef INCLUDE_ENCODING - } - else { - int ascompat = mrb_enc_asciicompat(mrb, enc); - - while (s < send) { - unsigned int c; - int n; - - if (ascompat && (c = *(unsigned char*)s) < 0x80) { - if (mrb_enc_isascii(c, enc) && 'A' <= c && c <= 'Z') { - *s = 'a' + (c - 'A'); - modify = 1; - } - s++; - } - else { - c = mrb_enc_codepoint_len(mrb, s, send, &n, enc); - if (mrb_enc_isupper(c, enc)) { - /* assuming toupper returns codepoint with same size */ - mrb_enc_mbcput(mrb_enc_tolower(c, enc), s, enc); - modify = 1; - } - s += n; - } - } - } -#endif //INCLUDE_ENCODING - if (modify) return str; return mrb_nil_value(); } @@ -2037,62 +987,7 @@ mrb_str_downcase(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_each_line(mrb_state *mrb, mrb_value str) { - mrb_value rs; - int newline; - struct RString *ps = mrb_str_ptr(str); - char *p = ps->buf, *pend = p + ps->len, *s; - char *ptr = p; - long len = ps->len, rslen; - mrb_value line; - struct RString *prs; - mrb_value *argv, b; - int argc; - - //if (mrb_scan_args(argc, argv, "01", &rs) == 0) { - mrb_get_args(mrb, "*&", &argv, &argc, &b); - if (argc > 0) { - rs = argv[0]; - } else { - rs = mrb_str_new2(mrb, "\n"); - } - /*RETURN_ENUMERATOR(str, argc, argv);*/ - if (mrb_nil_p(rs)) { - mrb_yield(mrb, b, str); - return str; - } - //StringValue(rs); - mrb_string_value(mrb, &rs); - prs = mrb_str_ptr(rs); - rslen = prs->len; - if (rslen == 0) { - newline = '\n'; - } - else { - newline = prs->buf[rslen-1]; - } - - for (s = p, p += rslen; p < pend; p++) { - if (rslen == 0 && *p == '\n') { - if (*++p != '\n') continue; - while (*p == '\n') p++; - } - if (ps->buf < p && p[-1] == newline && - (rslen <= 1 || - memcmp(prs->buf, p-rslen, rslen) == 0)) { - line = mrb_str_new5(mrb, str, s, p - s); - mrb_yield(mrb, b, line); - str_mod_check(mrb, str, ptr, len); - s = p; - } - } - - if (s != pend) { - if (p > pend) p = pend; - line = mrb_str_new5(mrb, str, s, p - s); - mrb_yield(mrb, b, line); - } - - return str; + return mrb_nil_value(); } /* 15.2.10.5.16 */ @@ -2106,7 +1001,7 @@ mrb_str_each_line(mrb_state *mrb, mrb_value str) * "".empty? #=> true */ static mrb_value -mrb_str_empty(mrb_state *mrb, mrb_value self) +mrb_str_empty_p(mrb_state *mrb, mrb_value self) { struct RString *s = mrb_str_ptr(self); @@ -2135,265 +1030,63 @@ mrb_str_eql(mrb_state *mrb, mrb_value self) return mrb_false_value(); } -#ifdef INCLUDE_ENCODING -static void -mrb_enc_cr_str_copy_for_substr(mrb_state *mrb, mrb_value dest, mrb_value src) -{ - /* this function is designed for copying encoding and coderange - * from src to new string "dest" which is made from the part of src. - */ - str_enc_copy(mrb, dest, src); - switch (ENC_CODERANGE(src)) { - case ENC_CODERANGE_7BIT: - ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); - break; - case ENC_CODERANGE_VALID: - if (!mrb_enc_asciicompat(mrb, STR_ENC_GET(mrb, src)) || - search_nonascii(RSTRING_PTR(dest), RSTRING_END(dest))) - ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID); - else - ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); - break; - default: - if (RSTRING_LEN(dest) == 0) { - if (!mrb_enc_asciicompat(mrb, STR_ENC_GET(mrb, src))) - ENC_CODERANGE_SET(dest, ENC_CODERANGE_VALID); - else - ENC_CODERANGE_SET(dest, ENC_CODERANGE_7BIT); - } - break; - } -} -#endif //INCLUDE_ENCODING - -static mrb_value -str_replace_shared(mrb_state *mrb, mrb_value str2, mrb_value str) -{ - str = mrb_str_new_frozen(mrb, str); - RSTRING(str2)->len = RSTRING_LEN(str); - RSTRING(str2)->buf = RSTRING_PTR(str); - RSTRING_SHARED(str2) = mrb_str_ptr(str); - FL_SET(str2, MRB_STR_SHARED); - mrb_enc_cr_str_exact_copy(mrb, str2, str); - - return str2; -} - -static mrb_value -str_new_shared(mrb_state *mrb, struct RClass* klass, mrb_value str) -{ - return str_replace_shared(mrb, str_alloc(mrb), str); -} - -mrb_value -str_new3(mrb_state *mrb, struct RClass* klass, mrb_value str) -{ - return str_new_shared(mrb, klass, str); -} - -mrb_value -mrb_str_new_shared(mrb_state *mrb, mrb_value str) -{ - mrb_value str2 = str_new3(mrb, mrb_obj_class(mrb, str), str); - - return str2; -} - mrb_value mrb_str_new_frozen(mrb_state *mrb, mrb_value orig) { - struct RClass* klass; - mrb_value str; - - klass = mrb_obj_class(mrb, orig); - - if (MRB_STR_SHARED_P(orig) && RSTRING_SHARED(orig)) { - long ofs; - ofs = RSTRING_LEN(str) - RSTRING_SHARED(orig)->len; -#ifdef INCLUDE_ENCODING - if ((ofs > 0) || (klass != RBASIC(str)->c) || - ENCODING_GET(mrb, str) != ENCODING_GET(mrb, orig)) { -#else - if ((ofs > 0) || (klass != RBASIC(str)->c)) { -#endif //INCLUDE_ENCODING - str = str_new3(mrb, klass, str); - RSTRING_PTR(str) += ofs; - RSTRING_LEN(str) -= ofs; - mrb_enc_cr_str_exact_copy(mrb, str, orig); - } - } - else { - str = str_new4(mrb, orig); - } - return str; -} - -mrb_value -mrb_str_drop_bytes(mrb_state *mrb, mrb_value str, long len) -{ - char *ptr = RSTRING_PTR(str); - long olen = RSTRING_LEN(str), nlen; - - str_modifiable(str); - if (len > olen) len = olen; - nlen = olen - len; - if (!MRB_STR_SHARED_P(str)) mrb_str_new4(mrb, str); - ptr = RSTRING(str)->buf += len; - RSTRING(str)->len = nlen; - ptr[nlen] = 0; - //ENC_CODERANGE_CLEAR(str); - return str; + return str_dup(mrb, orig); } mrb_value mrb_str_subseq(mrb_state *mrb, mrb_value str, long beg, long len) { mrb_value str2; - if (RSTRING_LEN(str) == beg + len && - STR_BUF_MIN_SIZE < len) { - str2 = mrb_str_new_shared(mrb, mrb_str_new_frozen(mrb, str)); - mrb_str_drop_bytes(mrb, str2, beg); - } - else { - str2 = mrb_str_new5(mrb, str, RSTRING_PTR(str)+beg, len); - } - mrb_enc_cr_str_copy_for_substr(mrb, str2, str); + str2 = mrb_str_new_with_class(mrb, str, RSTRING_PTR(str)+beg, len); return str2; } -#ifdef INCLUDE_ENCODING -int -mrb_enc_str_asciionly_p(mrb_state *mrb, mrb_value str) +mrb_value +mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, int len) { - mrb_encoding *enc = STR_ENC_GET(mrb, str); - - if (!mrb_enc_asciicompat(mrb, enc)) - return 0/*FALSE*/; - else if (mrb_enc_str_coderange(mrb, str) == ENC_CODERANGE_7BIT) - return 1/*TRUE*/; - return 0/*FALSE*/; -} + mrb_value str2; + char *p, *s = RSTRING_PTR(str); -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) -{ - int str_encindex = ENCODING_GET(mrb, str); - int res_encindex; - int str_cr, res_cr; - int str_a8 = ENCODING_IS_ASCII8BIT(str); - int ptr_a8 = ptr_encindex == 0; - - str_cr = ENC_CODERANGE(str); - - if (str_encindex == ptr_encindex) { - if (str_cr == ENC_CODERANGE_UNKNOWN || - (ptr_a8 && str_cr != ENC_CODERANGE_7BIT)) { - ptr_cr = ENC_CODERANGE_UNKNOWN; - } - else if (ptr_cr == ENC_CODERANGE_UNKNOWN) { - ptr_cr = coderange_scan(ptr, len, mrb_enc_from_index(mrb, ptr_encindex)); - } + if (len < 0) return mrb_nil_value(); + if (!RSTRING_LEN(str)) { + len = 0; } - else { - mrb_encoding *str_enc = mrb_enc_from_index(mrb, str_encindex); - mrb_encoding *ptr_enc = mrb_enc_from_index(mrb, ptr_encindex); - if (!mrb_enc_asciicompat(mrb, str_enc) || !mrb_enc_asciicompat(mrb, ptr_enc)) { - if (len == 0) - return str; - if (RSTRING_LEN(str) == 0) { - mrb_str_buf_cat(mrb, str, ptr, len); - ENCODING_CODERANGE_SET(mrb, str, ptr_encindex, ptr_cr); - return str; - } - goto incompatible; - } - if (ptr_cr == ENC_CODERANGE_UNKNOWN) { - ptr_cr = coderange_scan(ptr, len, ptr_enc); - } - if (str_cr == ENC_CODERANGE_UNKNOWN) { - if (str_a8 || ptr_cr != ENC_CODERANGE_7BIT) { - str_cr = mrb_enc_str_coderange(mrb, str); - } - } + if (beg > RSTRING_LEN(str)) return mrb_nil_value(); + if (beg < 0) { + beg += RSTRING_LEN(str); + if (beg < 0) return mrb_nil_value(); } - if (ptr_cr_ret) - *ptr_cr_ret = ptr_cr; - - if (str_encindex != ptr_encindex && - str_cr != ENC_CODERANGE_7BIT && - ptr_cr != ENC_CODERANGE_7BIT) { -incompatible: - mrb_raise(mrb, E_ENCODING_ERROR, "incompatible character encodings: %s and %s", - mrb_enc_name(mrb_enc_from_index(mrb, str_encindex)), - mrb_enc_name(mrb_enc_from_index(mrb, ptr_encindex))); + if (beg + len > RSTRING_LEN(str)) + len = RSTRING_LEN(str) - beg; + if (len <= 0) { + len = 0; + p = 0; } + else + p = s + beg; - if (str_cr == ENC_CODERANGE_UNKNOWN) { - res_encindex = str_encindex; - res_cr = ENC_CODERANGE_UNKNOWN; - } - else if (str_cr == ENC_CODERANGE_7BIT) { - if (ptr_cr == ENC_CODERANGE_7BIT) { - res_encindex = !str_a8 ? str_encindex : ptr_encindex; - res_cr = ENC_CODERANGE_7BIT; - } - else { - res_encindex = ptr_encindex; - res_cr = ptr_cr; - } - } - else if (str_cr == ENC_CODERANGE_VALID) { - res_encindex = str_encindex; - if (ptr_cr == ENC_CODERANGE_7BIT || ptr_cr == ENC_CODERANGE_VALID) - res_cr = str_cr; - else - res_cr = ptr_cr; + if (len > STR_BUF_MIN_SIZE && beg + len == RSTRING_LEN(str)) { + str2 = mrb_str_new(mrb, s, RSTRING_LEN(str)); + RSTRING(str2)->buf += RSTRING(str2)->len - len; + RSTRING(str2)->len = len; } - else { /* str_cr == ENC_CODERANGE_BROKEN */ - res_encindex = str_encindex; - res_cr = str_cr; - if (0 < len) res_cr = ENC_CODERANGE_UNKNOWN; + else { + str2 = mrb_str_new_with_class(mrb, str, p, len); } - if (len < 0) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)"); - } - str_buf_cat(mrb, str, ptr, len); - ENCODING_CODERANGE_SET(mrb, str, res_encindex, res_cr); - return str; -} - -mrb_value -mrb_enc_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len, mrb_encoding *ptr_enc) -{ - return mrb_enc_cr_str_buf_cat(mrb, str, ptr, len, - mrb_enc_to_index(ptr_enc), ENC_CODERANGE_UNKNOWN, NULL); + return str2; } mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2) { - int str2_cr; - - str2_cr = ENC_CODERANGE(str2); - - mrb_enc_cr_str_buf_cat(mrb, str, RSTRING_PTR(str2), RSTRING_LEN(str2), - ENCODING_GET(mrb, str2), str2_cr, &str2_cr); - - ENC_CODERANGE_SET(str2, str2_cr); - - return str; -} -#else -mrb_value -mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2) -{ mrb_str_cat(mrb, str, RSTRING_PTR(str2), RSTRING_LEN(str2)); return str; } -#endif //INCLUDE_ENCODING static inline void str_discard(mrb_state *mrb, mrb_value str) @@ -2406,38 +1099,6 @@ str_discard(mrb_state *mrb, mrb_value str) } } -void -mrb_str_shared_replace(mrb_state *mrb, mrb_value str, mrb_value str2) -{ -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; - int cr; -#endif //INCLUDE_ENCODING - - if (mrb_obj_equal(mrb, str, str2)) return; -#ifdef INCLUDE_ENCODING - enc = STR_ENC_GET(mrb, str2); - cr = ENC_CODERANGE(str2); -#endif //INCLUDE_ENCODING - str_discard(mrb, str); - MRB_STR_UNSET_NOCAPA(str); - RSTRING_PTR(str) = RSTRING_PTR(str2); - RSTRING_LEN(str) = RSTRING_LEN(str2); - if (MRB_STR_NOCAPA_P(str2)) { - FL_SET(str, RBASIC(str2)->flags & MRB_STR_NOCAPA); - RSTRING_SHARED(str) = RSTRING_SHARED(str2); - } - else { - RSTRING_CAPA(str) = RSTRING_CAPA(str2); - } - - MRB_STR_UNSET_NOCAPA(str2); /* abandon str2 */ - RSTRING_PTR(str2)[0] = 0; - RSTRING_LEN(str2) = 0; - mrb_enc_associate(mrb, str, enc); - ENC_CODERANGE_SET(str, cr); -} - #ifdef INCLUDE_REGEXP static mrb_value str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) @@ -2450,7 +1111,6 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) mrb_int beg0, end0; mrb_int offset, blen, len, last; char *sp, *cp; - mrb_encoding *str_enc; mrb_get_args(mrb, "*", &argv, &argc); switch (argc) { @@ -2478,7 +1138,6 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) dest = mrb_str_buf_new(mrb, blen); sp = RSTRING_PTR(str); cp = sp; - str_enc = STR_ENC_GET(mrb, str); do { n++; @@ -2490,7 +1149,7 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) len = beg - offset; /* copy pre-match substr */ if (len) { - mrb_enc_str_buf_cat(mrb, dest, cp, len, str_enc); + mrb_str_buf_cat(mrb, dest, cp, len); } mrb_str_buf_append(mrb, dest, val); @@ -2503,8 +1162,8 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) * in order to prevent infinite loops. */ if (RSTRING_LEN(str) <= end0) break; - len = mrb_enc_fast_mbclen(RSTRING_PTR(str)+end0, RSTRING_END(str), str_enc); - mrb_enc_str_buf_cat(mrb, dest, RSTRING_PTR(str)+end0, len, str_enc); + len = RSTRING_LEN(str)-end0; + mrb_str_buf_cat(mrb, dest, RSTRING_PTR(str)+end0, len); offset = end0 + len; } cp = RSTRING_PTR(str) + offset; @@ -2512,17 +1171,10 @@ str_gsub(mrb_state *mrb, mrb_value str, mrb_int bang) beg = mrb_reg_search(mrb, pat, str, offset, 0); } while (beg >= 0); if (RSTRING_LEN(str) > offset) { - mrb_enc_str_buf_cat(mrb, dest, cp, RSTRING_LEN(str) - offset, str_enc); + mrb_str_buf_cat(mrb, dest, cp, RSTRING_LEN(str) - offset); } mrb_reg_search(mrb, pat, str, last, 0); - if (bang) { - mrb_str_shared_replace(mrb, str, dest); - } - else { - RBASIC(dest)->c = mrb_obj_class(mrb, str); - str = dest; - } - + RBASIC(dest)->c = mrb_obj_class(mrb, str); return str; } @@ -2578,7 +1230,6 @@ mrb_str_gsub(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_gsub_bang(mrb_state *mrb, mrb_value self) { - str_modify_keep_cr(mrb, self); //return str_gsub(argc, argv, self, 1); return str_gsub(mrb, self, 1); } @@ -2694,18 +1345,10 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) } if (pos < 0) { -#ifdef INCLUDE_ENCODING - pos += str_strlen(mrb, str, STR_ENC_GET(mrb, str)); -#else pos += RSTRING_LEN(str); -#endif //INCLUDE_ENCODING if (pos < 0) { if (mrb_type(sub) == MRB_TT_REGEX) { -#ifdef INCLUDE_REGEXP - mrb_backref_set(mrb, mrb_nil_value()); -#else - mrb_raise(mrb, E_TYPE_ERROR, "Regexp Class not supported"); -#endif //INCLUDE_REGEXP + mrb_raise(mrb, E_TYPE_ERROR, "Regexp class not supported"); } return mrb_nil_value(); } @@ -2714,11 +1357,9 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_REGEX: #ifdef INCLUDE_REGEXP - if (pos > str_strlen(mrb, str, STR_ENC_GET(mrb, str))) + if (pos > RSTRING_LEN(str)) return mrb_nil_value(); - pos = str_offset(mrb, RSTRING_PTR(str), RSTRING_END(str), pos, - mrb_enc_check(mrb, str, sub), single_byte_optimizable(mrb, str)); - + pos = mrb_str_offset(mrb, str, pos); pos = mrb_reg_search(mrb, sub, str, pos, 0); pos = mrb_str_sublen(mrb, str, pos); #else @@ -2750,9 +1391,6 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) /* fall through */ case MRB_TT_STRING: pos = mrb_str_index(mrb, str, sub, pos); -#ifdef INCLUDE_ENCODING - pos = mrb_str_sublen(mrb, str, pos); -#endif //INCLUDE_ENCODING break; } @@ -2763,22 +1401,7 @@ mrb_str_index_m(mrb_state *mrb, mrb_value str) static mrb_value str_replace(mrb_state *mrb, mrb_value str, mrb_value str2) { - long len; - - len = RSTRING_LEN(str2); - if (MRB_STR_SHARED_P(str2)) { - struct RString *shared = RSTRING_SHARED(str2); - RSTRING_LEN(str) = len; - RSTRING_PTR(str) = shared->buf; - FL_SET(str, MRB_STR_SHARED); - RSTRING_SHARED(str) = shared; - } - else { - str_replace_shared(mrb, str, str2); - } - - mrb_enc_cr_str_exact_copy(mrb, str, str2); - return str; + return mrb_nil_value(); } /* 15.2.10.5.24 */ @@ -2825,33 +1448,10 @@ mrb_str_init(mrb_state *mrb, mrb_value self) return self; } -#ifdef INCLUDE_ENCODING -mrb_sym -mrb_intern3(mrb_state *mrb, const char *name, long len, mrb_encoding *enc) -{ - return mrb_intern(mrb, name); -} -#endif //INCLUDE_ENCODING - mrb_sym mrb_intern_str(mrb_state *mrb, mrb_value str) { - mrb_sym id; -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; - - if (mrb_enc_str_coderange(mrb, str) == ENC_CODERANGE_7BIT) { - enc = mrb_usascii_encoding(mrb); - } - else { - enc = mrb_enc_get(mrb, str); - } - id = mrb_intern3(mrb, RSTRING_PTR(str), RSTRING_LEN(str), enc); -#else - id = mrb_intern(mrb, RSTRING_PTR(str)); -#endif //INCLUDE_ENCODING - str = RB_GC_GUARD(str); - return id; + return mrb_intern(mrb, RSTRING_PTR(str)); } /* 15.2.10.5.25 */ @@ -2984,66 +1584,19 @@ mrb_str_match_m(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_reverse(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING - mrb_value rev; - char *s, *e, *p; -#ifdef INCLUDE_ENCODING - int single = 1; -#endif //INCLUDE_ENCODING + mrb_value obj; + char *s, *e, *p; - if (RSTRING_LEN(str) <= 1) return mrb_str_dup(mrb, str); -#ifdef INCLUDE_ENCODING - enc = STR_ENC_GET(mrb, str); -#endif //INCLUDE_ENCODING - rev = mrb_str_new5(mrb, str, 0, RSTRING_LEN(str)); - s = RSTRING_PTR(str); e = RSTRING_END(str); - p = RSTRING_END(rev); + if (RSTRING(str)->len <= 1) return str_dup(mrb, str); - if (RSTRING_LEN(str) > 1) { -#ifdef INCLUDE_ENCODING - if (single_byte_optimizable(mrb, str)) { -#endif //INCLUDE_ENCODING - while (s < e) { - *--p = *s++; - } -#ifdef INCLUDE_ENCODING - } - else if (ENC_CODERANGE(str) == ENC_CODERANGE_VALID) { - while (s < e) { - int clen = mrb_enc_fast_mbclen(s, e, enc); - - if (clen > 1 || (*s & 0x80)) single = 0; - p -= clen; - memcpy(p, s, clen); - s += clen; - } - } - else { - while (s < e) { - int clen = mrb_enc_mbclen(s, e, enc); + obj = mrb_str_new_with_class(mrb, str, 0, RSTRING(str)->len); + s = RSTRING(str)->buf; e = s + RSTRING(str)->len - 1; + p = RSTRING(obj)->buf; - if (clen > 1 || (*s & 0x80)) single = 0; - p -= clen; - memcpy(p, s, clen); - s += clen; - } - } - } - STR_SET_LEN(rev, RSTRING_LEN(str)); - if (ENC_CODERANGE(str) == ENC_CODERANGE_UNKNOWN) { - if (single) { - ENC_CODERANGE_SET(str, ENC_CODERANGE_7BIT); - } - else { - ENC_CODERANGE_SET(str, ENC_CODERANGE_VALID); - } -#endif //INCLUDE_ENCODING - } - mrb_enc_cr_str_copy_for_substr(mrb, rev, str); - - return rev; + while (e >= s) { + *p++ = *e--; + } + return obj; } /* 15.2.10.5.30 */ @@ -3056,29 +1609,18 @@ mrb_str_reverse(mrb_state *mrb, mrb_value str) static mrb_value mrb_str_reverse_bang(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - if (RSTRING_LEN(str) > 1) { - if (single_byte_optimizable(mrb, str)) { -#endif //INCLUDE_ENCODING - char *s, *e, c; - str_modify_keep_cr(mrb, str); - s = RSTRING_PTR(str); - e = RSTRING_END(str) - 1; - while (s < e) { - c = *s; - *s++ = *e; - *e-- = c; - } -#ifdef INCLUDE_ENCODING - } - else { - mrb_str_shared_replace(mrb, str, mrb_str_reverse(mrb, str)); + char *s, *e; + char c; + + if (RSTRING(str)->len > 1) { + s = RSTRING(str)->buf; + e = s + RSTRING(str)->len - 1; + while (s < e) { + c = *s; + *s++ = *e; + *e-- = c; } } - else { - str_modify_keep_cr(mrb, str); - } -#endif //INCLUDE_ENCODING return str; } @@ -3135,12 +1677,7 @@ mrb_str_rindex(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int pos) size_t mrb_str_sublen(mrb_state *mrb, mrb_value str, long pos) { - if (single_byte_optimizable(mrb, str) || pos < 0) - return pos; - else { - char *p = RSTRING_PTR(str); - return enc_strlen(p, p + pos, STR_ENC_GET(mrb, str), ENC_CODERANGE(str)); - } + return pos; } #endif //INCLUDE_ENCODING @@ -3170,14 +1707,8 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) int argc; mrb_value sub; mrb_value vpos; -#ifdef INCLUDE_ENCODING - mrb_encoding *enc = STR_ENC_GET(mrb, str); - int pos, len = str_strlen(mrb, str, enc); -#else int pos, len = RSTRING_LEN(str); -#endif //INCLUDE_ENCODING - //if (mrb_scan_args(argc, argv, "11", &sub, &vpos) == 2) { mrb_get_args(mrb, "*", &argv, &argc); if (argc == 2) { sub = argv[0]; @@ -3209,9 +1740,7 @@ mrb_str_rindex_m(mrb_state *mrb, mrb_value str) switch (mrb_type(sub)) { case MRB_TT_REGEX: #ifdef INCLUDE_REGEXP - pos = str_offset(mrb, RSTRING_PTR(str), RSTRING_END(str), pos, - STR_ENC_GET(mrb, str), single_byte_optimizable(mrb, str)); - + pos = mrb_str_offset(mrb, str, pos); if (!RREGEXP(sub)->ptr || RREGEXP_SRC_LEN(sub)) { pos = mrb_reg_search(mrb, sub, str, pos, 1); pos = mrb_str_sublen(mrb, str, pos); @@ -3269,12 +1798,11 @@ scan_once(mrb_state *mrb, mrb_value str, mrb_value pat, mrb_int *start) pmatch = mrb_match_ptr(match); regs = &pmatch->rmatch->regs; if (regs->beg[0] == regs->end[0]) { - mrb_encoding *enc = STR_ENC_GET(mrb, str); /* * Always consume at least one character of the input string */ if (ps->len > regs->end[0]) - *start = regs->end[0] + mrb_enc_fast_mbclen(RSTRING_PTR(str)+regs->end[0],RSTRING_END(str), enc); + *start = regs->end[0] + RSTRING_LEN(str)-regs->end[0]; else *start = regs->end[0] + 1; } @@ -3426,16 +1954,11 @@ static const char isspacetable[256] = { * "1,2,,3,4,,".split(',', -4) #=> ["1", "2", "", "3", "4", "", ""] */ -//static mrb_value -//mrb_str_split_m(int argc, mrb_value *argv, mrb_value str) static mrb_value mrb_str_split_m(mrb_state *mrb, mrb_value str) { mrb_value *argv; int argc; -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING mrb_value spat; mrb_value limit; enum {awk, string, regexp} split_type; @@ -3462,21 +1985,12 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) i = 1; } -#ifdef INCLUDE_ENCODING - enc = STR_ENC_GET(mrb, str); -#endif //INCLUDE_ENCODING - //if (mrb_nil_p(spat)) { if (argc == 0) { -// spat = mrb_nil_value(); -// goto fs_set; split_type = awk; } else { //fs_set: if (mrb_type(spat) == MRB_TT_STRING) { -#ifdef INCLUDE_REGEXP - mrb_encoding *enc2 = STR_ENC_GET(mrb, spat); -#endif //INCLUDE_REGEXP split_type = string; #ifdef INCLUDE_REGEXP if (RSTRING_LEN(spat) == 0) { @@ -3484,20 +1998,13 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) spat = mrb_reg_regcomp(mrb, spat); split_type = regexp; } - else if (mrb_enc_asciicompat(mrb, enc2) == 1) { + else { #endif //INCLUDE_REGEXP if (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){ split_type = awk; } #ifdef INCLUDE_REGEXP } - else { - int l; - if (mrb_enc_ascget(mrb, RSTRING_PTR(spat), RSTRING_END(spat), &l, enc2) == ' ' && - RSTRING_LEN(spat) == l) { - split_type = awk; - } - } #endif //INCLUDE_REGEXP } else { @@ -3520,89 +2027,28 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) unsigned int c; end = beg; -#ifdef INCLUDE_ENCODING - if (is_ascii_string(mrb, str)) { -#endif //INCLUDE_ENCODING - while (ptr < eptr) { - c = (unsigned char)*ptr++; - if (skip) { - if (ascii_isspace(c)) { - beg = ptr - bptr; - } - else { - end = ptr - bptr; - skip = 0; - if (!mrb_nil_p(limit) && lim <= i) break; - } - } - else if (ascii_isspace(c)) { - mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, end-beg)); - skip = 1; - beg = ptr - bptr; - if (!mrb_nil_p(limit)) ++i; - } - else { - end = ptr - bptr; - } - } -#ifdef INCLUDE_ENCODING - } - else { - while (ptr < eptr) { - int n; - - c = mrb_enc_codepoint_len(mrb, ptr, eptr, &n, enc); - ptr += n; - if (skip) { - if (mrb_isspace(c)) { - beg = ptr - bptr; - } - else { - end = ptr - bptr; - skip = 0; - if (!mrb_nil_p(limit) && lim <= i) break; - } - } - else if (mrb_isspace(c)) { - mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, end-beg)); - skip = 1; - beg = ptr - bptr; - if (!mrb_nil_p(limit)) ++i; - } - else { - end = ptr - bptr; - } + while (ptr < eptr) { + c = (unsigned char)*ptr++; + if (skip) { + if (ascii_isspace(c)) { + beg = ptr - bptr; + } + else { + end = ptr - bptr; + skip = 0; + if (!mrb_nil_p(limit) && lim <= i) break; + } + } + else if (ascii_isspace(c)) { + mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, end-beg)); + skip = 1; + beg = ptr - bptr; + if (!mrb_nil_p(limit)) ++i; } - } - } - else if (split_type == string) { - char *ptr = RSTRING_PTR(str); - char *temp = ptr; - char *eptr = RSTRING_END(str); - char *sptr = RSTRING_PTR(spat); - long slen = RSTRING_LEN(spat); - - if (is_broken_string(mrb, str)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid byte sequence in %s", mrb_enc_name(STR_ENC_GET(mrb, str))); - } - if (is_broken_string(mrb, spat)) { - mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid byte sequence in %s", mrb_enc_name(STR_ENC_GET(mrb, spat))); - } - enc = mrb_enc_check(mrb, str, spat); - while (ptr < eptr && - (end = mrb_memsearch(mrb, sptr, slen, ptr, eptr - ptr, enc)) >= 0) { - /* Check we are at the start of a char */ - char *t = mrb_enc_right_char_head(ptr, ptr + end, eptr, enc); - if (t != ptr + end) { - ptr = t; - continue; + else { + end = ptr - bptr; } - mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, ptr - temp, end)); - ptr += end + slen; - if (!mrb_nil_p(limit) && lim <= ++i) break; } - beg = ptr - temp; -#endif //INCLUDE_ENCODING } else { #ifdef INCLUDE_REGEXP @@ -3621,17 +2067,14 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str) break; } else if (last_null == 1) { - mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, - mrb_enc_fast_mbclen(ptr+beg, - ptr+len, - enc))); + mrb_ary_push(mrb, result, mrb_str_subseq(mrb, str, beg, len)); beg = start; } else { if (ptr+start == ptr+len) start++; else - start += mrb_enc_fast_mbclen(ptr+start,ptr+len,enc); + start += len; last_null = 1; continue; } @@ -3696,77 +2139,6 @@ mrb_block_given_p() static mrb_value mrb_str_sub_bang(mrb_state *mrb, mrb_value str) { - mrb_value *argv; - int argc; - mrb_value pat, repl; - long plen; - - mrb_get_args(mrb, "*", &argv, &argc); - if (argc == 1 && mrb_block_given_p()) { - /* do nothing */ - } - else if (argc == 2) { - repl = argv[1]; - //StringValue(repl); - mrb_string_value(mrb, &repl); - } - else { - mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 2)", argc); - } - - pat = get_pat(mrb, argv[0], 1); - str_modifiable(str); - if (mrb_reg_search(mrb, pat, str, 0, 0) >= 0) { - mrb_encoding *enc; - int cr = ENC_CODERANGE(str); - mrb_value match = mrb_backref_get(mrb); - struct re_registers *regs = RMATCH_REGS(match); - long beg0 = BEG(0); - long end0 = END(0); - char *p, *rp; - long len, rlen; - - repl = mrb_reg_regsub(mrb, repl, str, regs, pat); - enc = mrb_enc_compatible(mrb, str, repl); - if (!enc) { - mrb_encoding *str_enc = STR_ENC_GET(mrb, str); - p = RSTRING_PTR(str); len = RSTRING_LEN(str); - if (coderange_scan(p, beg0, str_enc) != ENC_CODERANGE_7BIT || - coderange_scan(p+end0, len-end0, str_enc) != ENC_CODERANGE_7BIT) { - mrb_raise(mrb, E_ENCODING_ERROR, "incompatible character encodings: %s and %s", - mrb_enc_name(str_enc), - mrb_enc_name(STR_ENC_GET(mrb, repl))); - } - enc = STR_ENC_GET(mrb, repl); - } - mrb_str_modify(mrb, str); - mrb_enc_associate(mrb, str, enc); - if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) { - int cr2 = ENC_CODERANGE(repl); - if (cr2 == ENC_CODERANGE_BROKEN || - (cr == ENC_CODERANGE_VALID && cr2 == ENC_CODERANGE_7BIT)) - cr = ENC_CODERANGE_UNKNOWN; - else - cr = cr2; - } - plen = end0 - beg0; - rp = RSTRING_PTR(repl); rlen = RSTRING_LEN(repl); - len = RSTRING_LEN(str); - if (rlen > plen) { - RESIZE_CAPA(str, len + rlen - plen); - } - p = RSTRING_PTR(str); - if (rlen != plen) { - memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen); - } - memcpy(p + beg0, rp, rlen); - len += rlen - plen; - STR_SET_LEN(str, len); - RSTRING_PTR(str)[len] = '\0'; - ENC_CODERANGE_SET(str, cr); - - return str; - } return mrb_nil_value(); } #endif //INCLUDE_REGEXP @@ -4197,66 +2569,18 @@ mrb_str_to_s(mrb_state *mrb, mrb_value self) static mrb_value mrb_str_upcase_bang(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc; -#endif //INCLUDE_ENCODING char *s, *send; int modify = 0; -#ifdef INCLUDE_ENCODING - int n; - - str_modify_keep_cr(mrb, str); - enc = STR_ENC_GET(mrb, str); - mrb_str_check_dummy_enc(mrb, enc); - s = RSTRING_PTR(str); send = RSTRING_END(str); - if (single_byte_optimizable(mrb, str)) { - while (s < send) { - unsigned int c = *(unsigned char*)s; - - if (mrb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') { - *s = 'A' + (c - 'a'); - modify = 1; - } - s++; - } - } - else { - int ascompat = mrb_enc_asciicompat(mrb, enc); - - while (s < send) { - unsigned int c; - if (ascompat && (c = *(unsigned char*)s) < 0x80) { - if (mrb_enc_isascii(c, enc) && 'a' <= c && c <= 'z') { - *s = 'A' + (c - 'a'); - modify = 1; - } - s++; - } - else { - c = mrb_enc_codepoint_len(mrb, s, send, &n, enc); - if (mrb_enc_islower(c, enc)) { - /* assuming toupper returns codepoint with same size */ - mrb_enc_mbcput(mrb_enc_toupper(c, enc), s, enc); - modify = 1; - } - s += n; - } - } - } -#else - mrb_str_modify(mrb, str); - s = RSTRING_PTR(str); send = RSTRING_END(str); + s = RSTRING(str)->buf; send = s + RSTRING(str)->len; while (s < send) { - unsigned int c = *(unsigned char*)s; - - if ('a' <= c && c <= 'z') { - *s = 'A' + (c - 'a'); + if (ISLOWER(*s)) { + *s = toupper(*s); modify = 1; } s++; } -#endif //INCLUDE_ENCODING + if (modify) return str; return mrb_nil_value(); } @@ -4282,252 +2606,6 @@ mrb_str_upcase(mrb_state *mrb, mrb_value self) return str; } -/* 15.2.10.5.xx */ -/* - * call-seq: - * str.force_encoding(encoding) -> str - * - * Changes the encoding to +encoding+ and returns self. - */ -#ifdef INCLUDE_ENCODING -static mrb_value -mrb_str_force_encoding(mrb_state *mrb, mrb_value self) -{ - mrb_value enc; - - mrb_get_args(mrb, "o", &enc); - str_modifiable(self); - mrb_enc_associate(mrb, self, mrb_to_encoding(mrb, enc)); - ENC_CODERANGE_CLEAR(self); - return self; -} - -long -mrb_str_coderange_scan_restartable(const char *s, const char *e, mrb_encoding *enc, int *cr) -{ - const char *p = s; - - if (*cr == ENC_CODERANGE_BROKEN) - return e - s; - - if (mrb_enc_to_index(enc) == 0) { - /* enc is ASCII-8BIT. ASCII-8BIT string never be broken. */ - p = search_nonascii(p, e); - *cr = (!p && *cr != ENC_CODERANGE_VALID) ? ENC_CODERANGE_7BIT : ENC_CODERANGE_VALID; - return e - s; - } - else if (mrb_enc_asciicompat(mrb, enc)) { - p = search_nonascii(p, e); - if (!p) { - if (*cr != ENC_CODERANGE_VALID) *cr = ENC_CODERANGE_7BIT; - return e - s; - } - while (p < e) { - int ret = mrb_enc_precise_mbclen(p, e, enc); - if (!MBCLEN_CHARFOUND_P(ret)) { - *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN; - return p - s; - } - p += MBCLEN_CHARFOUND_LEN(ret); - if (p < e) { - p = search_nonascii(p, e); - if (!p) { - *cr = ENC_CODERANGE_VALID; - return e - s; - } - } - } - *cr = e < p ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_VALID; - return p - s; - } - else { - while (p < e) { - int ret = mrb_enc_precise_mbclen(p, e, enc); - if (!MBCLEN_CHARFOUND_P(ret)) { - *cr = MBCLEN_INVALID_P(ret) ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_UNKNOWN; - return p - s; - } - p += MBCLEN_CHARFOUND_LEN(ret); - } - *cr = e < p ? ENC_CODERANGE_BROKEN: ENC_CODERANGE_VALID; - return p - s; - } -} - -mrb_value -mrb_str_conv_enc_opts(mrb_state *mrb, mrb_value str, mrb_encoding *from, mrb_encoding *to, int ecflags, mrb_value ecopts) -{ - mrb_econv_t *ec; - mrb_econv_result_t ret; - long len; - mrb_value newstr; - const unsigned char *sp; - unsigned char *dp; - - if (!to) return str; - if (from == to) return str; - if ((mrb_enc_asciicompat(mrb, to) && ENC_CODERANGE(str) == ENC_CODERANGE_7BIT) || - to == mrb_ascii8bit_encoding(mrb)) { - if (STR_ENC_GET(mrb, str) != to) { - str = mrb_str_dup(mrb, str); - mrb_enc_associate(mrb, str, to); - } - return str; - } - - len = RSTRING_LEN(str); - newstr = mrb_str_new(mrb, 0, len); - - retry: - ec = mrb_econv_open_opts(mrb, from->name, to->name, ecflags, ecopts); - if (!ec) return str; - - sp = (unsigned char*)RSTRING_PTR(str); - dp = (unsigned char*)RSTRING_PTR(newstr); - ret = mrb_econv_convert(mrb, ec, &sp, (unsigned char*)RSTRING_END(str), - &dp, (unsigned char*)RSTRING_END(newstr), 0); - mrb_econv_close(ec); - switch (ret) { - case econv_destination_buffer_full: - /* destination buffer short */ - len = len < 2 ? 2 : len * 2; - mrb_str_resize(mrb, newstr, len); - goto retry; - - case econv_finished: - len = dp - (unsigned char*)RSTRING_PTR(newstr); - mrb_str_set_len(mrb, newstr, len); - mrb_enc_associate(mrb, newstr, to); - return newstr; - - case econv_invalid_byte_sequence: - case econv_undefined_conversion: - case econv_source_buffer_empty: - case econv_after_output: - case econv_incomplete_input: - /* some error, return original */ - return str; - - default: - mrb_bug("Internal Error: Invalid return value mrb_econv_convert."); - return str; - } -} - -mrb_value -mrb_str_conv_enc(mrb_state *mrb, mrb_value str, mrb_encoding *from, mrb_encoding *to) -{ - return mrb_str_conv_enc_opts(mrb, str, from, to, 0, mrb_nil_value()); -} -#endif //INCLUDE_ENCODING - -#ifndef INCLUDE_ENCODING -#undef SIGN_EXTEND_CHAR -#if __STDC__ -# define SIGN_EXTEND_CHAR(c) ((signed char)(c)) -#else /* not __STDC__ */ -/* As in Harbison and Steele. */ -# define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128) -#endif -#define is_identchar(c) (SIGN_EXTEND_CHAR(c)!=-1&&(ISALNUM(c) || (c) == '_')) - -static int -is_special_global_name(m) - const char *m; -{ - switch (*m) { - case '~': case '*': case '$': case '?': case '!': case '@': - case '/': case '\\': case ';': case ',': case '.': case '=': - case ':': case '<': case '>': case '\"': - case '&': case '`': case '\'': case '+': - case '0': - ++m; - break; - case '-': - ++m; - if (is_identchar(*m)) m += 1; - break; - default: - if (!ISDIGIT(*m)) return 0; - do ++m; while (ISDIGIT(*m)); - } - return !*m; -} - -int -mrb_symname_p(const char *name) -{ - const char *m = name; - int localid = FALSE; - - if (!m) return FALSE; - switch (*m) { - case '\0': - return FALSE; - - case '$': - if (is_special_global_name(++m)) return TRUE; - goto id; - - case '@': - if (*++m == '@') ++m; - goto id; - - case '<': - switch (*++m) { - case '<': ++m; break; - case '=': if (*++m == '>') ++m; break; - default: break; - } - break; - - case '>': - switch (*++m) { - case '>': case '=': ++m; break; - } - break; - - case '=': - switch (*++m) { - case '~': ++m; break; - case '=': if (*++m == '=') ++m; break; - default: return FALSE; - } - break; - - case '*': - if (*++m == '*') ++m; - break; - - case '+': case '-': - if (*++m == '@') ++m; - break; - - case '|': case '^': case '&': case '/': case '%': case '~': case '`': - ++m; - break; - - case '[': - if (*++m != ']') return FALSE; - if (*++m == '=') ++m; - break; - - default: - localid = !ISUPPER(*m); -id: - if (*m != '_' && !ISALPHA(*m)) return FALSE; - while (is_identchar(*m)) m += 1; - if (localid) { - switch (*m) { - case '!': case '?': case '=': ++m; - } - } - break; - } - return *m ? FALSE : TRUE; -} -#endif //INCLUDE_ENCODING - /* * call-seq: * str.dump -> new_str @@ -4538,16 +2616,10 @@ id: mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc = mrb_enc_get(mrb, str); -#endif //INCLUDE_ENCODING long len; const char *p, *pend; - char *q, *qend; + char *q; mrb_value result; -#ifdef INCLUDE_ENCODING - int u8 = (enc == mrb_utf8_encoding(mrb)); -#endif //INCLUDE_ENCODING len = 2; /* "" */ p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); @@ -4570,33 +2642,15 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) len++; } else { -#ifdef INCLUDE_ENCODING - if (u8) { /* \u{NN} */ - int n = mrb_enc_precise_mbclen(p-1, pend, enc); - if (MBCLEN_CHARFOUND_P(n-1)) { - unsigned int cc = mrb_enc_mbc_to_codepoint(p-1, pend, enc); - while (cc >>= 4) len++; - len += 5; - p += MBCLEN_CHARFOUND_LEN(n)-1; - break; - } - } -#endif //INCLUDE_ENCODING len += 4; /* \xNN */ } break; } } -#ifdef INCLUDE_ENCODING - if (!mrb_enc_asciicompat(mrb, enc)) { - len += 19; /* ".force_encoding('')" */ - len += strlen(enc->name); - } -#endif //INCLUDE_ENCODING - result = mrb_str_new5(mrb, str, 0, len); + result = mrb_str_new_with_class(mrb, str, 0, len); p = RSTRING_PTR(str); pend = p + RSTRING_LEN(str); - q = RSTRING_PTR(result); qend = q + len + 1; + q = RSTRING_PTR(result); *q++ = '"'; while (p < pend) { @@ -4647,35 +2701,11 @@ mrb_str_dump(mrb_state *mrb, mrb_value str) } else { *q++ = '\\'; -#ifdef INCLUDE_ENCODING - if (u8) { - int n = mrb_enc_precise_mbclen(p-1, pend, enc) - 1; - if (MBCLEN_CHARFOUND_P(n)) { - int cc = mrb_enc_mbc_to_codepoint(p-1, pend, enc); - p += n; - snprintf(q, qend-q, "u{%x}", cc); - q += strlen(q); - continue; - } - } - snprintf(q, qend-q, "x%02X", c); -#else sprintf(q, "%03o", c&0xff); -#endif //INCLUDE_ENCODING q += 3; } } *q++ = '"'; -#ifdef INCLUDE_ENCODING - *q = '\0'; - if (!mrb_enc_asciicompat(mrb, enc)) { - snprintf(q, qend-q, ".force_encoding(\"%s\")", enc->name); - enc = mrb_ascii8bit_encoding(mrb); - } - /* result from dump is ASCII */ - mrb_enc_associate(mrb, result, enc); - ENC_CODERANGE_SET(result, ENC_CODERANGE_7BIT); -#endif //INCLUDE_ENCODING return result; } @@ -4686,8 +2716,6 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len) mrb_raise(mrb, E_ARGUMENT_ERROR, "negative string size (or size too big)"); } if (0/*STR_ASSOC_P(str)*/) { - mrb_str_modify(mrb, str); - //if (STR_EMBED_P(str)) str_make_independent(mrb, str); mrb_realloc(mrb, RSTRING(str)->buf, RSTRING(str)->len+len+1); memcpy(RSTRING(str)->buf + RSTRING(str)->len, ptr, len); RSTRING(str)->len += len; @@ -4701,18 +2729,13 @@ mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len) mrb_value mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr) { - return mrb_str_cat(mrb, str, ptr, strlen(ptr)); + return mrb_str_cat(mrb, str, ptr, strlen(ptr)); } -mrb_value +static mrb_value mrb_str_vcatf(mrb_state *mrb, mrb_value str, const char *fmt, va_list ap) { - //mrb_printf_buffer f; - //mrb_value klass; - - //StringValue(str); mrb_string_value(mrb, &str); - mrb_str_modify(mrb, str); mrb_str_resize(mrb, str, (char*)RSTRING_END(str) - RSTRING_PTR(str)); return str; @@ -4730,12 +2753,6 @@ mrb_str_catf(mrb_state *mrb, mrb_value str, const char *format, ...) return str; } -void -mrb_lastline_set(mrb_value val) -{ - //vm_svar_set(0, val); -} - mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2) { @@ -4743,69 +2760,7 @@ mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2) return mrb_str_buf_append(mrb, str, str2); } -void -mrb_str_setter(mrb_state *mrb, mrb_value val, mrb_sym id, mrb_value *var) -{ - if (!mrb_nil_p(val) && (mrb_type(val) != MRB_TT_STRING)) { - mrb_raise(mrb, E_TYPE_ERROR, "value of %s must be String", mrb_sym2name(mrb, id)); - } - *var = val; -} - -#ifdef INCLUDE_ENCODING -/* - * call-seq: - * str.ascii_only? -> true or false - * - * Returns true for a string which has only ASCII characters. - * - * "abc".force_encoding("UTF-8").ascii_only? #=> true - * "abc\u{6666}".force_encoding("UTF-8").ascii_only? #=> false - */ - -int -mrb_str_is_ascii_only_p(mrb_state *mrb, mrb_value str) -{ - int cr = mrb_enc_str_coderange(mrb, str); - - return cr == ENC_CODERANGE_7BIT ? TRUE : FALSE; -} - -#endif //INCLUDE_ENCODING - #define CHAR_ESC_LEN 13 /* sizeof(\x{ hex of 32bit unsigned int } \0) */ -int -mrb_str_buf_cat_escaped_char(mrb_state *mrb, mrb_value result, unsigned int c, int unicode_p) -{ - char buf[CHAR_ESC_LEN + 1]; - int l; - - if (sizeof(c) > 4) { - c &= 0xffffffff; - } - if (unicode_p) { - if (c < 0x7F && ISPRINT(c)) { - snprintf(buf, CHAR_ESC_LEN, "%c", c); - } - else if (c < 0x10000) { - snprintf(buf, CHAR_ESC_LEN, "\\u%04X", c); - } - else { - snprintf(buf, CHAR_ESC_LEN, "\\u{%X}", c); - } - } - else { - if (c < 0x100) { - snprintf(buf, CHAR_ESC_LEN, "\\x%02X", c); - } - else { - snprintf(buf, CHAR_ESC_LEN, "\\x{%X}", c); - } - } - l = (int)strlen(buf); /* CHAR_ESC_LEN cannot exceed INT_MAX */ - mrb_str_buf_cat(mrb, result, buf, l); - return l; -} /* * call-seq: @@ -4821,24 +2776,9 @@ mrb_str_buf_cat_escaped_char(mrb_state *mrb, mrb_value result, unsigned int c, i mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str) { -#ifdef INCLUDE_ENCODING - mrb_encoding *enc = STR_ENC_GET(mrb, str); -#endif //INCLUDE_ENCODING const char *p, *pend, *prev; char buf[CHAR_ESC_LEN + 1]; -#ifdef INCLUDE_ENCODING - mrb_value result = mrb_str_buf_new(mrb, 0); - mrb_encoding *resenc = mrb_default_internal_encoding(mrb); - int unicode_p = mrb_enc_unicode_p(enc); - int asciicompat = mrb_enc_asciicompat(mrb, enc); - - if (resenc == NULL) resenc = mrb_default_external_encoding(mrb); - if (!mrb_enc_asciicompat(mrb, resenc)) resenc = mrb_usascii_encoding(mrb); - mrb_enc_associate(mrb, result, resenc); - mrb_str_buf_cat(mrb, result, "\"", strlen("\"")); -#else mrb_value result = mrb_str_new_cstr(mrb, "\""); -#endif //INCLUDE_ENCODING p = RSTRING_PTR(str); pend = RSTRING_END(str); prev = p; @@ -4846,37 +2786,6 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) unsigned int c, cc; int n; -#ifdef INCLUDE_ENCODING - n = mrb_enc_precise_mbclen(p, pend, enc); - if (!MBCLEN_CHARFOUND_P(n)) { - if (p > prev) mrb_str_buf_cat(mrb, result, prev, p - prev); - n = mrb_enc_mbminlen(enc); - if (pend < p + n) - n = (int)(pend - p); - while (n--) { - snprintf(buf, CHAR_ESC_LEN, "\\x%02X", *p & 0377); - mrb_str_buf_cat(mrb, result, buf, strlen(buf)); - prev = ++p; - } - continue; - } - n = MBCLEN_CHARFOUND_LEN(n); - c = mrb_enc_mbc_to_codepoint(p, pend, enc); - p += n; - if (c == '"'|| c == '\\' || - (c == '#' && - p < pend && - MBCLEN_CHARFOUND_P(mrb_enc_precise_mbclen(p,pend,enc)) && - (cc = mrb_enc_codepoint(mrb, p, pend, enc), - (cc == '$' || cc == '@' || cc == '{')))) { - if (p - n > prev) mrb_str_buf_cat(mrb, result, prev, p - n - prev); - mrb_str_buf_cat(mrb, result, "\\", strlen("\\")); //str_buf_cat2(result, "\\"); - if (asciicompat || enc == resenc) { - prev = p - n; - continue; - } - } -#else c = *p++; n = 1; if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p, pend))) { @@ -4889,7 +2798,6 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) mrb_str_buf_cat(mrb, result, buf, 1); continue; } -#endif //INCLUDE_ENCODING switch (c) { case '\n': cc = 'n'; break; case '\r': cc = 'r'; break; @@ -4909,20 +2817,10 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) prev = p; continue; } -#ifdef INCLUDE_ENCODING - if ((enc == resenc && mrb_enc_isprint(c, enc)) || - (asciicompat && mrb_enc_isascii(c, enc) && ISPRINT(c))) { - continue; - } -#endif //INCLUDE_ENCODING else { if (p - n > prev) mrb_str_buf_cat(mrb, result, prev, p - n - prev); -#ifdef INCLUDE_ENCODING - mrb_str_buf_cat_escaped_char(mrb, result, c, unicode_p); -#else sprintf(buf, "\\%03o", c & 0377); mrb_str_buf_cat(mrb, result, buf, strlen(buf)); -#endif //INCLUDE_ENCODING prev = p; continue; } @@ -4935,21 +2833,6 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str) return result; } -#ifdef INCLUDE_ENCODING -int -sym_printable(mrb_state *mrb, const char *s, const char *send, mrb_encoding *enc) -{ - while (s < send) { - int n; - int c = mrb_enc_codepoint_len(mrb, s, send, &n, enc); - - if (!mrb_enc_isprint(c, enc)) return FALSE; - s += n; - } - return TRUE; -} -#endif //INCLUDE_ENCODING - /* ---------------------------*/ void mrb_init_string(mrb_state *mrb) @@ -4978,7 +2861,7 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "downcase", mrb_str_downcase, ARGS_NONE()); /* 15.2.10.5.13 */ mrb_define_method(mrb, s, "downcase!", mrb_str_downcase_bang, ARGS_NONE()); /* 15.2.10.5.14 */ mrb_define_method(mrb, s, "each_line", mrb_str_each_line, ARGS_REQ(1)); /* 15.2.10.5.15 */ - mrb_define_method(mrb, s, "empty?", mrb_str_empty, ARGS_NONE()); /* 15.2.10.5.16 */ + mrb_define_method(mrb, s, "empty?", mrb_str_empty_p, ARGS_NONE()); /* 15.2.10.5.16 */ mrb_define_method(mrb, s, "eql?", mrb_str_eql, ARGS_REQ(1)); /* 15.2.10.5.17 */ #ifdef INCLUDE_REGEXP mrb_define_method(mrb, s, "gsub", mrb_str_gsub, ARGS_REQ(1)); /* 15.2.10.5.18 */ @@ -5013,9 +2896,5 @@ mrb_init_string(mrb_state *mrb) mrb_define_method(mrb, s, "to_sym", mrb_str_intern, ARGS_NONE()); /* 15.2.10.5.41 */ mrb_define_method(mrb, s, "upcase", mrb_str_upcase, ARGS_REQ(1)); /* 15.2.10.5.42 */ mrb_define_method(mrb, s, "upcase!", mrb_str_upcase_bang, ARGS_REQ(1)); /* 15.2.10.5.43 */ -#ifdef INCLUDE_ENCODING - mrb_define_method(mrb, s, "encoding", mrb_obj_encoding, ARGS_NONE()); /* 15.2.10.5.44(x) */ - mrb_define_method(mrb, s, "force_encoding", mrb_str_force_encoding, ARGS_REQ(1)); /* 15.2.10.5.45(x) */ -#endif mrb_define_method(mrb, s, "inspect", mrb_str_inspect, ARGS_NONE()); /* 15.2.10.5.46(x) */ } |