28#define id_lshift idLTLT
40#define ENUM_WANT_SVALUE() do { \
41 i = rb_enum_values_pack(argc, argv); \
55enum_yield_array(
VALUE ary)
145#define COUNT_BIGNUM IMEMO_FL_USER0
146#define MEMO_V3_SET(m, v) RB_OBJ_WRITE((m), &(m)->u3.value, (v))
149imemo_count_up(
struct MEMO *memo)
154 else if (++memo->
u3.
cnt == 0) {
156 unsigned long buf[2] = {0, 1};
163imemo_count_value(
struct MEMO *memo)
181 imemo_count_up(memo);
192 imemo_count_up(memo);
202 imemo_count_up(memo);
242 rb_warn(
"given block not used");
249 return imemo_count_value(memo);
305 if (!
NIL_P(if_none)) {
322 imemo_count_up(memo);
335 imemo_count_up(memo);
367 func = find_index_iter_i;
372 rb_warn(
"given block not used");
406 return ((
unsigned long)
n > limit) ? (
long)limit :
n;
862 op =
id ?
ID2SYM(
id) : init;
876 if (iter == inject_op_i &&
880 return ary_inject_op(
obj, init, op);
942 group = enum_yield(
argc,
i);
974 return enum_hashify(
obj, 0, 0, group_by_i);
985 tally +=
INT2FIX(1) & ~FIXNUM_FLAG;
1015 return enum_hashify(
obj, 0, 0, tally_i);
1055 return enum_take(
obj,
argv[0]);
1095#define SORT_BY_BUFSIZE 16
1131sort_by_cmp(
const void *ap,
const void *
bp,
void *data)
1138 if (
RBASIC(ary)->klass) {
1260 sort_by_cmp, (
void *)
ary));
1274#define ENUMFUNC(name) argc ? name##_eqq : rb_block_given_p() ? name##_iter_i : name##_i
1276#define MEMO_ENUM_NEW(v1) (rb_check_arity(argc, 0, 1), MEMO_NEW((v1), (argc ? *argv : 0), 0))
1278#define DEFINE_ENUMFUNCS(name) \
1279static VALUE enum_##name##_func(VALUE result, struct MEMO *memo); \
1282name##_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
1284 return enum_##name##_func(rb_enum_values_pack(argc, argv), MEMO_CAST(memo)); \
1288name##_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
1290 return enum_##name##_func(rb_yield_values2(argc, argv), MEMO_CAST(memo)); \
1294name##_eqq(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \
1296 ENUM_WANT_SVALUE(); \
1297 return enum_##name##_func(rb_funcallv(MEMO_CAST(memo)->v2, id_eqq, 1, &i), MEMO_CAST(memo)); \
1301enum_##name##_func(VALUE result, struct MEMO *memo)
1303#define WARN_UNUSED_BLOCK(argc) do { \
1304 if ((argc) > 0 && rb_block_given_p()) { \
1305 rb_warn("given block not used"); \
1311 if (!
RTEST(result)) {
1353 if (
RTEST(result)) {
1395 if (
RTEST(result)) {
1423 data->
rev ?
"max" :
"min",
1424 data->
by ?
"_by" :
"");
1430nmin_cmp(
const void *ap,
const void *
bp,
void *_data)
1435#define rb_cmpint(cmp, a, b) rb_cmpint(cmpint_reenter_check(data, (cmp)), a, b)
1441nmin_block_cmp(
const void *ap,
const void *
bp,
void *_data)
1446 cmpint_reenter_check(data, cmp);
1468 eltsize = data->
by ? 2 : 1;
1474#define GETPTR(i) (beg+(i)*eltsize)
1476#define SWAP(i, j) do { \
1478 memcpy(tmp, GETPTR(i), sizeof(VALUE)*eltsize); \
1479 memcpy(GETPTR(i), GETPTR(j), sizeof(VALUE)*eltsize); \
1480 memcpy(GETPTR(j), tmp, sizeof(VALUE)*eltsize); \
1484 long pivot_index = left + (right-left)/2;
1485 long num_pivots = 1;
1487 SWAP(pivot_index, right);
1488 pivot_index = right;
1492 while (
i <= right-num_pivots) {
1497 SWAP(
i, right-num_pivots);
1502 SWAP(
i, store_index);
1508 for (
i = right; right-num_pivots <
i;
i--) {
1515 if (store_index <=
n &&
n <= store_index+num_pivots)
1518 if (
n < store_index) {
1519 right = store_index-1;
1522 left = store_index+num_pivots;
1542 cmpv = enum_yield(
argc,
i);
1668 if (
RTEST(result)) {
1946 minmax_i_update(
i, j, memo);
1998 minmax_ii_update(
i, j, memo);
2031 minmax_ii_update(m->
last, m->
last, m);
2036 minmax_i_update(m->
last, m->
last, m);
2255 vi = enum_yield(
argc,
i);
2281 minmax_by_i_update(vi, vj,
i, j, memo);
2362 VALUE n = imemo_count_value(m);
2446 enum_yield(
argc,
i);
2503#define dont_recycle_block_arg(arity) ((arity) == 1 || (arity) < 0)
2545 n = add_int(
size, slice_size-1);
2546 return div_int(
n, slice_size);
2620 n = add_int(
size, 1 - cons_size);
2696 struct MEMO *memo = (
struct MEMO *)memoval;
2715 if (
NIL_P(result)) {
2716 enum_yield_array(tmp);
2744 struct MEMO *memo = (
struct MEMO *)memoval;
2768 if (
NIL_P(result)) {
2769 enum_yield_array(tmp);
2927 if (memo->
u3.
cnt == 0) {
3016 enum_yield(
argc,
i);
3032 size = enum_size(
self, args, 0);
3077 if (
n <= 0)
return Qnil;
3084 while (
n < 0 || 0 < --
n) {
3120 else if (
NIL_P(
v) ||
v == separator) {
3261enum_chunk(
VALUE enumerable)
3294 if (
RTEST(header_p)) {
3506#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct sliceafter_arg, _memo)))
3630#define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct slicewhen_arg, _memo)))
3753enum_slice_when(
VALUE enumerable)
3819enum_chunk_while(
VALUE enumerable)
3846 const int unused = (
assert(memo !=
NULL), 0);
4064 return int_range_sum(beg, end, excl, memo.
v);
4070 hash_sum(
obj, &memo);
4147#define rb_intern(str) rb_intern_const(str)
#define MEMO_V3_SET(m, v)
#define rb_cmpint(cmp, a, b)
#define MEMO_ENUM_NEW(v1)
VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
#define WARN_UNUSED_BLOCK(argc)
#define DEFINE_ENUMFUNCS(name)
#define ENUM_WANT_SVALUE()
VALUE rb_enum_values_pack(int argc, const VALUE *argv)
void Init_Enumerable(void)
#define dont_recycle_block_arg(arity)
VALUE rb_define_module(const char *)
int rb_block_given_p(void)
Determines if the current method is given a block.
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_rescue2(VALUE(*)(VALUE), VALUE, VALUE(*)(VALUE, VALUE), VALUE,...)
An equivalent of rescue clause.
void rb_warn(const char *fmt,...)
VALUE rb_obj_alloc(VALUE)
Allocates an instance of klass.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
double rb_num2dbl(VALUE)
Converts a Numeric object to double.
VALUE rb_equal(VALUE, VALUE)
Same as Object#===, case equality.
unsigned char buf[MIME_BUF_SIZE]
struct cmp_opt_data cmp_opt
struct cmp_opt_data cmp_opt
struct cmp_opt_data cmp_opt
int(* cmpfunc)(const void *, const void *, void *)
#define STATIC_ID2SYM(id)
void ruby_qsort(void *, const size_t, const size_t, int(*)(const void *, const void *, void *), void *)
MJIT_STATIC void rb_error_arity(int argc, int min, int max)