25 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
31 #define ARY_DEFAULT_SIZE 16
32 #define ARY_MAX_SIZE (LONG_MAX / (int)sizeof(VALUE))
50 # define ARY_SHARED_P(ary) \
51 (assert(!FL_TEST((ary), ELTS_SHARED) || !FL_TEST((ary), RARRAY_EMBED_FLAG)), \
52 FL_TEST((ary),ELTS_SHARED)!=0)
53 # define ARY_EMBED_P(ary) \
54 (assert(!FL_TEST((ary), ELTS_SHARED) || !FL_TEST((ary), RARRAY_EMBED_FLAG)), \
55 FL_TEST((ary), RARRAY_EMBED_FLAG)!=0)
57 #define ARY_HEAP_PTR(a) (assert(!ARY_EMBED_P(a)), RARRAY(a)->as.heap.ptr)
58 #define ARY_HEAP_LEN(a) (assert(!ARY_EMBED_P(a)), RARRAY(a)->as.heap.len)
59 #define ARY_EMBED_PTR(a) (assert(ARY_EMBED_P(a)), RARRAY(a)->as.ary)
60 #define ARY_EMBED_LEN(a) \
61 (assert(ARY_EMBED_P(a)), \
62 (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
63 (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)))
65 #define ARY_OWNS_HEAP_P(a) (!FL_TEST((a), ELTS_SHARED|RARRAY_EMBED_FLAG))
66 #define FL_SET_EMBED(a) do { \
67 assert(!ARY_SHARED_P(a)); \
68 assert(!OBJ_FROZEN(a)); \
69 FL_SET((a), RARRAY_EMBED_FLAG); \
71 #define FL_UNSET_EMBED(ary) FL_UNSET((ary), RARRAY_EMBED_FLAG|RARRAY_EMBED_LEN_MASK)
72 #define FL_SET_SHARED(ary) do { \
73 assert(!ARY_EMBED_P(ary)); \
74 FL_SET((ary), ELTS_SHARED); \
76 #define FL_UNSET_SHARED(ary) FL_UNSET((ary), ELTS_SHARED)
78 #define ARY_SET_PTR(ary, p) do { \
79 assert(!ARY_EMBED_P(ary)); \
80 assert(!OBJ_FROZEN(ary)); \
81 RARRAY(ary)->as.heap.ptr = (p); \
83 #define ARY_SET_EMBED_LEN(ary, n) do { \
85 assert(ARY_EMBED_P(ary)); \
86 assert(!OBJ_FROZEN(ary)); \
87 RBASIC(ary)->flags &= ~RARRAY_EMBED_LEN_MASK; \
88 RBASIC(ary)->flags |= (tmp_n) << RARRAY_EMBED_LEN_SHIFT; \
90 #define ARY_SET_HEAP_LEN(ary, n) do { \
91 assert(!ARY_EMBED_P(ary)); \
92 RARRAY(ary)->as.heap.len = (n); \
94 #define ARY_SET_LEN(ary, n) do { \
95 if (ARY_EMBED_P(ary)) { \
96 ARY_SET_EMBED_LEN((ary), (n)); \
99 ARY_SET_HEAP_LEN((ary), (n)); \
101 assert(RARRAY_LEN(ary) == (n)); \
103 #define ARY_INCREASE_PTR(ary, n) do { \
104 assert(!ARY_EMBED_P(ary)); \
105 assert(!OBJ_FROZEN(ary)); \
106 RARRAY(ary)->as.heap.ptr += (n); \
108 #define ARY_INCREASE_LEN(ary, n) do { \
109 assert(!OBJ_FROZEN(ary)); \
110 if (ARY_EMBED_P(ary)) { \
111 ARY_SET_EMBED_LEN((ary), RARRAY_LEN(ary)+(n)); \
114 RARRAY(ary)->as.heap.len += (n); \
118 #define ARY_CAPA(ary) (ARY_EMBED_P(ary) ? RARRAY_EMBED_LEN_MAX : \
119 ARY_SHARED_ROOT_P(ary) ? RARRAY_LEN(ary) : RARRAY(ary)->as.heap.aux.capa)
120 #define ARY_SET_CAPA(ary, n) do { \
121 assert(!ARY_EMBED_P(ary)); \
122 assert(!ARY_SHARED_P(ary)); \
123 assert(!OBJ_FROZEN(ary)); \
124 RARRAY(ary)->as.heap.aux.capa = (n); \
127 #define ARY_SHARED(ary) (assert(ARY_SHARED_P(ary)), RARRAY(ary)->as.heap.aux.shared)
128 #define ARY_SET_SHARED(ary, value) do { \
129 assert(!ARY_EMBED_P(ary)); \
130 assert(ARY_SHARED_P(ary)); \
131 assert(ARY_SHARED_ROOT_P(value)); \
132 RARRAY(ary)->as.heap.aux.shared = (value); \
134 #define RARRAY_SHARED_ROOT_FLAG FL_USER5
135 #define ARY_SHARED_ROOT_P(ary) (FL_TEST((ary), RARRAY_SHARED_ROOT_FLAG))
136 #define ARY_SHARED_NUM(ary) \
137 (assert(ARY_SHARED_ROOT_P(ary)), RARRAY(ary)->as.heap.aux.capa)
138 #define ARY_SET_SHARED_NUM(ary, value) do { \
139 assert(ARY_SHARED_ROOT_P(ary)); \
140 RARRAY(ary)->as.heap.aux.capa = (value); \
142 #define FL_SET_SHARED_ROOT(ary) do { \
143 assert(!ARY_EMBED_P(ary)); \
144 FL_SET((ary), RARRAY_SHARED_ROOT_FLAG); \
171 if (len > capacity) len = capacity;
356 for (i=0; i<n; i++) {
397 return RARRAY(ary)->as.heap.aux.capa *
sizeof(
VALUE);
440 return (
VALUE)shared;
599 rb_warn(
"block supersedes default value argument");
601 for (i=0; i<
len; i++) {
626 if (argc > 0 && argv) {
925 if (argc == 0)
return ary;
949 if (offset < 0 ||
RARRAY_LEN(ary) <= offset) {
970 if (beg < 0 || len < 0)
return Qnil;
976 if (len == 0)
return ary_new(klass, 0);
1146 if (block_given && argc == 2) {
1147 rb_warn(
"block supersedes default value argument");
1155 if (block_given)
return rb_yield(pos);
1204 rb_warn(
"given block not used");
1252 rb_warn(
"given block not used");
1268 if (!
NIL_P(tmp))
return tmp;
1345 if (len == olen)
return ary;
1407 long offset, beg,
len;
1457 if (argc == 1)
return ary;
1491 volatile VALUE ary = array;
1622 int *first = (
int *)arg[3];
1640 for (i=0; i<
max; i++) {
1642 if (i > 0 && !
NIL_P(sep))
1656 if (i > 0 && !
NIL_P(sep))
1660 switch (
TYPE(val)) {
1678 args[3] = (
VALUE)first;
1709 int untrust =
FALSE;
1724 if (
NIL_P(tmp) || tmp != val) {
1907 do *p2-- = *p1++;
while (--len > 0);
1916 return (cnt < 0) ? (len - (~cnt %
len) - 1) : (cnt %
len);
1987 VALUE rotated, *ptr, *ptr2;
2022 #define STRING_P(s) (TYPE(s) == T_STRING && CLASS_OF(s) == rb_cString)
2024 #define SORT_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(sort_opt_,type))
2025 #define SORT_OPTIMIZABLE(data, type) \
2026 (((data)->opt_inited & SORT_OPTIMIZABLE_BIT(type)) ? \
2027 ((data)->opt_methods & SORT_OPTIMIZABLE_BIT(type)) : \
2028 (((data)->opt_inited |= SORT_OPTIMIZABLE_BIT(type)), \
2029 rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
2030 ((data)->opt_methods |= SORT_OPTIMIZABLE_BIT(type))))
2035 if (
RBASIC(ary)->klass) {
2064 if ((
long)a > (
long)b)
return 1;
2065 if ((
long)a < (
long)b)
return -1;
2279 long beg,
len,
i, j;
2281 for (i=0; i<
argc; i++) {
2293 for (j=0; j<
len; j++) {
2379 for (i1 = i2 = 0; i1 <
RARRAY_LEN(ary); i1++) {
2442 for (i1 = i2 = 0; i1 <
RARRAY_LEN(ary); i1++) {
2479 if (pos >= len)
return Qnil;
2482 if (pos < 0)
return Qnil;
2537 long pos,
len, orig_len;
2544 if (len < 0)
return Qnil;
2548 if (pos < 0)
return Qnil;
2550 else if (orig_len < pos)
return Qnil;
2551 if (orig_len < pos + len) {
2552 len = orig_len - pos;
2571 goto delete_pos_len;
2662 return rejected_ary;
2742 for (i=0; i<
argc; i++) {
2753 for (j=0; j<
argc; j++) {
2756 if (
NIL_P(result)) {
2780 long elen = -1, alen,
i, j;
2785 for (i=0; i<alen; i++) {
2790 for (j=0; j<elen; j++) {
2798 for (j=0; j<elen; j++) {
2822 if (copy == orig)
return copy;
2914 VALUE item, arg1, arg2;
2915 long beg = 0, end = 0,
len = 0;
2917 int block_p =
FALSE;
2941 if (beg < 0) beg = 0;
2966 for (i=beg; i<end; i++) {
3047 VALUE ary2, tmp, *ptr, *ptr2;
3076 while (t <= len/2) {
3160 if (recur)
return Qtrue;
3185 if (ary1 == ary2)
return Qtrue;
3201 if (recur)
return Qtrue;
3220 if (ary1 == ary2)
return Qtrue;
3293 if (recur)
return Qundef;
3298 for (i=0; i<
len; i++) {
3335 if (ary1 == ary2)
return INT2FIX(0);
3339 if (len == 0)
return INT2FIX(0);
3340 if (len > 0)
return INT2FIX(1);
3395 if (
RHASH(hash)->ntbl) {
3397 RHASH(hash)->ntbl = 0;
3713 rb_warn(
"given block not used");
3741 if (
RBASIC(result)->klass) {
3798 int mod = 0, level = -1;
3804 if (level == 0)
return Qnil;
3806 result =
flatten(ary, level, &mod);
3839 int mod = 0, level = -1;
3846 result =
flatten(ary, level, &mod);
3852 #define OPTHASH_GIVEN_P(opts) \
3853 (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
3856 #define RAND_UPTO(max) (long)(rb_random_real(randgen)*(max))
3944 long n,
len,
i, j, k, idx[10];
3953 if (len == 0)
return Qnil;
3960 i = (
long)(x * len);
3967 if (n > len) n =
len;
3969 for (i = 0; i < n; ++
i) {
3975 if (n > len) n =
len;
3980 i = (
long)(rnds[0] * len);
3983 i = (
long)(rnds[0] * len);
3984 j = (
long)(rnds[1] * (len-1));
3988 i = (
long)(rnds[0] * len);
3989 j = (
long)(rnds[1] * (len-1));
3990 k = (
long)(rnds[2] * (len-2));
3993 if (j >= i) l =
i, g = ++j;
3994 if (k >= l && (++k >= g)) ++k;
4001 sorted[0] = idx[0] = (
long)(rnds[0] * len);
4002 for (i=1; i<n; i++) {
4003 k = (
long)(rnds[i] * --len);
4004 for (j = 0; j <
i; ++j) {
4005 if (k < sorted[j])
break;
4008 memmove(&sorted[j+1], &sorted[j],
sizeof(sorted[0])*(i-j));
4009 sorted[j] = idx[
i] = k;
4013 for (i=0; i<n; i++) {
4014 ptr_result[
i] = ptr[idx[
i]];
4020 RBASIC(result)->klass = 0;
4023 for (i=0; i<n; i++) {
4026 ptr_result[j] = ptr_result[
i];
4070 if (n <= 0)
return Qnil;
4073 while (
RARRAY_LEN(ary) > 0 && (n < 0 || 0 < n--)) {
4081 #define tmpbuf(n, size) rb_str_tmp_new((n)*(size))
4082 #define tmpbuf_discard(s) (rb_str_resize((s), 0L), RBASIC(s)->klass = rb_cString)
4083 #define tmpary(n) rb_ary_tmp_new(n)
4084 #define tmpary_discard(a) (ary_discard(a), RBASIC(a)->klass = rb_cArray)
4102 for (i = 0; i < n; i++) {
4119 for (j = 0; j < r; j++) result_array[j] = values_array[p[j]];
4122 if (
RBASIC(values)->klass) {
4167 if (r < 0 || n < r) {
4228 if (n < 0 || len < n) {
4235 for (i = 0; i <
len; i++) {
4250 for (lev++; lev < n; lev++) {
4251 chosen[lev] =
RARRAY_PTR(ary)[stack[lev+1] = stack[lev]+1];
4258 if (lev == 0)
goto done;
4260 }
while (stack[lev+1]+n == len+lev+1);
4285 for (i = 0; i < n; i++) {
4298 for (j = 0; j < r; j++) result_array[j] = values_array[p[j]];
4301 if (
RBASIC(values)->klass) {
4368 for (; index < n; ++index) {
4378 for (j = 0; j < r; ++j) result_array[j] = values_array[p[j]];
4381 if (
RBASIC(values)->klass) {
4429 for (i = 0; i <
len; i++) {
4433 else if (len == 0) {
4487 for (i = 1; i < n; i++) arrays[i] =
Qnil;
4488 for (i = 1; i < n; i++) arrays[i] =
to_ary(argv[i-1]);
4491 for (i = 0; i < n; i++) counters[i] = 0;
4496 for (i = 0; i < n; i++) {
4503 for (i = 0; i < n; i++) {
4504 long k =
RARRAY_LEN(arrays[i]), l = resultlen;
4510 if (resultlen < k || resultlen < l || resultlen / k != l) {
4520 for (j = 0; j < n; j++) {
4545 while (counters[m] ==
RARRAY_LEN(arrays[m])) {
4548 if (--m < 0)
goto done;
4674 #define rb_intern(str) rb_intern_const(str)