22 #define BEG(no) (regs->beg[(no)])
23 #define END(no) (regs->end[(no)])
32 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
34 #undef rb_str_new_cstr
35 #undef rb_tainted_str_new_cstr
36 #undef rb_usascii_str_new_cstr
37 #undef rb_external_str_new_cstr
38 #undef rb_locale_str_new_cstr
43 #undef rb_tainted_str_new2
44 #undef rb_usascii_str_new2
45 #undef rb_str_dup_frozen
46 #undef rb_str_buf_new_cstr
47 #undef rb_str_buf_new2
48 #undef rb_str_buf_cat2
56 #define RUBY_MAX_CHAR_LEN 16
57 #define STR_TMPLOCK FL_USER7
58 #define STR_NOEMBED FL_USER1
59 #define STR_SHARED FL_USER2
60 #define STR_ASSOC FL_USER3
61 #define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
62 #define STR_ASSOC_P(s) FL_ALL((s), STR_NOEMBED|STR_ASSOC)
63 #define STR_NOCAPA (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
64 #define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
65 #define STR_UNSET_NOCAPA(s) do {\
66 if (FL_TEST((s),STR_NOEMBED)) FL_UNSET((s),(ELTS_SHARED|STR_ASSOC));\
70 #define STR_SET_NOEMBED(str) do {\
71 FL_SET((str), STR_NOEMBED);\
72 STR_SET_EMBED_LEN((str), 0);\
74 #define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED)
75 #define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
76 #define STR_SET_EMBED_LEN(str, n) do { \
78 RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\
79 RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\
82 #define STR_SET_LEN(str, n) do { \
83 if (STR_EMBED_P(str)) {\
84 STR_SET_EMBED_LEN((str), (n));\
87 RSTRING(str)->as.heap.len = (n);\
91 #define STR_DEC_LEN(str) do {\
92 if (STR_EMBED_P(str)) {\
93 long n = RSTRING_LEN(str);\
95 STR_SET_EMBED_LEN((str), n);\
98 RSTRING(str)->as.heap.len--;\
102 #define RESIZE_CAPA(str,capacity) do {\
103 if (STR_EMBED_P(str)) {\
104 if ((capacity) > RSTRING_EMBED_LEN_MAX) {\
105 char *tmp = ALLOC_N(char, (capacity)+1);\
106 memcpy(tmp, RSTRING_PTR(str), RSTRING_LEN(str));\
107 RSTRING(str)->as.heap.ptr = tmp;\
108 RSTRING(str)->as.heap.len = RSTRING_LEN(str);\
109 STR_SET_NOEMBED(str);\
110 RSTRING(str)->as.heap.aux.capa = (capacity);\
114 REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+1);\
115 if (!STR_NOCAPA_P(str))\
116 RSTRING(str)->as.heap.aux.capa = (capacity);\
120 #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
121 #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
123 #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str))
145 static inline const char *
148 #if SIZEOF_VALUE == 8
149 # define NONASCII_MASK 0x8080808080808080ULL
150 #elif SIZEOF_VALUE == 4
151 # define NONASCII_MASK 0x80808080UL
154 if ((
int)
sizeof(
VALUE) * 2 < e - p) {
157 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
158 while (p < (
const char *)s) {
165 if (*s & NONASCII_MASK) {
185 const char *e = p + len;
366 return RSTRING(str)->as.heap.len;
369 return RSTRING(str)->as.heap.aux.capa;
378 str->as.heap.ptr = 0;
379 str->as.heap.len = 0;
380 str->as.heap.aux.capa = 0;
409 RSTRING(str)->as.heap.aux.capa = len;
456 #define rb_str_new2 rb_str_new_cstr
467 #define rb_usascii_str_new2 rb_usascii_str_new_cstr
488 #define rb_tainted_str_new2 rb_tainted_str_new_cstr
499 const unsigned char *start, *sp;
500 unsigned char *dest, *
dp;
501 size_t converted_output = 0;
505 if (from == to)
return str;
520 RBASIC(econv_wrapper)->klass = 0;
527 while ((dest = (
unsigned char*)
RSTRING_PTR(newstr)),
528 (dp = dest + converted_output),
532 size_t converted_input = sp - start;
533 size_t rest = len - converted_input;
534 converted_output = dp - dest;
536 if (converted_input && converted_output &&
537 rest < (
LONG_MAX / converted_output)) {
538 rest = (rest * converted_output) / converted_input;
543 olen += rest < 2 ? 2 : rest;
650 RSTRING(str2)->as.heap.aux.shared = str;
686 #define rb_str_new3 rb_str_new_shared
701 RSTRING(str2)->as.heap.aux.shared = shared;
705 RSTRING(str)->as.heap.aux.shared = str2;
723 if ((ofs > 0) || (klass !=
RBASIC(str)->klass) ||
727 RSTRING(str)->as.heap.ptr += ofs;
728 RSTRING(str)->as.heap.len -= ofs;
741 str = str_new4(klass, orig);
743 RSTRING(str)->as.heap.aux.shared = assoc;
746 str = str_new4(klass, orig);
753 #define rb_str_new4 rb_str_new_frozen
763 #define rb_str_new5 rb_str_new_with_class
766 str_new_empty(
VALUE str)
774 #define STR_BUF_MIN_SIZE 128
785 RSTRING(str)->as.heap.aux.capa = capa;
787 RSTRING(str)->as.heap.ptr[0] =
'\0';
805 #define rb_str_buf_new2 rb_str_buf_new_cstr
841 return RSTRING(str)->as.heap.aux.capa;
861 if (str == str2)
return;
880 RSTRING(str)->as.heap.aux.shared =
RSTRING(str2)->as.heap.aux.shared;
922 RSTRING(str)->as.heap.len = len;
926 RSTRING(str)->as.heap.aux.shared = shared;
973 if (argc > 0 &&
rb_scan_args(argc, argv,
"01", &orig) == 1)
1018 for (c=0; p<e; c++) {
1068 for (c=0; p<e; c++) {
1086 #ifdef NONASCII_MASK
1087 #define is_utf8_lead_byte(c) (((c)&0xC0) != 0x80)
1102 count_utf8_lead_bytes_with_word(
const VALUE *s)
1109 d &= NONASCII_MASK >> 7;
1114 #if SIZEOF_VALUE == 8
1133 #ifdef NONASCII_MASK
1138 if ((
int)
sizeof(
VALUE) * 2 < e - p) {
1141 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
1143 while (p < (
const char *)s) {
1144 if (is_utf8_lead_byte(*p)) len++;
1148 len += count_utf8_lead_bytes_with_word(s);
1151 p = (
const char *)s;
1154 if (is_utf8_lead_byte(*p)) len++;
1287 while (n <= len/2) {
1288 memcpy(ptr2 + n, ptr2, n);
1291 memcpy(ptr2 + n, ptr2, len-n);
1351 long capa = len + expand;
1353 if (len > capa) len = capa;
1354 ptr =
ALLOC_N(
char, capa + 1);
1361 RSTRING(str)->as.heap.ptr = ptr;
1362 RSTRING(str)->as.heap.len = len;
1363 RSTRING(str)->as.heap.aux.capa = capa;
1366 #define str_make_independent(str) str_make_independent_expand((str), 0L)
1385 else if (expand > 0) {
1387 long capa = len + expand;
1390 RSTRING(str)->as.heap.aux.capa = capa;
1416 RSTRING(str)->as.heap.ptr = 0;
1417 RSTRING(str)->as.heap.len = 0;
1435 assoc =
RSTRING(assoc)->as.heap.aux.shared;
1457 return RSTRING(str)->as.heap.aux.shared;
1496 if (!s || memchr(s, 0, len)) {
1542 const char *p2, *e2;
1545 while (p < e && 0 < nth) {
1572 while (p < e && nth--) {
1604 const char *pp =
str_nth(p, e, nth, enc, singlebyte);
1605 if (!pp)
return e -
p;
1616 #ifdef NONASCII_MASK
1618 str_utf8_nth(
const char *
p,
const char *e,
long *nthp)
1624 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
1626 while (p < (
const char *)s) {
1627 if (is_utf8_lead_byte(*p)) nth--;
1631 nth -= count_utf8_lead_bytes_with_word(s);
1633 }
while (s < t && (
int)
sizeof(
VALUE) <= nth);
1637 if (is_utf8_lead_byte(*p)) {
1638 if (nth == 0)
break;
1648 str_utf8_offset(
const char *p,
const char *e,
long nth)
1650 const char *pp = str_utf8_nth(p, e, &nth);
1697 if (len < 0)
return 0;
1702 if (beg > blen)
return 0;
1705 if (beg < 0)
return 0;
1707 if (beg + len > blen)
1709 if (len < 0)
return 0;
1714 if (len > -beg) len = -beg;
1728 if (beg < 0)
return 0;
1730 if (len == 0)
goto end;
1740 #ifdef NONASCII_MASK
1743 p = str_utf8_nth(s, e, &beg);
1744 if (beg > 0)
return 0;
1745 len = str_utf8_offset(p, e, len);
1751 p = s + beg * char_sz;
1755 else if (len * char_sz > e - p)
1760 else if ((p =
str_nth_len(s, e, &beg, enc)) == e) {
1761 if (beg > 0)
return 0;
1779 if (!p)
return Qnil;
1784 RSTRING(str2)->as.heap.len = len;
1807 #define rb_str_dup_frozen rb_str_new_frozen
1846 rb_bug(
"probable buffer overflow: %ld for %ld", len, capa);
1869 RSTRING(str)->as.ary[len] =
'\0';
1876 char *ptr =
RSTRING(str)->as.heap.ptr;
1878 if (slen > len) slen = len;
1879 if (slen > 0)
MEMCPY(
RSTRING(str)->as.ary, ptr,
char, slen);
1880 RSTRING(str)->as.ary[len] =
'\0';
1882 if (independent)
xfree(ptr);
1885 else if (!independent) {
1888 else if (slen < len || slen - len > 1024) {
1892 RSTRING(str)->as.heap.aux.capa = len;
1894 RSTRING(str)->as.heap.len = len;
1895 RSTRING(str)->as.heap.ptr[len] =
'\0';
1903 long capa, total, off = -1;
1909 if (len == 0)
return 0;
1918 capa =
RSTRING(str)->as.heap.aux.capa;
1924 if (capa <= total) {
1925 while (total > capa) {
1927 capa = (total + 4095) / 4096;
1930 capa = (capa + 1) * 2;
1944 #define str_buf_cat2(str, ptr) str_buf_cat((str), (ptr), strlen(ptr))
1949 if (len == 0)
return str;
1971 p =
RSTRING(str)->as.heap.ptr;
1972 memcpy(p +
RSTRING(str)->as.heap.len, ptr, len);
1973 len =
RSTRING(str)->as.heap.len += len;
1989 int ptr_encindex,
int ptr_cr,
int *ptr_cr_ret)
1997 if (str_encindex == ptr_encindex) {
2027 *ptr_cr_ret = ptr_cr;
2029 if (str_encindex != ptr_encindex &&
2039 res_encindex = str_encindex;
2044 res_encindex = str_encindex;
2048 res_encindex = ptr_encindex;
2053 res_encindex = str_encindex;
2060 res_encindex = str_encindex;
2093 unsigned int c = (
unsigned char)*ptr;
2136 RSTRING(str)->as.heap.len = len;
2184 buf[0] = (char)code;
2280 #define lesser(a,b) (((a)>(b))?(b):(a))
2292 if (idx1 == idx2)
return TRUE;
2311 const char *ptr1, *ptr2;
2314 if (str1 == str2)
return 0;
2317 if (ptr1 == ptr2 || (retval =
memcmp(ptr1, ptr2,
lesser(len1, len2))) == 0) {
2326 if (len1 > len2)
return 1;
2329 if (retval > 0)
return 1;
2338 const char *ptr1, *ptr2;
2344 if (
memcmp(ptr1, ptr2, len) == 0)
2361 if (str1 == str2)
return Qtrue;
2381 if (str1 == str2)
return Qtrue;
2448 char *p1, *p1end, *p2, *p2end;
2459 while (p1 < p1end && p2 < p2end) {
2461 unsigned int c1 =
TOUPPER(*p1 & 0xff);
2462 unsigned int c2 =
TOUPPER(*p2 & 0xff);
2464 return INT2FIX(c1 < c2 ? -1 : 1);
2471 while (p1 < p1end && p2 < p2end) {
2475 if (0 <= c1 && 0 <= c2) {
2479 return INT2FIX(c1 < c2 ? -1 : 1);
2485 len = l1 < l2 ? l1 : l2;
2488 return INT2FIX(r < 0 ? -1 : 1);
2490 return INT2FIX(l1 < l2 ? -1 : 1);
2517 if (offset < 0)
return -1;
2519 if (len - offset < slen)
return -1;
2526 if (slen == 0)
return offset;
2534 if (pos < 0)
return pos;
2536 if (t == s + pos)
break;
2537 if ((len -= t - s) <= 0)
return -1;
2541 return pos + offset;
2569 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
2615 if (pos == -1)
return Qnil;
2623 char *s, *sbeg, *e, *t;
2634 if (len < slen)
return -1;
2635 if (len - pos < slen) {
2645 s =
str_nth(sbeg, e, pos, enc, singlebyte);
2647 if (
memcmp(s, t, slen) == 0) {
2650 if (pos == 0)
break;
2684 if (
rb_scan_args(argc, argv,
"11", &sub, &vpos) == 2) {
2695 if (pos > len) pos = len;
2712 if (pos >= 0)
return LONG2NUM(pos);
2729 if (pos >= 0)
return LONG2NUM(pos);
2830 for (i = len-1; 0 <= i && (
unsigned char)p[i] == 0xff; i--)
2834 ++((
unsigned char*)p)[
i];
2842 memset(p+l, 0xff, len-l);
2848 for (len2 = len-1; 0 < len2; len2--) {
2853 memset(p+len2+1, 0xff, len-(len2+1));
2864 for (i = len-1; 0 <= i && (
unsigned char)p[i] == 0; i--)
2868 --((
unsigned char*)p)[
i];
2876 memset(p+l, 0, len-l);
2882 for (len2 = len-1; 0 < len2; len2--) {
2887 memset(p+len2+1, 0, len-(len2+1));
2918 MEMCPY(save, p,
char, len);
2925 MEMCPY(p, save,
char, len);
2928 MEMCPY(save, p,
char, len);
2933 MEMCPY(p, save,
char, len);
2938 MEMCPY(p, save,
char, len);
2948 MEMCPY(carry, p,
char, len);
2952 MEMCPY(carry, p,
char, len);
2988 char *sbeg, *s, *e, *last_alnum = 0;
2992 long carry_pos = 0, carry_len = 1;
3024 carry_pos = s - sbeg;
3040 MEMCPY(carry, s,
char, l);
3043 carry_pos = s - sbeg;
3110 VALUE end, exclusive;
3111 VALUE current, after_end;
3118 excl =
RTEST(exclusive);
3128 if (c > e || (excl && c == e))
return beg;
3131 if (!excl && c == e)
break;
3133 if (excl && c == e)
break;
3162 if (excl && bi == ei)
break;
3183 if (n > 0 || (excl && n == 0))
return beg;
3192 if (
NIL_P(next))
break;
3353 if (len > olen) len = olen;
3361 memmove(ptr, oldptr + len, nlen);
3366 ptr =
RSTRING(str)->as.heap.ptr += len;
3367 RSTRING(str)->as.heap.len = nlen;
3432 if (slen < len || slen < beg + len) {
3461 long start, end, len;
3507 switch (
TYPE(indx)) {
3637 for (i=0; i<
argc; i++) {
3642 if (!
NIL_P(result)) {
3654 switch (
TYPE(pat)) {
3724 if (iter || !
NIL_P(hash)) {
3772 memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen);
3774 memcpy(p + beg0, rp, rlen);
3842 long offset, blen, slen, len,
last;
3868 if (bang)
return Qnil;
3889 if (iter || !
NIL_P(hash)) {
3908 len = beg0 - offset;
3925 offset = end0 + len;
3964 return str_gsub(argc, argv, str, 1);
4014 return str_gsub(argc, argv, str, 0);
4033 if (str == str2)
return str;
4130 if (beg > n || len < 0)
return Qnil;
4133 if (beg < 0)
return Qnil;
4148 RSTRING(str2)->as.heap.len = len;
4182 switch (
TYPE(indx)) {
4278 if (clen > 1 || (*s & 0x80)) single = 0;
4288 if (clen > 1 || (*s & 0x80)) single = 0;
4365 if (i == -1)
return Qfalse;
4396 if (argc == 0) base = 10;
4460 #define CHAR_ESC_LEN 13
4475 else if (c < 0x10000) {
4511 const char *
p, *pend, *prev;
4529 const unsigned char *q = (
const unsigned char *)p;
4530 if (q[0] == 0xFE && q[1] == 0xFF)
4532 else if (q[0] == 0xFF && q[1] == 0xFE)
4537 else if (enc == utf32) {
4538 const unsigned char *q = (
const unsigned char *)p;
4539 if (q[0] == 0 && q[1] == 0 && q[2] == 0xFE && q[3] == 0xFF)
4541 else if (q[3] == 0 && q[2] == 0 && q[1] == 0xFE && q[0] == 0xFF)
4552 if (p > prev)
str_buf_cat(result, prev, p - prev);
4555 n = (int)(pend - p);
4566 if ((asciicompat || unicode_p) &&
4567 (c ==
'"'|| c ==
'\\' ||
4572 (cc ==
'$' || cc ==
'@' || cc ==
'{'))))) {
4573 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4575 if (asciicompat || enc == resenc) {
4581 case '\n': cc =
'n';
break;
4582 case '\r': cc =
'r';
break;
4583 case '\t': cc =
't';
break;
4584 case '\f': cc =
'f';
break;
4585 case '\013': cc =
'v';
break;
4586 case '\010': cc =
'b';
break;
4587 case '\007': cc =
'a';
break;
4588 case 033: cc =
'e';
break;
4589 default: cc = 0;
break;
4592 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4604 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4610 if (p > prev)
str_buf_cat(result, prev, p - prev);
4617 #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
4634 const char *
p, *pend;
4642 unsigned char c = *p++;
4644 case '"':
case '\\':
4645 case '\n':
case '\r':
4646 case '\t':
case '\f':
4647 case '\013':
case '\010':
case '\007':
case '\033':
4664 while (cc >>= 4) len++;
4686 unsigned char c = *p++;
4688 if (c ==
'"' || c ==
'\\') {
4692 else if (c ==
'#') {
4693 if (
IS_EVSTR(p, pend)) *q++ =
'\\';
4696 else if (c ==
'\n') {
4700 else if (c ==
'\r') {
4704 else if (c ==
'\t') {
4708 else if (c ==
'\f') {
4712 else if (c ==
'\013') {
4716 else if (c ==
'\010') {
4720 else if (c ==
'\007') {
4724 else if (c ==
'\033') {
4750 snprintf(q, qend-q,
".force_encoding(\"%s\")", enc->
name);
4793 unsigned int c = *(
unsigned char*)s;
4796 *s =
'A' + (c -
'a');
4808 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
4810 *s =
'A' + (c -
'a');
4827 if (modify)
return str;
4875 unsigned int c = *(
unsigned char*)s;
4878 *s =
'a' + (c -
'A');
4891 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
4893 *s =
'a' + (c -
'A');
4910 if (modify)
return str;
4980 if (modify)
return str;
5044 if (modify)
return str;
5085 if (t->
p == t->
pend)
return -1;
5093 if (t->
p < t->
pend) {
5097 if (t->
now < 0x80 && c < 0x80) {
5099 "invalid range \"%c-%c\" in string transliteration",
5136 const unsigned int errc = -1;
5137 unsigned int trans[256];
5139 struct tr trsrc, trrepl;
5141 unsigned int c, c0,
last = 0;
5142 int modify = 0,
i, l;
5148 #define CHECK_IF_ASCII(c) \
5149 (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \
5150 (cr = ENC_CODERANGE_VALID) : 0)
5171 trsrc.
p + l < trsrc.
pend) {
5177 trsrc.
gen = trrepl.
gen = 0;
5178 trsrc.
now = trrepl.
now = 0;
5179 trsrc.
max = trrepl.
max = 0;
5182 for (
i=0;
i<256;
i++) {
5185 while ((c =
trnext(&trsrc, enc)) != errc) {
5194 while ((c =
trnext(&trrepl, enc)) != errc)
5197 for (
i=0;
i<256;
i++) {
5198 if (trans[
i] != errc) {
5206 for (
i=0;
i<256;
i++) {
5209 while ((c =
trnext(&trsrc, enc)) != errc) {
5210 r =
trnext(&trrepl, enc);
5211 if (r == errc) r = trrepl.
now;
5230 unsigned int save = -1;
5246 if (cflag) c =
last;
5249 else if (cflag) c = errc;
5255 if (c != (
unsigned int)-1) {
5267 if (enc != e1) may_modify = 1;
5269 while (t - buf + tlen >= max) {
5276 if (may_modify &&
memcmp(s, t, tlen) != 0) {
5293 c = (
unsigned char)*s;
5294 if (trans[c] != errc) {
5325 if (cflag) c =
last;
5328 else if (cflag) c = errc;
5332 c = cflag ? last : errc;
5340 if (enc != e1) may_modify = 1;
5342 while (t - buf + tlen >= max) {
5350 if (may_modify &&
memcmp(s, t, tlen) != 0) {
5390 return tr_trans(str, src, repl, 0);
5437 #define TR_TABLE_SIZE 257
5442 const unsigned int errc = -1;
5446 VALUE table = 0, ptable = 0;
5447 int i, l, cflag = 0;
5457 for (i=0; i<256; i++) {
5460 stable[256] = cflag;
5462 else if (stable[256] && !cflag) {
5465 for (i=0; i<256; i++) {
5469 while ((c =
trnext(&tr, enc)) != errc) {
5471 buf[c & 0xff] = !cflag;
5476 if (!table && (first || *tablep || stable[256])) {
5493 for (i=0; i<256; i++) {
5494 stable[
i] = stable[
i] && buf[
i];
5496 if (!table && !cflag) {
5506 return table[c] != 0;
5538 VALUE del = 0, nodel = 0;
5540 int i, ascompat, cr;
5544 for (i=0; i<
argc; i++) {
5561 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5574 if (
tr_find(c, squeez, del, nodel)) {
5589 if (modify)
return str;
5630 VALUE del = 0, nodel = 0;
5640 for (i=0; i<
argc; i++) {
5660 unsigned int c = *(
unsigned char*)s++;
5661 if (c != save || (argc > 0 && !squeez[c])) {
5670 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5671 if (c != save || (argc > 0 && !squeez[c])) {
5679 if (c != save || (argc > 0 && !
tr_find(c, squeez, del, nodel))) {
5695 if (modify)
return str;
5735 return tr_trans(str, src, repl, 1);
5793 VALUE del = 0, nodel = 0;
5799 for (i=0; i<
argc; i++) {
5813 if (*(
unsigned char*)s++ == c) n++;
5828 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5837 if (
tr_find(c, table, del, nodel)) {
5848 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
5849 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5850 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5851 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5852 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5853 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5854 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5855 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5856 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5857 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5858 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5859 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5860 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5861 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5862 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5866 #define ascii_isspace(c) isspacetable[(unsigned char)(c)]
5921 enum {awk, string, regexp} split_type;
5922 long beg, end,
i = 0;
5926 if (
rb_scan_args(argc, argv,
"02", &spat, &limit) == 2) {
5928 if (lim <= 0) limit =
Qnil;
5929 else if (lim == 1) {
5950 split_type = string;
5954 split_type = regexp;
5971 split_type = regexp;
5977 if (split_type == awk) {
5986 while (ptr < eptr) {
5987 c = (
unsigned char)*ptr++;
5995 if (!
NIL_P(limit) && lim <=
i)
break;
6010 while (ptr < eptr) {
6022 if (!
NIL_P(limit) && lim <= i)
break;
6037 else if (split_type ==
string) {
6051 while (ptr < eptr &&
6052 (end =
rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
6055 if (t != ptr + end) {
6061 if (!
NIL_P(limit) && lim <= ++i)
break;
6075 if (start == end &&
BEG(0) ==
END(0)) {
6080 else if (last_null == 1) {
6088 if (ptr+start == ptr+len)
6098 beg = start =
END(0);
6102 for (idx=1; idx < regs->
num_regs; idx++) {
6103 if (
BEG(idx) == -1)
continue;
6104 if (
BEG(idx) ==
END(idx))
6105 tmp = str_new_empty(str);
6110 if (!
NIL_P(limit) && lim <= ++i)
break;
6115 tmp = str_new_empty(str);
6120 if (
NIL_P(limit) && lim == 0) {
6146 unsigned int newline;
6147 const char *
p, *pend, *s, *ptr;
6164 rb_warn(
"given block not used");
6167 rb_warning(
"passing a block to String#lines is deprecated");
6199 p = memchr(p,
'\n', pend - p);
6231 if (rslen == 0 && c == newline) {
6244 const char *pp = p + (rslen ? rslen : n);
6346 rb_warn(
"given block not used");
6349 rb_warning(
"passing a block to String#bytes is deprecated");
6418 const char *end_ptr = ptr + len;
6419 for (len = 0; ptr < end_ptr; ++len) {
6439 rb_warn(
"given block not used");
6442 rb_warning(
"passing a block to String#chars is deprecated");
6461 for (i = 0; i < len; i += n) {
6471 for (i = 0; i < len; i += n) {
6532 const char *ptr, *end;
6542 rb_warn(
"given block not used");
6545 rb_warning(
"passing a block to String#codepoints is deprecated");
6623 const char *
p, *p2, *beg, *end;
6627 if (beg > end)
return 0;
6707 if (len == 0)
return Qnil;
6759 while (len>0 && p[len-1] ==
'\n') {
6761 if (len>0 && p[len-1] ==
'\r')
6771 if (rslen > len)
return Qnil;
6773 if (rslen == 1 && newline ==
'\n')
6781 if (p[len-1] == newline &&
6914 while (s < t && ((c = *(t-1)) ==
'\0' ||
ascii_isspace(c))) t--;
7021 for (i=1; i < regs->
num_regs; i++) {
7067 long last = -1, prev = 0;
7156 extern char *
crypt(
const char *,
const char *);
7158 const char *s, *saltp;
7161 char salt_8bit_clean[3];
7172 if (!
ISASCII((
unsigned char)saltp[0]) || !
ISASCII((
unsigned char)saltp[1])) {
7173 salt_8bit_clean[0] = saltp[0] & 0x7f;
7174 salt_8bit_clean[1] = saltp[1] & 0x7f;
7175 salt_8bit_clean[2] =
'\0';
7176 saltp = salt_8bit_clean;
7179 res =
crypt(s, saltp);
7254 char *ptr, *
p, *pend;
7257 unsigned long sum0 = 0;
7276 sum0 += (
unsigned char)*p;
7287 if (bits < (
int)
sizeof(
long)*
CHAR_BIT) {
7288 sum0 &= (((
unsigned long)1)<<bits)-1;
7312 long width, len, flen = 1, fclen = 1;
7315 const char *
f =
" ";
7316 long n,
size, llen, rlen, llen2 = 0, rlen2 = 0;
7318 int singlebyte = 1, cr;
7330 if (flen == 0 || fclen == 0) {
7335 if (width < 0 || len >= width)
return rb_str_dup(str);
7337 llen = (jflag ==
'l') ? 0 : ((jflag ==
'r') ? n : n/2);
7341 llen2 =
str_offset(f, f + flen, llen % fclen, enc, singlebyte);
7342 rlen2 =
str_offset(f, f + flen, rlen % fclen, enc, singlebyte);
7345 if ((len = llen / fclen + rlen / fclen) >=
LONG_MAX / flen ||
7346 (len *= flen) >=
LONG_MAX - llen2 - rlen2 ||
7347 (len += llen2 + rlen2) >=
LONG_MAX - size) {
7354 memset(p, *f, llen);
7358 while (llen >= fclen) {
7364 memcpy(p, f, llen2);
7371 memset(p, *f, rlen);
7375 while (rlen >= fclen) {
7381 memcpy(p, f, rlen2);
7495 return rb_ary_new3(3, str, str_new_empty(str), str_new_empty(str));
7499 if (pos == 0 &&
RSTRING_LEN(sep) == 0)
goto failed;
7545 return rb_ary_new3(3, str_new_empty(str), str_new_empty(str), str);
7573 for (i=0; i<
argc; i++) {
7598 for (i=0; i<
argc; i++) {
7711 static const char ellipsis[] =
"...";
7712 const long ellipsislen =
sizeof(ellipsis) - 1;
7715 const char *
const p =
RSTRING_PTR(str), *e = p + blen;
7716 VALUE estr, ret = 0;
7720 (e =
rb_enc_nth(p, e, len, enc)) - p == blen) {
7723 else if (len <= ellipsislen ||
7790 if (sym1 == sym2)
return Qtrue;
7888 memcpy(dest + 1, ptr, len);
7955 enum {SYM_PROC_CACHE_SIZE = 67};
7960 if (!sym_proc_cache) {
7967 index = (
id % SYM_PROC_CACHE_SIZE) << 1;
7970 if (aryp[index] == sym) {
7971 return aryp[index + 1];
7976 aryp[index + 1] = proc;
8158 switch (
TYPE(name)) {
8195 #define rb_intern(str) rb_intern_const(str)
static int str_independent(VALUE str)
#define rb_usascii_str_new2
int rb_enc_str_asciionly_p(VALUE str)
static VALUE sym_upcase(VALUE sym)
static long chopped_length(VALUE str)
VALUE rb_str_resize(VALUE str, long len)
static VALUE str_replace_shared_without_enc(VALUE str2, VALUE str)
int rb_enc_codelen(int c, rb_encoding *enc)
static VALUE rb_str_bytesize(VALUE str)
int rb_reg_backref_number(VALUE match, VALUE backref)
#define rb_tainted_str_new2
static VALUE str_buf_cat(VALUE str, const char *ptr, long len)
#define MBCLEN_CHARFOUND_P(ret)
static long rb_str_rindex(VALUE str, VALUE sub, long pos)
rb_encoding * rb_enc_check(VALUE str1, VALUE str2)
VALUE rb_ary_pop(VALUE ary)
#define MBCLEN_CHARFOUND_LEN(ret)
#define RESIZE_CAPA(str, capacity)
void rb_bug(const char *fmt,...)
#define rb_enc_mbc_to_codepoint(p, e, enc)
void rb_enc_copy(VALUE obj1, VALUE obj2)
#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
size_t strlen(const char *)
#define CHECK_IF_ASCII(c)
void rb_backref_set(VALUE)
#define ENCODING_CODERANGE_SET(obj, encindex, cr)
static int sym_printable(const char *s, const char *send, rb_encoding *enc)
VALUE rb_str_equal(VALUE str1, VALUE str2)
static int max(int a, int b)
VALUE rb_locale_str_new_cstr(const char *ptr)
VALUE rb_sym_to_s(VALUE sym)
static int coderange_scan(const char *p, long len, rb_encoding *enc)
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *eenc)
void rb_undef_alloc_func(VALUE)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static VALUE rb_str_to_f(VALUE str)
VALUE rb_str_new_frozen(VALUE orig)
static VALUE rb_str_oct(VALUE str)
st_index_t rb_str_hash(VALUE str)
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *ptr_enc)
static VALUE rb_str_scan(VALUE str, VALUE pat)
VALUE rb_locale_str_new(const char *ptr, long len)
static VALUE rb_str_gsub(int argc, VALUE *argv, VALUE str)
static VALUE rb_str_match(VALUE x, VALUE y)
RUBY_ALIAS_FUNCTION(rb_str_new2(const char *ptr), rb_str_new_cstr,(ptr))
void rb_str_set_len(VALUE str, long len)
static void rb_enc_cr_str_copy_for_substr(VALUE dest, VALUE src)
static unsigned int trnext(struct tr *t, rb_encoding *enc)
#define ENC_CODERANGE_SET(obj, cr)
#define is_broken_string(str)
static VALUE sym_swapcase(VALUE sym)
static VALUE rb_str_b(VALUE str)
static VALUE rb_str_clear(VALUE str)
rb_encoding * rb_to_encoding(VALUE enc)
#define ENC_CODERANGE_CLEAR(obj)
void rb_econv_close(rb_econv_t *ec)
#define STR_UNSET_NOCAPA(s)
VALUE rb_enc_from_encoding(rb_encoding *encoding)
int rb_enc_tolower(int c, rb_encoding *enc)
VALUE rb_str_new_with_class(VALUE, const char *, long)
static VALUE str_gsub(int argc, VALUE *argv, VALUE str, int bang)
VALUE rb_reg_match(VALUE, VALUE)
long rb_memsearch(const void *, long, const void *, long, rb_encoding *)
static VALUE rb_str_succ_bang(VALUE str)
static VALUE rb_str_enumerate_bytes(VALUE str, int wantarray)
static VALUE rb_str_each_line(int argc, VALUE *argv, VALUE str)
rb_encoding * rb_default_internal_encoding(void)
VALUE rb_ary_push(VALUE ary, VALUE item)
static VALUE str_new3(VALUE klass, VALUE str)
SSL_METHOD *(* func)(void)
VALUE rb_reg_regsub(VALUE, VALUE, struct re_registers *, VALUE)
RUBY_EXTERN char * crypt(const char *, const char *)
st_index_t rb_memhash(const void *ptr, long len)
int rb_usascii_encindex(void)
VALUE rb_str_split(VALUE str, const char *sep0)
static VALUE rb_str_prepend(VALUE str, VALUE str2)
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
static VALUE rb_str_gsub_bang(int argc, VALUE *argv, VALUE str)
VALUE rb_ary_tmp_new(long capa)
VALUE rb_str_export_to_enc(VALUE str, rb_encoding *enc)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
static VALUE rb_str_codepoints(VALUE str)
#define str_buf_cat2(str, ptr)
static VALUE rb_str_swapcase_bang(VALUE str)
static VALUE rb_str_rstrip(VALUE str)
VALUE rb_filesystem_str_new(const char *ptr, long len)
VALUE rb_str_export(VALUE str)
static VALUE rb_str_justify(int argc, VALUE *argv, VALUE str, char jflag)
static VALUE rb_str_include(VALUE str, VALUE arg)
static void rb_str_check_dummy_enc(rb_encoding *enc)
VALUE rb_backref_get(void)
#define str_make_independent(str)
VALUE rb_str_freeze(VALUE str)
long rb_enc_strlen(const char *p, const char *e, rb_encoding *enc)
unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len_p, rb_encoding *enc)
long rb_enc_strlen_cr(const char *p, const char *e, rb_encoding *enc, int *cr)
void rb_raise(VALUE exc, const char *fmt,...)
static VALUE sym_downcase(VALUE sym)
static VALUE str_replace(VALUE str, VALUE str2)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE *, VALUE)
static VALUE rb_str_to_i(int argc, VALUE *argv, VALUE str)
char * rb_string_value_ptr(volatile VALUE *ptr)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
static VALUE rb_str_slice_bang(int argc, VALUE *argv, VALUE str)
VALUE rb_str_intern(VALUE s)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
VALUE rb_ary_new3(long n,...)
static VALUE rb_str_empty(VALUE str)
static VALUE rb_str_chars(VALUE str)
static VALUE rb_str_reverse_bang(VALUE str)
void rb_include_module(VALUE klass, VALUE module)
#define ONIGENC_CODE_TO_MBC_MAXLEN
static VALUE rb_str_center(int argc, VALUE *argv, VALUE str)
static VALUE rb_str_each_char_size(VALUE str)
VALUE rb_range_beg_len(VALUE, long *, long *, long, int)
double rb_str_to_dbl(VALUE, int)
#define rb_enc_islower(c, enc)
RUBY_FUNC_EXPORTED size_t rb_str_memsize(VALUE str)
static VALUE rb_str_subpat(VALUE str, VALUE re, VALUE backref)
VALUE rb_str_new(const char *ptr, long len)
static VALUE rb_str_aset_m(int argc, VALUE *argv, VALUE str)
#define rb_enc_mbmaxlen(enc)
static VALUE rb_str_upcase_bang(VALUE str)
static VALUE rb_str_format_m(VALUE str, VALUE arg)
#define STR_SET_NOEMBED(str)
static long str_strlen(VALUE str, rb_encoding *enc)
static VALUE rb_str_chomp(int argc, VALUE *argv, VALUE str)
rb_encoding * rb_utf8_encoding(void)
VALUE rb_str_export_locale(VALUE str)
VALUE rb_str_tmp_new(long)
static VALUE sym_length(VALUE sym)
VALUE rb_str_new_shared(VALUE str)
void rb_undef_method(VALUE klass, const char *name)
VALUE rb_sym_all_symbols(void)
static VALUE empty_str_alloc(VALUE klass)
static VALUE rb_str_upcase(VALUE str)
#define ONIGENC_CTYPE_ALPHA
static VALUE rb_str_hash_m(VALUE str)
static int tr_find(unsigned int c, char table[TR_TABLE_SIZE], VALUE del, VALUE nodel)
VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts)
static VALUE rb_str_aset(VALUE str, VALUE indx, VALUE val)
#define ENC_CODERANGE_7BIT
const char * rb_obj_classname(VALUE)
VALUE rb_enc_sprintf(rb_encoding *enc, const char *format,...)
void rb_gc_force_recycle(VALUE p)
RUBY_EXTERN void * memmove(void *, const void *, size_t)
int rb_enc_toupper(int c, rb_encoding *enc)
static VALUE rb_str_insert(VALUE str, VALUE idx, VALUE str2)
VALUE rb_str_append(VALUE str, VALUE str2)
#define NEWOBJ_OF(obj, type, klass, flags)
static VALUE sym_equal(VALUE sym1, VALUE sym2)
static VALUE sym_inspect(VALUE sym)
int rb_str_hash_cmp(VALUE str1, VALUE str2)
static VALUE rb_str_partition(VALUE str, VALUE sep)
static long str_offset(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte)
#define rb_enc_isctype(c, t, enc)
static VALUE rb_str_ljust(int argc, VALUE *argv, VALUE str)
#define RB_TYPE_P(obj, type)
int rb_enc_str_coderange(VALUE str)
#define MEMZERO(p, type, n)
VALUE rb_str_plus(VALUE str1, VALUE str2)
static VALUE rb_str_setbyte(VALUE str, VALUE index, VALUE value)
rb_encoding * rb_default_external_encoding(void)
#define ONIGENC_CTYPE_DIGIT
static VALUE rb_str_capitalize_bang(VALUE str)
static VALUE rb_str_strip(VALUE str)
#define rb_intern_str(string)
int rb_block_given_p(void)
static VALUE rb_str_split_m(int argc, VALUE *argv, VALUE str)
static int single_byte_optimizable(VALUE str)
int rb_enc_fast_mbclen(const char *p, const char *e, rb_encoding *enc)
static void rb_str_splice_0(VALUE str, long beg, long len, VALUE val)
RUBY_EXTERN VALUE rb_cObject
static VALUE sym_to_sym(VALUE sym)
#define rb_enc_isascii(c, enc)
void * rb_alloc_tmp_buffer(volatile VALUE *store, long len)
VALUE rb_str_to_inum(VALUE str, int base, int badcheck)
static VALUE str_new_shared(VALUE klass, VALUE str)
VALUE rb_str_length(VALUE str)
static VALUE rb_str_rpartition(VALUE str, VALUE sep)
static VALUE rb_str_crypt(VALUE str, VALUE salt)
static VALUE rb_str_cmp_m(VALUE str1, VALUE str2)
int rb_str_symname_p(VALUE sym)
VALUE rb_str_new_cstr(const char *ptr)
static void str_modify_keep_cr(VALUE str)
rb_econv_t * rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE ecopts)
#define STR_SET_EMBED(str)
static VALUE rb_str_tr_s(VALUE str, VALUE src, VALUE repl)
static VALUE rb_str_delete(int argc, VALUE *argv, VALUE str)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
#define rb_enc_step_back(s, p, e, n, enc)
void rb_enc_set_index(VALUE obj, int idx)
static VALUE rb_str_each_byte_size(VALUE str, VALUE args)
static VALUE rb_str_enumerate_chars(VALUE str, int wantarray)
static VALUE rb_str_enumerate_lines(int argc, VALUE *argv, VALUE str, int wantarray)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static VALUE rb_str_tr_s_bang(VALUE str, VALUE src, VALUE repl)
#define RUBY_DTRACE_STRING_CREATE_ENABLED()
VALUE rb_str_concat(VALUE str1, VALUE str2)
static VALUE rb_str_strip_bang(VALUE str)
VALUE rb_cEncodingConverter
long rb_str_offset(VALUE str, long pos)
#define STR_SET_EMBED_LEN(str, n)
#define ALLOCA_N(type, n)
#define range(low, item, hi)
#define ENC_CODERANGE_UNKNOWN
void rb_gc_register_mark_object(VALUE obj)
static VALUE rb_str_tr_bang(VALUE str, VALUE src, VALUE repl)
#define rb_enc_isprint(c, enc)
#define RUBY_FUNC_EXPORTED
#define MEMCPY(p1, p2, type, n)
#define ENC_CODERANGE_BROKEN
#define rb_enc_isupper(c, enc)
VALUE rb_obj_alloc(VALUE)
#define rb_enc_codepoint(p, e, enc)
void rb_str_update(VALUE str, long beg, long len, VALUE val)
#define rb_enc_mbminlen(enc)
static VALUE sym_call(VALUE args, VALUE sym, int argc, VALUE *argv, VALUE passed_proc)
static VALUE rb_str_rjust(int argc, VALUE *argv, VALUE str)
#define ENC_CODERANGE_VALID
long rb_str_sublen(VALUE str, long pos)
static VALUE sym_capitalize(VALUE sym)
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
VALUE rb_str_times(VALUE str, VALUE times)
int rb_enc_ascget(const char *p, const char *e, int *len, rb_encoding *enc)
static VALUE sym_cmp(VALUE sym, VALUE other)
void rb_str_modify_expand(VALUE str, long expand)
static void rb_str_splice(VALUE str, long beg, long len, VALUE val)
static VALUE str_eql(const VALUE str1, const VALUE str2)
static VALUE sym_encoding(VALUE sym)
static VALUE rb_str_swapcase(VALUE str)
VALUE rb_obj_as_string(VALUE obj)
VALUE rb_str_subseq(VALUE str, long beg, long len)
#define REALLOC_N(var, type, n)
char * rb_string_value_cstr(volatile VALUE *ptr)
#define RUBY_MAX_CHAR_LEN
static VALUE rb_str_byteslice(int argc, VALUE *argv, VALUE str)
VALUE rb_check_funcall(VALUE, ID, int, VALUE *)
VALUE rb_funcall2(VALUE, ID, int, const VALUE *)
Calls a method.
VALUE rb_str_format(int, const VALUE *, VALUE)
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
int rb_enc_unicode_p(rb_encoding *enc)
#define RSTRING_EMBED_LEN_MAX
int rb_enc_symname_p(const char *name, rb_encoding *enc)
static VALUE rb_str_tr(VALUE str, VALUE src, VALUE repl)
static VALUE rb_str_chop_bang(VALUE str)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE rb_str_enumerate_codepoints(VALUE str, int wantarray)
static VALUE rb_str_squeeze(int argc, VALUE *argv, VALUE str)
long rb_reg_search(VALUE, VALUE, long, int)
static VALUE str_duplicate(VALUE klass, VALUE str)
VALUE rb_check_hash_type(VALUE hash)
int rb_str_cmp(VALUE str1, VALUE str2)
unsigned char buf[MIME_BUF_SIZE]
VALUE rb_str_buf_new_cstr(const char *ptr)
rb_encoding * rb_usascii_encoding(void)
static VALUE rb_str_aref_m(int argc, VALUE *argv, VALUE str)
static VALUE sym_to_proc(VALUE sym)
static VALUE rb_str_squeeze_bang(int argc, VALUE *argv, VALUE str)
static VALUE get_pat(VALUE, int)
VALUE rb_str_buf_cat(VALUE str, const char *ptr, long len)
static enum neighbor_char enc_pred_char(char *p, long len, rb_encoding *enc)
rb_encoding * rb_locale_encoding(void)
VALUE rb_str_replace(VALUE str, VALUE str2)
static VALUE rb_str_lstrip_bang(VALUE str)
#define rb_enc_is_newline(p, end, enc)
static VALUE str_new(VALUE klass, const char *ptr, long len)
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
static VALUE str_alloc(VALUE klass)
#define UNINITIALIZED_VAR(x)
static VALUE rb_str_sub_bang(int argc, VALUE *argv, VALUE str)
VALUE rb_str_buf_cat2(VALUE str, const char *ptr)
#define ENC_CODERANGE_AND(a, b)
static VALUE rb_str_is_ascii_only_p(VALUE str)
void rb_str_shared_replace(VALUE str, VALUE str2)
VALUE rb_obj_encoding(VALUE obj)
static int rb_enc_dummy_p(rb_encoding *enc)
#define RUBY_DTRACE_STRING_CREATE(arg0, arg1, arg2)
#define rb_enc_asciicompat(enc)
static VALUE rb_str_chomp_bang(int argc, VALUE *argv, VALUE str)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
VALUE rb_str_buf_cat_ascii(VALUE str, const char *ptr)
int memcmp(const void *s1, const void *s2, size_t len)
VALUE rb_str_quote_unprintable(VALUE str)
static VALUE sym_casecmp(VALUE sym, VALUE other)
long rb_str_coderange_scan_restartable(const char *s, const char *e, rb_encoding *enc, int *cr)
static char * str_nth_len(const char *p, const char *e, long *nthp, rb_encoding *enc)
#define RARRAY_LENINT(ary)
static VALUE rb_str_getbyte(VALUE str, VALUE index)
static void rb_enc_cr_str_exact_copy(VALUE dest, VALUE src)
void rb_sys_fail(const char *mesg)
static VALUE rb_str_chr(VALUE str)
#define ENCODING_IS_ASCII8BIT(obj)
static const char * search_nonascii(const char *p, const char *e)
static void str_modifiable(VALUE str)
static VALUE rb_str_bytes(VALUE str)
static VALUE rb_str_index_m(int argc, VALUE *argv, VALUE str)
VALUE rb_str_to_str(VALUE str)
static VALUE rb_str_match_m(int argc, VALUE *argv, VALUE str)
static void str_mod_check(VALUE s, const char *p, long len)
VALUE rb_string_value(volatile VALUE *ptr)
static VALUE rb_str_lines(int argc, VALUE *argv, VALUE str)
VALUE rb_tainted_str_new_cstr(const char *ptr)
static const char isspacetable[256]
int rb_respond_to(VALUE, ID)
static VALUE scan_once(VALUE str, VALUE pat, long *start)
static VALUE rb_str_sub(int argc, VALUE *argv, VALUE str)
VALUE rb_usascii_str_new(const char *ptr, long len)
VALUE rb_str_buf_append(VALUE str, VALUE str2)
static VALUE rb_str_s_try_convert(VALUE dummy, VALUE str)
RUBY_EXTERN VALUE rb_default_rs
static VALUE sym_succ(VALUE sym)
void rb_str_free(VALUE str)
VALUE rb_filesystem_str_new_cstr(const char *ptr)
static VALUE rb_str_end_with(int argc, VALUE *argv, VALUE str)
#define rb_enc_right_char_head(s, p, e, enc)
static void str_enc_copy(VALUE str1, VALUE str2)
#define ENCODING_GET(obj)
VALUE rb_equal(VALUE, VALUE)
rb_encoding * rb_enc_get(VALUE obj)
static VALUE rb_str_hex(VALUE str)
char * rb_enc_nth(const char *p, const char *e, long nth, rb_encoding *enc)
static char * str_nth(const char *p, const char *e, long nth, rb_encoding *enc, int singlebyte)
static VALUE rb_str_reverse(VALUE str)
#define rb_check_arity(argc, min, max)
static VALUE rb_str_downcase(VALUE str)
#define UNLIMITED_ARGUMENTS
VALUE rb_str_unlocktmp(VALUE str)
#define MBCLEN_INVALID_P(ret)
static VALUE rb_str_valid_encoding_p(VALUE str)
static VALUE rb_str_each_byte(VALUE str)
static VALUE rb_str_chop(VALUE str)
rb_econv_result_t rb_econv_convert(rb_econv_t *ec, const unsigned char **source_buffer_ptr, const unsigned char *source_buffer_end, unsigned char **destination_buffer_ptr, unsigned char *destination_buffer_end, int flags)
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
static VALUE rb_str_count(int argc, VALUE *argv, VALUE str)
#define STR_SET_LEN(str, n)
static VALUE rb_str_eql(VALUE str1, VALUE str2)
static void rb_str_subpat_set(VALUE str, VALUE re, VALUE backref, VALUE val)
static long enc_strlen(const char *p, const char *e, rb_encoding *enc, int cr)
static VALUE rb_str_lstrip(VALUE str)
VALUE rb_check_array_type(VALUE ary)
VALUE rb_hash_aref(VALUE hash, VALUE key)
static enum neighbor_char enc_succ_alnum_char(char *p, long len, rb_encoding *enc, char *carry)
static VALUE sym_match(VALUE sym, VALUE other)
VALUE rb_reg_quote(VALUE)
static long rb_str_index(VALUE str, VALUE sub, long offset)
#define ENC_CODERANGE(obj)
static VALUE rb_str_upto(int argc, VALUE *argv, VALUE beg)
static VALUE str_byte_substr(VALUE str, long beg, long len)
VALUE rb_str_cat(VALUE str, const char *ptr, long len)
long rb_str_strlen(VALUE str)
static VALUE tr_trans(VALUE str, VALUE src, VALUE repl, int sflag)
int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
VALUE rb_proc_new(VALUE(*)(ANYARGS), VALUE)
VALUE rb_str_locktmp(VALUE)
static VALUE rb_str_capitalize(VALUE str)
VALUE rb_str_drop_bytes(VALUE str, long len)
size_t rb_str_capacity(VALUE str)
rb_encoding * rb_filesystem_encoding(void)
static VALUE rb_str_init(int argc, VALUE *argv, VALUE str)
void rb_define_variable(const char *, VALUE *)
void rb_str_setter(VALUE val, ID id, VALUE *var)
static VALUE rb_str_rstrip_bang(VALUE str)
static VALUE rb_str_each_char(VALUE str)
#define rb_enc_left_char_head(s, p, e, enc)
static VALUE str_replace_shared(VALUE str2, VALUE str)
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
static void str_make_independent_expand(VALUE str, long expand)
VALUE rb_ary_concat(VALUE x, VALUE y)
static unsigned int hash(const char *str, unsigned int len)
#define RETURN_ENUMERATOR(obj, argc, argv)
static VALUE rb_str_start_with(int argc, VALUE *argv, VALUE str)
VALUE rb_ary_new2(long capa)
VALUE rb_str_substr(VALUE str, long beg, long len)
static void str_discard(VALUE str)
#define RREGEXP_SRC_LEN(r)
void rb_must_asciicompat(VALUE str)
#define assert(condition)
VALUE rb_str_associated(VALUE str)
const char * rb_id2name(ID id)
static VALUE sym_empty(VALUE sym)
static VALUE rb_str_to_s(VALUE str)
static VALUE str_byte_aref(VALUE str, VALUE indx)
VALUE rb_external_str_new(const char *ptr, long len)
void rb_str_associate(VALUE str, VALUE add)
#define rb_enc_to_index(enc)
VALUE rb_str_succ(VALUE orig)
rb_encoding * rb_ascii8bit_encoding(void)
static VALUE rb_str_downcase_bang(VALUE str)
static VALUE rb_enc_cr_str_buf_cat(VALUE str, const char *ptr, long len, int ptr_encindex, int ptr_cr, int *ptr_cr_ret)
void rb_warning(const char *fmt,...)
#define rb_check_frozen(obj)
#define CONST_ID(var, str)
static VALUE rb_str_sum(int argc, VALUE *argv, VALUE str)
VALUE rb_str_inspect(VALUE str)
void rb_free_tmp_buffer(volatile VALUE *store)
static void tr_setup_table(VALUE str, char stable[TR_TABLE_SIZE], int first, VALUE *tablep, VALUE *ctablep, rb_encoding *enc)
VALUE rb_obj_freeze(VALUE)
#define SPECIAL_CONST_P(x)
#define is_ascii_string(str)
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
VALUE rb_str_buf_new(long capa)
int rb_num_to_uint(VALUE val, unsigned int *ret)
VALUE rb_tainted_str_new(const char *, long)
static VALUE rb_str_casecmp(VALUE str1, VALUE str2)
#define ONIGERR_INVALID_CODE_POINT_VALUE
int rb_str_comparable(VALUE str1, VALUE str2)
#define rb_enc_mbcput(c, buf, enc)
VALUE rb_str_cat2(VALUE str, const char *ptr)
static char * rb_str_subpos(VALUE str, long beg, long *lenp)
VALUE rb_str_ord(VALUE s)
VALUE rb_str_locktmp_ensure(VALUE str, VALUE(*func)(VALUE), VALUE arg)
#define rb_str_dup_frozen
static VALUE sym_aref(int argc, VALUE *argv, VALUE sym)
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
VALUE rb_invcmp(VALUE x, VALUE y)
VALUE rb_str_resurrect(VALUE str)
static VALUE rb_str_aref(VALUE str, VALUE indx)
VALUE rb_check_string_type(VALUE str)
VALUE rb_id_quote_unprintable(ID id)
VALUE rb_reg_regcomp(VALUE)
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static VALUE rb_str_delete_bang(int, VALUE *, VALUE)
void rb_warn(const char *fmt,...)
VALUE rb_str_ellipsize(VALUE str, long len)
Shortens str and adds three dots, an ellipsis, if it is longer than len characters.
#define rb_enc_prev_char(s, p, e, enc)
static VALUE rb_str_force_encoding(VALUE str, VALUE enc)
rb_encoding * rb_enc_find(const char *name)
VALUE rb_str_dump(VALUE str)
static VALUE rb_str_rindex_m(int argc, VALUE *argv, VALUE str)
VALUE rb_reg_nth_match(int, VALUE)
static VALUE rb_str_each_codepoint(VALUE str)
void rb_str_modify(VALUE str)
VALUE rb_usascii_str_new_cstr(const char *)
VALUE rb_enc_str_new(const char *ptr, long len, rb_encoding *enc)
static enum neighbor_char enc_succ_char(char *p, long len, rb_encoding *enc)
VALUE rb_external_str_new_cstr(const char *ptr)
rb_encoding * rb_enc_from_index(int index)
VALUE rb_obj_class(VALUE)
VALUE rb_str_dup(VALUE str)