20 #define BEG(no) (regs->beg[(no)])
21 #define END(no) (regs->end[(no)])
30 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
32 #undef rb_str_new_cstr
33 #undef rb_tainted_str_new_cstr
34 #undef rb_usascii_str_new_cstr
35 #undef rb_external_str_new_cstr
36 #undef rb_locale_str_new_cstr
41 #undef rb_tainted_str_new2
42 #undef rb_usascii_str_new2
43 #undef rb_str_dup_frozen
44 #undef rb_str_buf_new_cstr
45 #undef rb_str_buf_new2
46 #undef rb_str_buf_cat2
54 #define RUBY_MAX_CHAR_LEN 16
55 #define STR_TMPLOCK FL_USER7
56 #define STR_NOEMBED FL_USER1
57 #define STR_SHARED FL_USER2
58 #define STR_ASSOC FL_USER3
59 #define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
60 #define STR_ASSOC_P(s) FL_ALL((s), STR_NOEMBED|STR_ASSOC)
61 #define STR_NOCAPA (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
62 #define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
63 #define STR_UNSET_NOCAPA(s) do {\
64 if (FL_TEST((s),STR_NOEMBED)) FL_UNSET((s),(ELTS_SHARED|STR_ASSOC));\
68 #define STR_SET_NOEMBED(str) do {\
69 FL_SET((str), STR_NOEMBED);\
70 STR_SET_EMBED_LEN((str), 0);\
72 #define STR_SET_EMBED(str) FL_UNSET((str), STR_NOEMBED)
73 #define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
74 #define STR_SET_EMBED_LEN(str, n) do { \
76 RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK;\
77 RBASIC(str)->flags |= (tmp_n) << RSTRING_EMBED_LEN_SHIFT;\
80 #define STR_SET_LEN(str, n) do { \
81 if (STR_EMBED_P(str)) {\
82 STR_SET_EMBED_LEN((str), (n));\
85 RSTRING(str)->as.heap.len = (n);\
89 #define STR_DEC_LEN(str) do {\
90 if (STR_EMBED_P(str)) {\
91 long n = RSTRING_LEN(str);\
93 STR_SET_EMBED_LEN((str), n);\
96 RSTRING(str)->as.heap.len--;\
100 #define RESIZE_CAPA(str,capacity) do {\
101 if (STR_EMBED_P(str)) {\
102 if ((capacity) > RSTRING_EMBED_LEN_MAX) {\
103 char *tmp = ALLOC_N(char, (capacity)+1);\
104 memcpy(tmp, RSTRING_PTR(str), RSTRING_LEN(str));\
105 RSTRING(str)->as.heap.ptr = tmp;\
106 RSTRING(str)->as.heap.len = RSTRING_LEN(str);\
107 STR_SET_NOEMBED(str);\
108 RSTRING(str)->as.heap.aux.capa = (capacity);\
112 REALLOC_N(RSTRING(str)->as.heap.ptr, char, (capacity)+1);\
113 if (!STR_NOCAPA_P(str))\
114 RSTRING(str)->as.heap.aux.capa = (capacity);\
118 #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
119 #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
121 #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str))
143 static inline const char *
146 #if SIZEOF_VALUE == 8
147 # define NONASCII_MASK 0x8080808080808080ULL
148 #elif SIZEOF_VALUE == 4
149 # define NONASCII_MASK 0x80808080UL
152 if ((
int)
sizeof(
VALUE) * 2 < e - p) {
155 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
156 while (p < (
const char *)s) {
163 if (*s & NONASCII_MASK) {
183 const char *e = p +
len;
363 return RSTRING(str)->as.heap.len;
366 return RSTRING(str)->as.heap.aux.capa;
376 str->as.heap.ptr = 0;
377 str->as.heap.len = 0;
378 str->as.heap.aux.capa = 0;
441 #define rb_str_new2 rb_str_new_cstr
452 #define rb_usascii_str_new2 rb_usascii_str_new_cstr
473 #define rb_tainted_str_new2 rb_tainted_str_new_cstr
482 const unsigned char *sp;
486 if (from == to)
return str;
511 len = len < 2 ? 2 : len * 2;
615 RSTRING(str2)->as.heap.aux.shared = str;
645 #define rb_str_new3 rb_str_new_shared
660 RSTRING(str2)->as.heap.aux.shared = shared;
664 RSTRING(str)->as.heap.aux.shared = str2;
682 if ((ofs > 0) || (klass !=
RBASIC(str)->klass) ||
686 RSTRING(str)->as.heap.ptr += ofs;
687 RSTRING(str)->as.heap.len -= ofs;
700 str = str_new4(klass, orig);
702 RSTRING(str)->as.heap.aux.shared = assoc;
705 str = str_new4(klass, orig);
712 #define rb_str_new4 rb_str_new_frozen
722 #define rb_str_new5 rb_str_new_with_class
725 str_new_empty(
VALUE str)
733 #define STR_BUF_MIN_SIZE 128
744 RSTRING(str)->as.heap.aux.capa = capa;
746 RSTRING(str)->as.heap.ptr[0] =
'\0';
764 #define rb_str_buf_new2 rb_str_buf_new_cstr
800 return RSTRING(str)->as.heap.aux.capa;
820 if (str == str2)
return;
839 RSTRING(str)->as.heap.aux.shared =
RSTRING(str2)->as.heap.aux.shared;
885 RSTRING(str)->as.heap.aux.shared = shared;
928 if (argc > 0 &&
rb_scan_args(argc, argv,
"01", &orig) == 1)
973 for (c=0; p<e; c++) {
1023 for (c=0; p<e; c++) {
1041 #ifdef NONASCII_MASK
1042 #define is_utf8_lead_byte(c) (((c)&0xC0) != 0x80)
1057 count_utf8_lead_bytes_with_word(
const VALUE *s)
1064 d &= NONASCII_MASK >> 7;
1069 #if SIZEOF_VALUE == 8
1088 #ifdef NONASCII_MASK
1093 if ((
int)
sizeof(
VALUE) * 2 < e - p) {
1096 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
1098 while (p < (
const char *)s) {
1099 if (is_utf8_lead_byte(*p)) len++;
1103 len += count_utf8_lead_bytes_with_word(s);
1106 p = (
const char *)s;
1109 if (is_utf8_lead_byte(*p)) len++;
1237 while (n <= len/2) {
1238 memcpy(ptr2 + n, ptr2, n);
1241 memcpy(ptr2 + n, ptr2, len-n);
1301 long capa = len + expand;
1303 if (len > capa) len = capa;
1304 ptr =
ALLOC_N(
char, capa + 1);
1311 RSTRING(str)->as.heap.ptr = ptr;
1313 RSTRING(str)->as.heap.aux.capa = capa;
1316 #define str_make_independent(str) str_make_independent_expand((str), 0L)
1335 else if (expand > 0) {
1337 long capa = len + expand;
1340 RSTRING(str)->as.heap.aux.capa = capa;
1366 RSTRING(str)->as.heap.ptr = 0;
1367 RSTRING(str)->as.heap.len = 0;
1385 assoc =
RSTRING(assoc)->as.heap.aux.shared;
1407 return RSTRING(str)->as.heap.aux.shared;
1437 if (!s || memchr(s, 0, len)) {
1483 const char *p2, *e2;
1486 while (p < e && 0 < nth) {
1512 while (p < e && nth--) {
1544 const char *pp =
str_nth(p, e, nth, enc, singlebyte);
1545 if (!pp)
return e -
p;
1556 #ifdef NONASCII_MASK
1558 str_utf8_nth(
const char *
p,
const char *e,
long *nthp)
1564 s = (
const VALUE*)(~lowbits & ((
VALUE)p + lowbits));
1566 while (p < (
const char *)s) {
1567 if (is_utf8_lead_byte(*p)) nth--;
1571 nth -= count_utf8_lead_bytes_with_word(s);
1573 }
while (s < t && (
int)
sizeof(
VALUE) <= nth);
1577 if (is_utf8_lead_byte(*p)) {
1578 if (nth == 0)
break;
1588 str_utf8_offset(
const char *p,
const char *e,
long nth)
1590 const char *pp = str_utf8_nth(p, e, &nth);
1634 if (len < 0)
return Qnil;
1642 if (beg < 0)
return Qnil;
1655 if (len > -beg) len = -beg;
1660 if (!p)
return Qnil;
1662 if (!p)
return Qnil;
1668 if (beg < 0)
return Qnil;
1678 #ifdef NONASCII_MASK
1681 p = str_utf8_nth(s, e, &beg);
1682 if (beg > 0)
return Qnil;
1683 len = str_utf8_offset(p, e, len);
1689 p = s + beg * char_sz;
1693 else if (len * char_sz > e - p)
1698 else if ((p =
str_nth_len(s, e, &beg, enc)) == e) {
1699 if (beg > 0)
return Qnil;
1732 #define rb_str_dup_frozen rb_str_new_frozen
1771 rb_bug(
"probable buffer overflow: %ld for %ld", len, capa);
1801 char *ptr =
RSTRING(str)->as.heap.ptr;
1803 if (slen > len) slen =
len;
1804 if (slen > 0)
MEMCPY(
RSTRING(str)->as.ary, ptr,
char, slen);
1807 if (independent)
xfree(ptr);
1810 else if (!independent) {
1813 else if (slen < len || slen - len > 1024) {
1828 long capa, total, off = -1;
1834 if (len == 0)
return 0;
1843 capa =
RSTRING(str)->as.heap.aux.capa;
1849 if (capa <= total) {
1850 while (total > capa) {
1852 capa = (total + 4095) / 4096;
1855 capa = (capa + 1) * 2;
1869 #define str_buf_cat2(str, ptr) str_buf_cat((str), (ptr), strlen(ptr))
1874 if (len == 0)
return str;
1896 p =
RSTRING(str)->as.heap.ptr;
1897 memcpy(p +
RSTRING(str)->as.heap.len, ptr, len);
1914 int ptr_encindex,
int ptr_cr,
int *ptr_cr_ret)
1922 if (str_encindex == ptr_encindex) {
1952 *ptr_cr_ret = ptr_cr;
1954 if (str_encindex != ptr_encindex &&
1964 res_encindex = str_encindex;
1969 res_encindex = str_encindex;
1973 res_encindex = ptr_encindex;
1978 res_encindex = str_encindex;
1985 res_encindex = str_encindex;
2018 unsigned int c = (
unsigned char)*ptr;
2109 buf[0] = (char)code;
2205 #define lesser(a,b) (((a)>(b))?(b):(a))
2217 if (idx1 == idx2)
return TRUE;
2236 const char *ptr1, *ptr2;
2239 if (str1 == str2)
return 0;
2242 if (ptr1 == ptr2 || (retval =
memcmp(ptr1, ptr2,
lesser(len1, len2))) == 0) {
2251 if (len1 > len2)
return 1;
2254 if (retval > 0)
return 1;
2263 const char *ptr1, *ptr2;
2269 if (
memcmp(ptr1, ptr2, len) == 0)
2285 if (str1 == str2)
return Qtrue;
2305 if (str1 == str2)
return Qtrue;
2378 char *p1, *p1end, *p2, *p2end;
2389 while (p1 < p1end && p2 < p2end) {
2391 unsigned int c1 =
TOUPPER(*p1 & 0xff);
2392 unsigned int c2 =
TOUPPER(*p2 & 0xff);
2394 return INT2FIX(c1 < c2 ? -1 : 1);
2401 while (p1 < p1end && p2 < p2end) {
2405 if (0 <= c1 && 0 <= c2) {
2409 return INT2FIX(c1 < c2 ? -1 : 1);
2415 len = l1 < l2 ? l1 : l2;
2418 return INT2FIX(r < 0 ? -1 : 1);
2420 return INT2FIX(l1 < l2 ? -1 : 1);
2447 if (offset < 0)
return -1;
2449 if (len - offset < slen)
return -1;
2456 if (slen == 0)
return offset;
2464 if (pos < 0)
return pos;
2466 if (t == s + pos)
break;
2467 if ((len -= t - s) <= 0)
return -1;
2471 return pos + offset;
2499 if (
rb_scan_args(argc, argv,
"11", &sub, &initpos) == 2) {
2515 switch (
TYPE(sub)) {
2543 if (pos == -1)
return Qnil;
2551 char *s, *sbeg, *e, *t;
2562 if (len < slen)
return -1;
2563 if (len - pos < slen) {
2573 s =
str_nth(sbeg, e, pos, enc, singlebyte);
2575 if (
memcmp(s, t, slen) == 0) {
2578 if (pos == 0)
break;
2612 if (
rb_scan_args(argc, argv,
"11", &sub, &vpos) == 2) {
2623 if (pos > len) pos =
len;
2629 switch (
TYPE(sub)) {
2639 if (pos >= 0)
return LONG2NUM(pos);
2655 if (pos >= 0)
return LONG2NUM(pos);
2750 for (i = len-1; 0 <= i && (
unsigned char)p[i] == 0xff; i--)
2754 ++((
unsigned char*)p)[
i];
2762 memset(p+l, 0xff, len-l);
2768 for (len2 = len-1; 0 < len2; len2--) {
2773 memset(p+len2+1, 0xff, len-(len2+1));
2784 for (i = len-1; 0 <= i && (
unsigned char)p[i] == 0; i--)
2788 --((
unsigned char*)p)[
i];
2796 memset(p+l, 0, len-l);
2802 for (len2 = len-1; 0 < len2; len2--) {
2807 memset(p+len2+1, 0, len-(len2+1));
2838 MEMCPY(save, p,
char, len);
2845 MEMCPY(p, save,
char, len);
2848 MEMCPY(save, p,
char, len);
2853 MEMCPY(p, save,
char, len);
2858 MEMCPY(p, save,
char, len);
2868 MEMCPY(carry, p,
char, len);
2872 MEMCPY(carry, p,
char, len);
2908 char *sbeg, *s, *e, *last_alnum = 0;
2912 long carry_pos = 0, carry_len = 1;
2944 carry_pos = s - sbeg;
2960 MEMCPY(carry, s,
char, l);
2963 carry_pos = s - sbeg;
3030 VALUE end, exclusive;
3031 VALUE current, after_end;
3038 excl =
RTEST(exclusive);
3048 if (c > e || (excl && c == e))
return beg;
3051 if (!excl && c == e)
break;
3053 if (excl && c == e)
break;
3082 if (excl && bi == ei)
break;
3103 if (n > 0 || (excl && n == 0))
return beg;
3112 if (
NIL_P(next))
break;
3139 switch (
TYPE(indx)) {
3251 if (len > olen) len = olen;
3259 memmove(ptr, oldptr + len, nlen);
3265 RSTRING(str)->as.heap.len = nlen;
3330 if (slen < len || slen < beg + len) {
3359 long start, end,
len;
3397 switch (
TYPE(indx)) {
3533 if (argc < 1 || 2 < argc) {
3536 for (i=0; i<
argc; i++) {
3541 if (!
NIL_P(result)) {
3553 switch (
TYPE(pat)) {
3598 else if (argc == 2) {
3623 if (iter || !
NIL_P(hash)) {
3671 memmove(p + beg0 + rlen, p + beg0 + plen, len - beg0 - plen);
3673 memcpy(p + beg0, rp, rlen);
3742 long offset, blen, slen,
len,
last;
3768 if (bang)
return Qnil;
3789 if (iter || !
NIL_P(hash)) {
3825 offset = end0 +
len;
3864 return str_gsub(argc, argv, str, 1);
3914 return str_gsub(argc, argv, str, 0);
3933 if (str == str2)
return str;
4030 if (beg > n || len < 0)
return Qnil;
4033 if (beg < 0)
return Qnil;
4082 switch (
TYPE(indx)) {
4179 if (clen > 1 || (*s & 0x80)) single = 0;
4189 if (clen > 1 || (*s & 0x80)) single = 0;
4266 if (i == -1)
return Qfalse;
4297 if (argc == 0) base = 10;
4361 #define CHAR_ESC_LEN 13
4376 else if (c < 0x10000) {
4412 const char *
p, *pend, *prev;
4430 const unsigned char *q = (
const unsigned char *)p;
4431 if (q[0] == 0xFE && q[1] == 0xFF)
4433 else if (q[0] == 0xFF && q[1] == 0xFE)
4438 else if (enc == utf32) {
4439 const unsigned char *q = (
const unsigned char *)p;
4440 if (q[0] == 0 && q[1] == 0 && q[2] == 0xFE && q[3] == 0xFF)
4442 else if (q[3] == 0 && q[2] == 0 && q[1] == 0xFE && q[0] == 0xFF)
4453 if (p > prev)
str_buf_cat(result, prev, p - prev);
4456 n = (int)(pend - p);
4467 if ((asciicompat || unicode_p) &&
4468 (c ==
'"'|| c ==
'\\' ||
4473 (cc ==
'$' || cc ==
'@' || cc ==
'{'))))) {
4474 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4476 if (asciicompat || enc == resenc) {
4482 case '\n': cc =
'n';
break;
4483 case '\r': cc =
'r';
break;
4484 case '\t': cc =
't';
break;
4485 case '\f': cc =
'f';
break;
4486 case '\013': cc =
'v';
break;
4487 case '\010': cc =
'b';
break;
4488 case '\007': cc =
'a';
break;
4489 case 033: cc =
'e';
break;
4490 default: cc = 0;
break;
4493 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4505 if (p - n > prev)
str_buf_cat(result, prev, p - n - prev);
4511 if (p > prev)
str_buf_cat(result, prev, p - prev);
4518 #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{'))
4533 const char *
p, *pend;
4541 unsigned char c = *p++;
4543 case '"':
case '\\':
4544 case '\n':
case '\r':
4545 case '\t':
case '\f':
4546 case '\013':
case '\010':
case '\007':
case '\033':
4563 while (cc >>= 4) len++;
4585 unsigned char c = *p++;
4587 if (c ==
'"' || c ==
'\\') {
4591 else if (c ==
'#') {
4592 if (
IS_EVSTR(p, pend)) *q++ =
'\\';
4595 else if (c ==
'\n') {
4599 else if (c ==
'\r') {
4603 else if (c ==
'\t') {
4607 else if (c ==
'\f') {
4611 else if (c ==
'\013') {
4615 else if (c ==
'\010') {
4619 else if (c ==
'\007') {
4623 else if (c ==
'\033') {
4649 snprintf(q, qend-q,
".force_encoding(\"%s\")", enc->
name);
4692 unsigned int c = *(
unsigned char*)s;
4695 *s =
'A' + (c -
'a');
4707 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
4709 *s =
'A' + (c -
'a');
4726 if (modify)
return str;
4774 unsigned int c = *(
unsigned char*)s;
4777 *s =
'a' + (c -
'A');
4790 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
4792 *s =
'a' + (c -
'A');
4809 if (modify)
return str;
4879 if (modify)
return str;
4943 if (modify)
return str;
4983 if (t->
p == t->
pend)
return -1;
4984 if (t->
p < t->
pend - 1 && *t->
p ==
'\\') {
4989 if (t->
p < t->
pend - 1 && *t->
p ==
'-') {
4991 if (t->
p < t->
pend) {
4995 if (t->
now < 0x80 && c < 0x80) {
4997 "invalid range \"%c-%c\" in string transliteration",
5011 else if (++t->
now < t->
max) {
5026 const unsigned int errc = -1;
5027 unsigned int trans[256];
5029 struct tr trsrc, trrepl;
5031 unsigned int c, c0,
last = 0;
5032 int modify = 0,
i, l;
5038 #define CHECK_IF_ASCII(c) \
5039 (void)((cr == ENC_CODERANGE_7BIT && !rb_isascii(c)) ? \
5040 (cr = ENC_CODERANGE_VALID) : 0)
5061 trsrc.
p + l < trsrc.
pend) {
5067 trsrc.
gen = trrepl.
gen = 0;
5068 trsrc.
now = trrepl.
now = 0;
5069 trsrc.
max = trrepl.
max = 0;
5072 for (
i=0;
i<256;
i++) {
5075 while ((c =
trnext(&trsrc, enc)) != errc) {
5084 while ((c =
trnext(&trrepl, enc)) != errc)
5087 for (
i=0;
i<256;
i++) {
5088 if (trans[
i] != errc) {
5096 for (
i=0;
i<256;
i++) {
5099 while ((c =
trnext(&trsrc, enc)) != errc) {
5100 r =
trnext(&trrepl, enc);
5101 if (r == errc) r = trrepl.
now;
5120 unsigned int save = -1;
5136 if (cflag) c =
last;
5139 else if (cflag) c = errc;
5145 if (c != (
unsigned int)-1) {
5157 if (enc != e1) may_modify = 1;
5159 while (t - buf + tlen >= max) {
5166 if (may_modify &&
memcmp(s, t, tlen) != 0) {
5183 c = (
unsigned char)*s;
5184 if (trans[c] != errc) {
5215 if (cflag) c =
last;
5218 else if (cflag) c = errc;
5222 c = cflag ? last : errc;
5230 if (enc != e1) may_modify = 1;
5232 while (t - buf + tlen >= max) {
5240 if (may_modify &&
memcmp(s, t, tlen) != 0) {
5280 return tr_trans(str, src, repl, 0);
5312 #define TR_TABLE_SIZE 257
5317 const unsigned int errc = -1;
5321 VALUE table = 0, ptable = 0;
5322 int i, l, cflag = 0;
5332 for (i=0; i<256; i++) {
5335 stable[256] = cflag;
5337 else if (stable[256] && !cflag) {
5340 for (i=0; i<256; i++) {
5344 while ((c =
trnext(&tr, enc)) != errc) {
5346 buf[c & 0xff] = !cflag;
5367 for (i=0; i<256; i++) {
5368 stable[
i] = stable[
i] && buf[
i];
5377 return table[c] != 0;
5409 VALUE del = 0, nodel = 0;
5411 int i, ascompat, cr;
5417 for (i=0; i<
argc; i++) {
5434 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5447 if (
tr_find(c, squeez, del, nodel)) {
5462 if (modify)
return str;
5503 VALUE del = 0, nodel = 0;
5513 for (i=0; i<
argc; i++) {
5533 unsigned int c = *(
unsigned char*)s++;
5534 if (c != save || (argc > 0 && !squeez[c])) {
5543 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5544 if (c != save || (argc > 0 && !squeez[c])) {
5552 if (c != save || (argc > 0 && !
tr_find(c, squeez, del, nodel))) {
5568 if (modify)
return str;
5608 return tr_trans(str, src, repl, 1);
5655 VALUE del = 0, nodel = 0;
5663 for (i=0; i<
argc; i++) {
5677 if (*(
unsigned char*)s++ == c) n++;
5692 if (ascompat && (c = *(
unsigned char*)s) < 0x80) {
5701 if (
tr_find(c, table, del, nodel)) {
5712 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
5713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5714 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5715 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5716 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5717 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5718 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5719 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5720 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5721 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5722 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5723 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5724 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5725 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5726 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5727 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
5730 #define ascii_isspace(c) isspacetable[(unsigned char)(c)]
5780 enum {awk, string, regexp} split_type;
5781 long beg, end,
i = 0;
5785 if (
rb_scan_args(argc, argv,
"02", &spat, &limit) == 2) {
5787 if (lim <= 0) limit =
Qnil;
5788 else if (lim == 1) {
5809 split_type = string;
5813 split_type = regexp;
5830 split_type = regexp;
5836 if (split_type == awk) {
5845 while (ptr < eptr) {
5846 c = (
unsigned char)*ptr++;
5854 if (!
NIL_P(limit) && lim <=
i)
break;
5869 while (ptr < eptr) {
5881 if (!
NIL_P(limit) && lim <= i)
break;
5896 else if (split_type ==
string) {
5910 while (ptr < eptr &&
5911 (end =
rb_memsearch(sptr, slen, ptr, eptr - ptr, enc)) >= 0) {
5914 if (t != ptr + end) {
5920 if (!
NIL_P(limit) && lim <= ++i)
break;
5934 if (start == end &&
BEG(0) ==
END(0)) {
5939 else if (last_null == 1) {
5947 if (ptr+start == ptr+len)
5957 beg = start =
END(0);
5961 for (idx=1; idx < regs->
num_regs; idx++) {
5962 if (
BEG(idx) == -1)
continue;
5963 if (
BEG(idx) ==
END(idx))
5964 tmp = str_new_empty(str);
5969 if (!
NIL_P(limit) && lim <= ++i)
break;
5974 tmp = str_new_empty(str);
5979 if (
NIL_P(limit) && lim == 0) {
6042 unsigned int newline;
6043 const char *
p, *pend, *s, *ptr;
6070 p = memchr(p,
'\n', pend - p);
6101 if (rslen == 0 && c == newline) {
6114 line =
rb_str_new5(str, s, p - s + (rslen ? rslen : n));
6119 s = p + (rslen ? rslen : n);
6201 for (i = 0; i <
len; i += n) {
6207 for (i = 0; i <
len; i += n) {
6242 const char *ptr, *
end;
6263 const char *
p, *p2, *
beg, *
end;
6267 if (beg > end)
return 0;
6350 if (len == 0)
return Qnil;
6402 while (len>0 && p[len-1] ==
'\n') {
6404 if (len>0 && p[len-1] ==
'\r')
6414 if (rslen > len)
return Qnil;
6416 if (rslen == 1 && newline ==
'\n')
6424 if (p[len-1] == newline &&
6557 while (s < t && ((c = *(t-1)) ==
'\0' ||
ascii_isspace(c))) t--;
6664 for (i=1; i < regs->
num_regs; i++) {
6710 long last = -1, prev = 0;
6802 extern char *
crypt(
const char *,
const char *);
6804 const char *s, *saltp;
6807 char salt_8bit_clean[3];
6818 if (!
ISASCII((
unsigned char)saltp[0]) || !
ISASCII((
unsigned char)saltp[1])) {
6819 salt_8bit_clean[0] = saltp[0] & 0x7f;
6820 salt_8bit_clean[1] = saltp[1] & 0x7f;
6821 salt_8bit_clean[2] =
'\0';
6822 saltp = salt_8bit_clean;
6825 res =
crypt(s, saltp);
6900 char *ptr, *
p, *pend;
6903 unsigned long sum0 = 0;
6922 sum0 += (
unsigned char)*p;
6933 if (bits < (
int)
sizeof(
long)*
CHAR_BIT) {
6934 sum0 &= (((
unsigned long)1)<<bits)-1;
6958 long width,
len, flen = 1, fclen = 1;
6961 const char *f =
" ";
6962 long n,
size, llen, rlen, llen2 = 0, rlen2 = 0;
6964 int singlebyte = 1, cr;
6976 if (flen == 0 || fclen == 0) {
6981 if (width < 0 || len >= width)
return rb_str_dup(str);
6983 llen = (jflag ==
'l') ? 0 : ((jflag ==
'r') ? n : n/2);
6987 llen2 =
str_offset(f, f + flen, llen % fclen, enc, singlebyte);
6988 rlen2 =
str_offset(f, f + flen, rlen % fclen, enc, singlebyte);
6991 if ((len = llen / fclen + rlen / fclen) >=
LONG_MAX / flen ||
6992 (len *= flen) >=
LONG_MAX - llen2 - rlen2 ||
6993 (len += llen2 + rlen2) >=
LONG_MAX - size) {
7000 memset(p, *f, llen);
7004 while (llen >= fclen) {
7010 memcpy(p, f, llen2);
7017 memset(p, *f, rlen);
7021 while (rlen >= fclen) {
7027 memcpy(p, f, rlen2);
7141 return rb_ary_new3(3, str, str_new_empty(str), str_new_empty(str));
7145 if (pos == 0 &&
RSTRING_LEN(sep) == 0)
goto failed;
7191 return rb_ary_new3(3, str_new_empty(str), str_new_empty(str), str);
7222 for (i=0; i<
argc; i++) {
7224 if (
NIL_P(tmp))
continue;
7247 for (i=0; i<
argc; i++) {
7249 if (
NIL_P(tmp))
continue;
7343 static const char ellipsis[] =
"...";
7344 const long ellipsislen =
sizeof(ellipsis) - 1;
7347 const char *
const p =
RSTRING_PTR(str), *e = p + blen;
7348 VALUE estr, ret = 0;
7352 (e =
rb_enc_nth(p, e, len, enc)) - p == blen) {
7355 else if (len <= ellipsislen ||
7422 if (sym1 == sym2)
return Qtrue;
7479 memcpy(dest + 1, ptr, len);
7546 enum {SYM_PROC_CACHE_SIZE = 67};
7551 if (!sym_proc_cache) {
7558 index = (
id % SYM_PROC_CACHE_SIZE) << 1;
7561 if (aryp[index] == sym) {
7562 return aryp[index + 1];
7567 aryp[index + 1] = proc;
7743 switch (
TYPE(name)) {
7779 #define rb_intern(str) rb_intern_const(str)