25 #define id_each idEach 28 #define id_lshift idLTLT 33 if (argc == 0)
return Qnil;
34 if (argc == 1)
return argv[0];
38 #define ENUM_WANT_SVALUE() do { \ 39 i = rb_enum_values_pack(argc, argv); \ 212 rb_warn(
"given block not used");
273 if (!
NIL_P(if_none)) {
340 rb_warn(
"given block not used");
376 return ((
unsigned long)n > limit) ? (long)limit : n;
384 return ((
unsigned long)n >
FIX2ULONG(size));
499 int min_argc, max_argc;
584 VALUE key_value_pair;
588 if (
NIL_P(key_value_pair)) {
778 op =
id ?
ID2SYM(
id) : init;
976 #define SORT_BY_BUFSIZE 16 1018 if (
RBASIC(ary)->klass) {
1139 if (
RBASIC(ary)->klass) {
1152 #define ENUMFUNC(name) rb_block_given_p() ? name##_iter_i : name##_i 1154 #define DEFINE_ENUMFUNCS(name) \ 1155 static VALUE enum_##name##_func(VALUE result, struct MEMO *memo); \ 1158 name##_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ 1160 return enum_##name##_func(rb_enum_values_pack(argc, argv), MEMO_CAST(memo)); \ 1164 name##_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo)) \ 1166 return enum_##name##_func(rb_yield_values2(argc, argv), MEMO_CAST(memo)); \ 1170 enum_##name##_func(VALUE result, struct MEMO *memo) 1245 if (memo->v1 ==
Qundef) {
1248 else if (memo->v1 ==
Qtrue) {
1262 int (*cmpfunc)(
const void *,
const void *,
void *);
1311 eltsize = data->
by ? 2 : 1;
1317 #define GETPTR(i) (beg+(i)*eltsize) 1319 #define SWAP(i, j) do { \ 1321 memcpy(tmp, GETPTR(i), sizeof(VALUE)*eltsize); \ 1322 memcpy(GETPTR(i), GETPTR(j), sizeof(VALUE)*eltsize); \ 1323 memcpy(GETPTR(j), tmp, sizeof(VALUE)*eltsize); \ 1327 long pivot_index = left + (right-left)/2;
1328 long num_pivots = 1;
1330 SWAP(pivot_index, right);
1331 pivot_index = right;
1335 while (i <= right-num_pivots) {
1340 SWAP(i, right-num_pivots);
1345 SWAP(i, store_index);
1351 for (i = right; right-num_pivots < i; i--) {
1358 if (store_index <= n && n <= store_index+num_pivots)
1361 if (n < store_index) {
1362 right = store_index-1;
1365 left = store_index+num_pivots;
1432 data.
method = rev ? (by ?
"max_by" :
"max")
1433 : (by ?
"min_by" :
"min");
2303 #define dont_recycle_block_arg(arity) ((arity) == 1 || (arity) < 0) 2489 struct MEMO *memo = (
struct MEMO *)memoval;
2492 long n = memo->
u3.
cnt++;
2508 if (
NIL_P(result)) {
2535 struct MEMO *memo = (
struct MEMO *)memoval;
2559 if (
NIL_P(result)) {
2610 for (i=0; i<
argc; i++) {
2620 for (i=0; i<
argc; i++) {
2717 if (memo->
u3.
cnt == 0) {
2824 if (mul <= 0)
return INT2FIX(0);
2864 if (n <= 0)
return Qnil;
2870 if (len == 0)
return Qnil;
2871 while (n < 0 || 0 < --n) {
2872 for (i=0; i<
len; i++) {
2905 else if (
NIL_P(v) || v == separator) {
3075 if (
RTEST(header_p)) {
3287 #define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct sliceafter_arg, _memo))) 3411 #define UPDATE_MEMO ((void)(memo = MEMO_FOR(struct slicewhen_arg, _memo))) 3624 const int unused = (
assert(memo !=
NULL), 0);
3702 if (fabs(f) >= fabs(x))
3828 if (memo.float_value) {
3829 return DBL2NUM(memo.f + memo.c);
3902 #define rb_intern(str) rb_intern_const(str) #define NEW_PARTIAL_MEMO_FOR(type, value, member)
static VALUE sliceafter_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
VALUE rb_int_plus(VALUE x, VALUE y)
#define RBASIC_CLEAR_CLASS(obj)
const char * rb_builtin_class_name(VALUE x)
int(* cmpfunc)(const void *, const void *, void *)
static int cmp(VALUE x, VALUE y)
static void hash_sum(VALUE hash, struct enum_sum_memo *memo)
ID rb_check_id(volatile VALUE *)
Returns ID for the given name if it is interned already, or 0.
static VALUE uniq_func(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
#define MEMO_FOR(type, value)
static VALUE enum_any(VALUE obj)
static VALUE grep_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_all(VALUE obj)
static VALUE slicebefore_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
static VALUE minmax_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
static VALUE enum_each_with_index(int argc, VALUE *argv, VALUE obj)
int rb_block_min_max_arity(int *max)
VALUE rb_yield_values(int n,...)
static VALUE rb_f_send(int argc, VALUE *argv, VALUE recv)
static int sort_by_cmp(const void *ap, const void *bp, void *data)
static unsigned int hash(str, len) register const char *str
#define NEW_MEMO_FOR(type, value)
static VALUE count_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
static VALUE slicebefore_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp))
static VALUE each_with_object_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo))
static VALUE min_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
VALUE rb_ary_shift(VALUE ary)
int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val)
static VALUE count_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
VALUE rb_big_plus(VALUE x, VALUE y)
static VALUE enum_each_slice(VALUE obj, VALUE n)
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_yield_lambda(VALUE values)
SSL_METHOD *(* func)(void)
static VALUE enum_each_cons(VALUE obj, VALUE n)
VALUE rb_ary_tmp_new(long capa)
static VALUE enum_sort_by(VALUE obj)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
VALUE rb_int_minus(VALUE x, VALUE y)
static VALUE enum_member(VALUE obj, VALUE val)
struct cmp_opt_data cmp_opt
#define RBASIC_SET_CLASS(obj, cls)
VALUE rb_int_mul(VALUE x, VALUE y)
static VALUE enum_uniq(VALUE obj)
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_ary_clear(VALUE ary)
#define OPTIMIZED_CMP(a, b, data)
#define DEFINE_ENUMFUNCS(name)
static VALUE enum_slice_before(int argc, VALUE *argv, VALUE enumerable)
static int nmin_cmp(const void *ap, const void *bp, void *_data)
static VALUE sort_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _data))
VALUE rb_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
struct cmp_opt_data cmp_opt
double rb_big2dbl(VALUE x)
static VALUE enum_min(int argc, VALUE *argv, VALUE obj)
#define MEMO_NEW(a, b, c)
int rb_cmpint(VALUE val, VALUE a, VALUE b)
static VALUE enum_to_h(int argc, VALUE *argv, VALUE obj)
static int enum_size_over_p(VALUE obj, long n)
#define MEMO_V2_SET(m, v)
static VALUE uniq_iter(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
static VALUE enum_chunk(VALUE enumerable)
void Init_Enumerable(void)
static VALUE find_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
void rb_hash_foreach(VALUE hash, int(*func)(ANYARGS), VALUE farg)
#define ENUM_WANT_SVALUE()
static VALUE group_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
#define RBASIC_SET_CLASS_RAW(obj, cls)
#define RB_TYPE_P(obj, type)
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
static VALUE each_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memo))
VALUE rb_int_idiv(VALUE x, VALUE y)
#define dont_recycle_block_arg(arity)
static VALUE enum_take(VALUE obj, VALUE n)
static VALUE flat_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
int rb_block_given_p(void)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
static VALUE member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args))
static VALUE enum_sort(VALUE obj)
VALUE rb_int_ge(VALUE x, VALUE y)
static VALUE enum_each_entry(int argc, VALUE *argv, VALUE obj)
static VALUE enum_inject(int argc, VALUE *argv, VALUE obj)
static VALUE enum_grep(VALUE obj, VALUE pat)
static VALUE enum_find_all(VALUE obj)
static VALUE enum_cycle_size(VALUE self, VALUE args, VALUE eobj)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static void minmax_i_update(VALUE i, VALUE j, struct minmax_t *memo)
static VALUE enum_first(int argc, VALUE *argv, VALUE obj)
static VALUE count_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
static VALUE slicewhen_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
VALUE rb_obj_alloc(VALUE)
static void minmax_by_i_update(VALUE v1, VALUE v2, VALUE i1, VALUE i2, struct minmax_by_t *memo)
VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
static VALUE chunk_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _argp))
static VALUE max_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_sum_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_yield_array(VALUE ary)
static VALUE enum_cycle(int argc, VALUE *argv, VALUE obj)
VALUE rb_big_minus(VALUE x, VALUE y)
static VALUE enum_slice_when(VALUE enumerable)
#define RARRAY_PTR_USE(ary, ptr_name, expr)
#define MEMO_V1_SET(m, v)
static VALUE sliceafter_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
static VALUE ary_inject_op(VALUE ary, VALUE init, VALUE op)
static VALUE inject_op_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
VALUE rb_hash_values(VALUE hash)
static VALUE enum_each_cons_size(VALUE obj, VALUE args, VALUE eobj)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE min_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
VALUE rb_ivar_set(VALUE, ID, VALUE)
VALUE rb_assoc_new(VALUE car, VALUE cdr)
static void minmax_ii_update(VALUE i, VALUE j, struct minmax_t *memo)
VALUE rb_fix_plus(VALUE x, VALUE y)
static VALUE enum_collect(VALUE obj)
void ruby_qsort(void *, const size_t, const size_t, int(*)(const void *, const void *, void *), void *)
static VALUE enum_to_h_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, hash))
VALUE rb_hash_clear(VALUE hash)
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
VALUE rb_obj_hide(VALUE obj)
RUBY_EXTERN VALUE rb_cInteger
static VALUE take_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
static VALUE grep_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE minmax_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
static VALUE enum_none(VALUE obj)
VALUE rb_rescue2(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*r_proc)(ANYARGS), VALUE data2,...)
static VALUE enum_size(VALUE self, VALUE args, VALUE eobj)
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
static VALUE enum_one(VALUE obj)
static VALUE find_all_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
static VALUE enum_drop_while(VALUE obj)
static VALUE int_range_sum(VALUE beg, VALUE end, int excl, VALUE init)
#define RB_FLOAT_TYPE_P(obj)
static VALUE nmin_i(VALUE i, VALUE *_data, int argc, VALUE *argv)
int rb_respond_to(VALUE, ID)
static VALUE enum_min_by(int argc, VALUE *argv, VALUE obj)
register unsigned int len
VALUE rb_ary_new_from_values(long n, const VALUE *elts)
static VALUE enum_chunk_while(VALUE enumerable)
static VALUE take_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE max_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_max_by(int argc, VALUE *argv, VALUE obj)
static long limit_by_enum_size(VALUE obj, long n)
static int hash_sum_i(VALUE key, VALUE value, VALUE arg)
static VALUE cycle_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
struct cmp_opt_data cmp_opt
VALUE rb_rational_plus(VALUE self, VALUE other)
VALUE rb_ary_resize(VALUE ary, long len)
expands or shrinks ary to len elements.
#define RARRAY_ASET(a, i, v)
static VALUE enum_reject(VALUE obj)
VALUE rb_equal(VALUE, VALUE)
static VALUE enum_each_with_object(VALUE obj, VALUE memo)
static VALUE collect_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
VALUE rb_yield_values2(int n, const VALUE *argv)
VALUE rb_enum_values_pack(int argc, const VALUE *argv)
static VALUE enum_partition(VALUE obj)
static double float_value(VALUE v)
#define RARRAY_AREF(a, i)
#define NEW_CMP_OPT_MEMO(type, value)
static VALUE enum_to_a(int argc, VALUE *argv, VALUE obj)
static VALUE max_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE drop_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_minmax_by(VALUE obj)
VALUE rb_block_proc(void)
static VALUE enum_reverse_each(int argc, VALUE *argv, VALUE obj)
static VALUE chunk_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
VALUE rb_check_array_type(VALUE ary)
VALUE rb_hash_aref(VALUE hash, VALUE key)
void rb_error_arity(int argc, int min, int max)
static VALUE enum_count(int argc, VALUE *argv, VALUE obj)
static void sum_iter(VALUE i, struct enum_sum_memo *memo)
void rb_thread_check_ints(void)
static VALUE inject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
static VALUE first_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, params))
int rb_method_basic_definition_p(VALUE, ID)
static VALUE enum_drop(VALUE obj, VALUE n)
static VALUE partition_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, arys))
VALUE rb_ary_sort_bang(VALUE ary)
static VALUE enum_find(int argc, VALUE *argv, VALUE obj)
VALUE rb_ary_dup(VALUE ary)
static VALUE zip_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
VALUE rb_ary_concat(VALUE x, VALUE y)
static VALUE enum_zip(int argc, VALUE *argv, VALUE obj)
VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, int min_argc, int max_argc, VALUE data2)
#define RETURN_ENUMERATOR(obj, argc, argv)
static VALUE zip_ary(RB_BLOCK_CALL_FUNC_ARGLIST(val, memoval))
static VALUE find_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
VALUE rb_ary_reverse(VALUE ary)
static VALUE enum_flat_map(VALUE obj)
static VALUE enum_take_while(VALUE obj)
static VALUE enum_max(int argc, VALUE *argv, VALUE obj)
static VALUE enum_find_index(int argc, VALUE *argv, VALUE obj)
static VALUE enum_minmax(VALUE obj)
static VALUE each_cons_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static int nmin_block_cmp(const void *ap, const void *bp, void *_data)
static VALUE min_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE enum_slice_after(int argc, VALUE *argv, VALUE enumerable)
static VALUE enum_sum(int argc, VALUE *argv, VALUE obj)
void rb_warning(const char *fmt,...)
#define CONST_ID(var, str)
static VALUE minmax_by_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, _memo))
static VALUE call_stop(VALUE *v)
static VALUE find_index_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, memop))
static VALUE enum_grep_v(VALUE obj, VALUE pat)
VALUE rb_define_module(const char *name)
static VALUE drop_while_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, args))
static VALUE reject_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
static VALUE enum_each_slice_size(VALUE obj, VALUE args, VALUE eobj)
static VALUE enum_group_by(VALUE obj)
static VALUE slicewhen_i(RB_BLOCK_CALL_FUNC_ARGLIST(yielder, enumerator))
static VALUE each_val_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, p))
static VALUE enum_yield(int argc, VALUE ary)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static VALUE each_slice_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, m))
void rb_warn(const char *fmt,...)
static VALUE call_next(VALUE *v)
static void nmin_filter(struct nmin_data *data)
#define RB_OBJ_WRITE(a, slot, b)
VALUE rb_attr_get(VALUE, ID)
static VALUE collect_all(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
VALUE rb_obj_class(VALUE)