#include "ruby.h"
#include "node.h"
#include "util.h"
VALUE rb_mEnumerable;
static ID id_each, id_eqq, id_cmp, id_size;
struct iter_method_arg {
VALUE obj;
ID mid;
int argc;
VALUE *argv;
};
static VALUE iterate_method _((VALUE obj));
static VALUE
iterate_method(obj)
VALUE obj;
{
struct iter_method_arg *arg;
arg = (struct iter_method_arg *)obj;
return rb_funcall2(arg->obj, arg->mid, arg->argc, arg->argv);
}
VALUE
rb_block_call(obj, mid, argc, argv, bl_proc, data2)
VALUE obj;
ID mid;
int argc;
VALUE *argv;
VALUE (*bl_proc) (ANYARGS);
VALUE data2;
{
struct iter_method_arg arg;
arg.obj = obj;
arg.mid = mid;
arg.argc = argc;
arg.argv = argv;
return rb_iterate(iterate_method, (VALUE)&arg, bl_proc, data2);
}
VALUE
rb_each(obj)
VALUE obj;
{
return rb_funcall(obj, id_each, 0, 0);
}
static VALUE
grep_i(i, arg)
VALUE i, *arg;
{
if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) {
rb_ary_push(arg[1], i);
}
return Qnil;
}
static VALUE
grep_iter_i(i, arg)
VALUE i, *arg;
{
if (RTEST(rb_funcall(arg[0], id_eqq, 1, i))) {
rb_ary_push(arg[1], rb_yield(i));
}
return Qnil;
}
static VALUE
enum_grep(obj, pat)
VALUE obj, pat;
{
VALUE ary = rb_ary_new();
VALUE arg[2];
arg[0] = pat;
arg[1] = ary;
rb_iterate(rb_each, obj, rb_block_given_p() ? grep_iter_i : grep_i, (VALUE)arg);
return ary;
}
static VALUE count_i _((VALUE, VALUE));
static VALUE
count_i(i, memop)
VALUE i, memop;
{
VALUE *memo = (VALUE*)memop;
if (rb_equal(i, memo[1])) {
memo[0]++;
}
return Qnil;
}
static VALUE count_iter_i _((VALUE, VALUE));
static VALUE
count_iter_i(i, memop)
VALUE i, memop;
{
VALUE *memo = (VALUE*)memop;
if (RTEST(rb_yield(i))) {
memo[0]++;
}
return Qnil;
}
static VALUE count_all_i _((VALUE, VALUE));
static VALUE
count_all_i(i, memop)
VALUE i, memop;
{
VALUE *memo = (VALUE*)memop;
memo[0]++;
return Qnil;
}
static VALUE
enum_count(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE memo[2];
rb_block_call_func *func;
if (argc == 0) {
if (rb_block_given_p()) {
func = count_iter_i;
}
else {
if (rb_respond_to(obj, id_size)) {
return rb_funcall(obj, id_size, 0, 0);
}
func = count_all_i;
}
}
else {
rb_scan_args(argc, argv, "1", &memo[1]);
if (rb_block_given_p()) {
rb_warn("given block not used");
}
func = count_i;
}
memo[0] = 0;
rb_block_call(obj, id_each, 0, 0, func, (VALUE)&memo);
return INT2NUM(memo[0]);
}
static VALUE
find_i(i, memo)
VALUE i;
VALUE *memo;
{
if (RTEST(rb_yield(i))) {
*memo = i;
rb_iter_break();
}
return Qnil;
}
static VALUE
enum_find(argc, argv, obj)
int argc;
VALUE* argv;
VALUE obj;
{
VALUE memo = Qundef;
VALUE if_none;
rb_scan_args(argc, argv, "01", &if_none);
RETURN_ENUMERATOR(obj, argc, argv);
rb_iterate(rb_each, obj, find_i, (VALUE)&memo);
if (memo != Qundef) {
return memo;
}
if (!NIL_P(if_none)) {
return rb_funcall(if_none, rb_intern("call"), 0, 0);
}
return Qnil;
}
static VALUE find_index_i _((VALUE, VALUE));
static VALUE
find_index_i(i, memop)
VALUE i;
VALUE memop;
{
VALUE *memo = (VALUE*)memop;
if (rb_equal(i, memo[2])) {
memo[0] = UINT2NUM(memo[1]);
rb_iter_break();
}
memo[1]++;
return Qnil;
}
static VALUE find_index_iter_i _((VALUE, VALUE));
static VALUE
find_index_iter_i(i, memop)
VALUE i;
VALUE memop;
{
VALUE *memo = (VALUE*)memop;
if (RTEST(rb_yield(i))) {
memo[0] = UINT2NUM(memo[1]);
rb_iter_break();
}
memo[1]++;
return Qnil;
}
static VALUE
enum_find_index(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE memo[3];
rb_block_call_func *func;
if (argc == 0) {
RETURN_ENUMERATOR(obj, 0, 0);
func = find_index_iter_i;
}
else {
rb_scan_args(argc, argv, "1", &memo[2]);
if (rb_block_given_p()) {
rb_warn("given block not used");
}
func = find_index_i;
}
memo[0] = Qnil;
memo[1] = 0;
rb_block_call(obj, id_each, 0, 0, func, (VALUE)memo);
return memo[0];
}
static VALUE
find_all_i(i, ary)
VALUE i, ary;
{
if (RTEST(rb_yield(i))) {
rb_ary_push(ary, i);
}
return Qnil;
}
static VALUE
enum_find_all(obj)
VALUE obj;
{
VALUE ary = rb_ary_new();
RETURN_ENUMERATOR(obj, 0, 0);
rb_iterate(rb_each, obj, find_all_i, ary);
return ary;
}
static VALUE
reject_i(i, ary)
VALUE i, ary;
{
if (!RTEST(rb_yield(i))) {
rb_ary_push(ary, i);
}
return Qnil;
}
static VALUE
enum_reject(obj)
VALUE obj;
{
VALUE ary = rb_ary_new();
RETURN_ENUMERATOR(obj, 0, 0);
rb_iterate(rb_each, obj, reject_i, ary);
return ary;
}
static VALUE
collect_i(i, ary)
VALUE i, ary;
{
rb_ary_push(ary, rb_yield(i));
return Qnil;
}
static VALUE
collect_all(i, ary)
VALUE i, ary;
{
rb_ary_push(ary, i);
return Qnil;
}
static VALUE
enum_collect(obj)
VALUE obj;
{
VALUE ary = rb_ary_new();
rb_iterate(rb_each, obj, rb_block_given_p() ? collect_i : collect_all, ary);
return ary;
}
static VALUE
enum_to_a(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE ary = rb_ary_new();
rb_block_call(obj, id_each, argc, argv, collect_all, ary);
return ary;
}
static VALUE inject_i _((VALUE, VALUE));
static VALUE
inject_i(i, p)
VALUE i;
VALUE p;
{
VALUE *memo = (VALUE *)p;
if (memo[0] == Qundef) {
memo[0] = i;
}
else {
memo[0] = rb_yield_values(2, memo[0], i);
}
return Qnil;
}
static VALUE inject_op_i _((VALUE, VALUE));
static VALUE
inject_op_i(i, p)
VALUE i;
VALUE p;
{
VALUE *memo = (VALUE *)p;
if (memo[0] == Qundef) {
memo[0] = i;
}
else {
memo[0] = rb_funcall(memo[0], (ID)memo[1], 1, i);
}
return Qnil;
}
static VALUE
enum_inject(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE memo[2];
rb_block_call_func *iter = inject_i;
switch (rb_scan_args(argc, argv, "02", &memo[0], &memo[1])) {
case 0:
memo[0] = Qundef;
break;
case 1:
if (rb_block_given_p()) {
break;
}
memo[1] = (VALUE)rb_to_id(memo[0]);
memo[0] = Qundef;
iter = inject_op_i;
break;
case 2:
if (rb_block_given_p()) {
rb_warning("given block not used");
}
memo[1] = (VALUE)rb_to_id(memo[1]);
iter = inject_op_i;
break;
}
rb_block_call(obj, id_each, 0, 0, iter, (VALUE)memo);
if (memo[0] == Qundef) return Qnil;
return memo[0];
}
static VALUE
partition_i(i, ary)
VALUE i, *ary;
{
if (RTEST(rb_yield(i))) {
rb_ary_push(ary[0], i);
}
else {
rb_ary_push(ary[1], i);
}
return Qnil;
}
static VALUE
enum_partition(obj)
VALUE obj;
{
VALUE ary[2];
RETURN_ENUMERATOR(obj, 0, 0);
ary[0] = rb_ary_new();
ary[1] = rb_ary_new();
rb_iterate(rb_each, obj, partition_i, (VALUE)ary);
return rb_assoc_new(ary[0], ary[1]);
}
static VALUE
group_by_i(i, hash)
VALUE i;
VALUE hash;
{
VALUE group = rb_yield(i);
VALUE values;
values = rb_hash_aref(hash, group);
if (NIL_P(values)) {
values = rb_ary_new3(1, i);
rb_hash_aset(hash, group, values);
}
else {
rb_ary_push(values, i);
}
return Qnil;
}
static VALUE
enum_group_by(obj)
VALUE obj;
{
VALUE hash;
RETURN_ENUMERATOR(obj, 0, 0);
hash = rb_hash_new();
rb_block_call(obj, id_each, 0, 0, group_by_i, hash);
return hash;
}
static VALUE
first_i(i, ary)
VALUE i;
VALUE *ary;
{
if (NIL_P(ary[0])) {
ary[1] = i;
rb_iter_break();
}
else {
long n = NUM2LONG(ary[0]);
rb_ary_push(ary[1], i);
n--;
if (n <= 0) {
rb_iter_break();
}
ary[0] = INT2NUM(n);
}
return Qnil;
}
static VALUE
enum_first(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE n, ary[2];
if (argc == 0) {
ary[0] = ary[1] = Qnil;
}
else {
long len;
rb_scan_args(argc, argv, "01", &n);
len = NUM2LONG(n);
if (len == 0) return rb_ary_new2(0);
ary[0] = INT2NUM(len);
ary[1] = rb_ary_new2(len);
}
rb_block_call(obj, id_each, 0, 0, first_i, (VALUE)ary);
return ary[1];
}
static VALUE
enum_sort(obj)
VALUE obj;
{
return rb_ary_sort(enum_to_a(0, 0, obj));
}
static VALUE
sort_by_i(i, ary)
VALUE i, ary;
{
VALUE v;
NODE *memo;
v = rb_yield(i);
if (RBASIC(ary)->klass) {
rb_raise(rb_eRuntimeError, "sort_by reentered");
}
memo = rb_node_newnode(NODE_MEMO, v, i, 0);
rb_ary_push(ary, (VALUE)memo);
return Qnil;
}
static int
sort_by_cmp(aa, bb, data)
NODE **aa, **bb;
void *data;
{
VALUE a = aa[0]->u1.value;
VALUE b = bb[0]->u1.value;
VALUE ary = (VALUE)data;
if (RBASIC(ary)->klass) {
rb_raise(rb_eRuntimeError, "sort_by reentered");
}
return rb_cmpint(rb_funcall(a, id_cmp, 1, b), a, b);
}
static VALUE
enum_sort_by(obj)
VALUE obj;
{
VALUE ary;
long i;
RETURN_ENUMERATOR(obj, 0, 0);
if (TYPE(obj) == T_ARRAY) {
ary = rb_ary_new2(RARRAY(obj)->len);
}
else {
ary = rb_ary_new();
}
RBASIC(ary)->klass = 0;
rb_iterate(rb_each, obj, sort_by_i, ary);
if (RARRAY(ary)->len > 1) {
qsort(RARRAY(ary)->ptr, RARRAY(ary)->len, sizeof(VALUE),
sort_by_cmp, (void *)ary);
}
if (RBASIC(ary)->klass) {
rb_raise(rb_eRuntimeError, "sort_by reentered");
}
for (i=0; i<RARRAY(ary)->len; i++) {
RARRAY(ary)->ptr[i] = RNODE(RARRAY(ary)->ptr[i])->u2.value;
}
RBASIC(ary)->klass = rb_cArray;
return ary;
}
static VALUE
all_i(i, memo)
VALUE i;
VALUE *memo;
{
if (!RTEST(i)) {
*memo = Qfalse;
rb_iter_break();
}
return Qnil;
}
static VALUE
all_iter_i(i, memo)
VALUE i;
VALUE *memo;
{
return all_i(rb_yield(i), memo);
}
static VALUE
enum_all(obj)
VALUE obj;
{
VALUE result = Qtrue;
rb_iterate(rb_each, obj, rb_block_given_p() ? all_iter_i : all_i, (VALUE)&result);
return result;
}
static VALUE
any_i(i, memo)
VALUE i;
VALUE *memo;
{
if (RTEST(i)) {
*memo = Qtrue;
rb_iter_break();
}
return Qnil;
}
static VALUE
any_iter_i(i, memo)
VALUE i;
VALUE *memo;
{
return any_i(rb_yield(i), memo);
}
static VALUE
enum_any(obj)
VALUE obj;
{
VALUE result = Qfalse;
rb_iterate(rb_each, obj, rb_block_given_p() ? any_iter_i : any_i, (VALUE)&result);
return result;
}
static VALUE
one_i(i, memo)
VALUE i;
VALUE *memo;
{
if (RTEST(i)) {
if (*memo == Qundef) {
*memo = Qtrue;
}
else if (*memo == Qtrue) {
*memo = Qfalse;
rb_iter_break();
}
}
return Qnil;
}
static VALUE
one_iter_i(i, memo)
VALUE i;
VALUE *memo;
{
return one_i(rb_yield(i), memo);
}
static VALUE
enum_one(obj)
VALUE obj;
{
VALUE result = Qundef;
rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? one_iter_i : one_i, (VALUE)&result);
if (result == Qundef) return Qfalse;
return result;
}
static VALUE
none_i(i, memo)
VALUE i;
VALUE *memo;
{
if (RTEST(i)) {
*memo = Qfalse;
rb_iter_break();
}
return Qnil;
}
static VALUE
none_iter_i(i, memo)
VALUE i;
VALUE *memo;
{
return none_i(rb_yield(i), memo);
}
static VALUE
enum_none(obj)
VALUE obj;
{
VALUE result = Qtrue;
rb_block_call(obj, id_each, 0, 0, rb_block_given_p() ? none_iter_i : none_i, (VALUE)&result);
return result;
}
static VALUE
min_i(i, memo)
VALUE i;
VALUE *memo;
{
VALUE cmp;
if (*memo == Qundef) {
*memo = i;
}
else {
cmp = rb_funcall(i, id_cmp, 1, *memo);
if (rb_cmpint(cmp, i, *memo) < 0) {
*memo = i;
}
}
return Qnil;
}
static VALUE
min_ii(i, memo)
VALUE i;
VALUE *memo;
{
VALUE cmp;
if (*memo == Qundef) {
*memo = i;
}
else {
cmp = rb_yield_values(2, i, *memo);
if (rb_cmpint(cmp, i, *memo) < 0) {
*memo = i;
}
}
return Qnil;
}
static VALUE
enum_min(obj)
VALUE obj;
{
VALUE result = Qundef;
rb_iterate(rb_each, obj, rb_block_given_p() ? min_ii : min_i, (VALUE)&result);
if (result == Qundef) return Qnil;
return result;
}
static VALUE
max_i(i, memo)
VALUE i;
VALUE *memo;
{
VALUE cmp;
if (*memo == Qundef) {
*memo = i;
}
else {
cmp = rb_funcall(i, id_cmp, 1, *memo);
if (rb_cmpint(cmp, i, *memo) > 0) {
*memo = i;
}
}
return Qnil;
}
static VALUE
max_ii(i, memo)
VALUE i;
VALUE *memo;
{
VALUE cmp;
if (*memo == Qundef) {
*memo = i;
}
else {
cmp = rb_yield_values(2, i, *memo);
if (rb_cmpint(cmp, i, *memo) > 0) {
*memo = i;
}
}
return Qnil;
}
static VALUE
enum_max(obj)
VALUE obj;
{
VALUE result = Qundef;
rb_iterate(rb_each, obj, rb_block_given_p() ? max_ii : max_i, (VALUE)&result);
if (result == Qundef) return Qnil;
return result;
}
static VALUE
minmax_i(i, memo)
VALUE i;
VALUE *memo;
{
int n;
if (memo[0] == Qundef) {
memo[0] = i;
memo[1] = i;
}
else {
n = rb_cmpint(rb_funcall(i, id_cmp, 1, memo[0]), i, memo[0]);
if (n < 0) {
memo[0] = i;
}
n = rb_cmpint(rb_funcall(i, id_cmp, 1, memo[1]), i, memo[1]);
if (n > 0) {
memo[1] = i;
}
}
return Qnil;
}
static VALUE
minmax_ii(i, memo)
VALUE i;
VALUE *memo;
{
int n;
if (memo[0] == Qundef) {
memo[0] = i;
memo[1] = i;
}
else {
VALUE ary = memo[2];
RARRAY(ary)->ptr[0] = i;
RARRAY(ary)->ptr[1] = memo[0];
n = rb_cmpint(rb_yield(ary), i, memo[0]);
if (n < 0) {
memo[0] = i;
}
RARRAY(ary)->ptr[0] = i;
RARRAY(ary)->ptr[1] = memo[1];
n = rb_cmpint(rb_yield(ary), i, memo[1]);
if (n > 0) {
memo[1] = i;
}
}
return Qnil;
}
static VALUE
enum_minmax(obj)
VALUE obj;
{
VALUE result[3];
VALUE ary = rb_ary_new3(2, Qnil, Qnil);
result[0] = Qundef;
if (rb_block_given_p()) {
result[2] = ary;
rb_block_call(obj, id_each, 0, 0, minmax_ii, (VALUE)result);
}
else {
rb_block_call(obj, id_each, 0, 0, minmax_i, (VALUE)result);
}
if (result[0] != Qundef) {
RARRAY(ary)->ptr[0] = result[0];
RARRAY(ary)->ptr[1] = result[1];
}
return ary;
}
static VALUE
min_by_i(i, memo)
VALUE i;
VALUE *memo;
{
VALUE v;
v = rb_yield(i);
if (memo[0] == Qundef) {
memo[0] = v;
memo[1] = i;
}
else if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[0]), v, memo[0]) < 0) {
memo[0] = v;
memo[1] = i;
}
return Qnil;
}
static VALUE
enum_min_by(obj)
VALUE obj;
{
VALUE memo[2];
RETURN_ENUMERATOR(obj, 0, 0);
memo[0] = Qundef;
memo[1] = Qnil;
rb_block_call(obj, id_each, 0, 0, min_by_i, (VALUE)memo);
return memo[1];
}
static VALUE
max_by_i(i, memo)
VALUE i;
VALUE *memo;
{
VALUE v;
v = rb_yield(i);
if (memo[0] == Qundef) {
memo[0] = v;
memo[1] = i;
}
else if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[0]), v, memo[0]) > 0) {
memo[0] = v;
memo[1] = i;
}
return Qnil;
}
static VALUE
enum_max_by(obj)
VALUE obj;
{
VALUE memo[2];
RETURN_ENUMERATOR(obj, 0, 0);
memo[0] = Qundef;
memo[1] = Qnil;
rb_block_call(obj, id_each, 0, 0, max_by_i, (VALUE)memo);
return memo[1];
}
static VALUE
minmax_by_i(i, memo)
VALUE i;
VALUE *memo;
{
VALUE v;
v = rb_yield(i);
if (memo[0] == Qundef) {
memo[0] = v;
memo[1] = v;
memo[2] = i;
memo[3] = i;
}
else {
if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[0]), v, memo[0]) < 0) {
memo[0] = v;
memo[2] = i;
}
if (rb_cmpint(rb_funcall(v, id_cmp, 1, memo[1]), v, memo[1]) > 0) {
memo[1] = v;
memo[3] = i;
}
}
return Qnil;
}
static VALUE
enum_minmax_by(obj)
VALUE obj;
{
VALUE memo[4];
RETURN_ENUMERATOR(obj, 0, 0);
memo[0] = Qundef;
memo[1] = Qundef;
memo[2] = Qnil;
memo[3] = Qnil;
rb_block_call(obj, id_each, 0, 0, minmax_by_i, (VALUE)memo);
return rb_assoc_new(memo[2], memo[3]);
}
static VALUE
member_i(item, memo)
VALUE item;
VALUE *memo;
{
if (rb_equal(item, memo[0])) {
memo[1] = Qtrue;
rb_iter_break();
}
return Qnil;
}
static VALUE
enum_member(obj, val)
VALUE obj, val;
{
VALUE memo[2];
memo[0] = val;
memo[1] = Qfalse;
rb_iterate(rb_each, obj, member_i, (VALUE)memo);
return memo[1];
}
static VALUE
each_with_index_i(val, memo)
VALUE val;
VALUE *memo;
{
rb_yield_values(2, val, INT2FIX(*memo));
++*memo;
return Qnil;
}
static VALUE
enum_each_with_index(obj)
VALUE obj;
{
VALUE memo;
RETURN_ENUMERATOR(obj, 0, 0);
memo = 0;
rb_iterate(rb_each, obj, each_with_index_i, (VALUE)&memo);
return obj;
}
static VALUE
enum_reverse_each(int argc, VALUE *argv, VALUE obj)
{
VALUE ary;
long i;
RETURN_ENUMERATOR(obj, argc, argv);
ary = enum_to_a(argc, argv, obj);
for (i = RARRAY_LEN(ary); --i >= 0; ) {
rb_yield(RARRAY_PTR(ary)[i]);
}
return obj;
}
static VALUE
zip_i(val, memo)
VALUE val;
VALUE *memo;
{
VALUE result = memo[0];
VALUE args = memo[1];
int idx = memo[2]++;
VALUE tmp;
int i;
tmp = rb_ary_new2(RARRAY(args)->len + 1);
rb_ary_store(tmp, 0, val);
for (i=0; i<RARRAY(args)->len; i++) {
rb_ary_push(tmp, rb_ary_entry(RARRAY(args)->ptr[i], idx));
}
if (rb_block_given_p()) {
rb_yield(tmp);
}
else {
rb_ary_push(result, tmp);
}
return Qnil;
}
static VALUE
enum_zip(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
int i;
VALUE result;
VALUE memo[3];
for (i=0; i<argc; i++) {
argv[i] = rb_convert_type(argv[i], T_ARRAY, "Array", "to_a");
}
result = rb_block_given_p() ? Qnil : rb_ary_new();
memo[0] = result;
memo[1] = rb_ary_new4(argc, argv);
memo[2] = 0;
rb_iterate(rb_each, obj, zip_i, (VALUE)memo);
return result;
}
static VALUE
take_i(i, arg)
VALUE i;
VALUE *arg;
{
rb_ary_push(arg[0], i);
if (--arg[1] == 0) rb_iter_break();
return Qnil;
}
static VALUE
enum_take(obj, n)
VALUE obj;
VALUE n;
{
VALUE args[2];
long len = NUM2LONG(n);
if (len < 0) {
rb_raise(rb_eArgError, "attempt to take negative size");
}
if (len == 0) return rb_ary_new2(0);
args[1] = len;
args[0] = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, take_i, (VALUE)args);
return args[0];
}
static VALUE
take_while_i(i, ary)
VALUE i;
VALUE *ary;
{
if (!RTEST(rb_yield(i))) rb_iter_break();
rb_ary_push(*ary, i);
return Qnil;
}
static VALUE
enum_take_while(obj)
VALUE obj;
{
VALUE ary;
RETURN_ENUMERATOR(obj, 0, 0);
ary = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, take_while_i, (VALUE)&ary);
return ary;
}
static VALUE
drop_i(i, arg)
VALUE i;
VALUE *arg;
{
if (arg[1] == 0) {
rb_ary_push(arg[0], i);
}
else {
arg[1]--;
}
return Qnil;
}
static VALUE
enum_drop(obj, n)
VALUE obj;
VALUE n;
{
VALUE args[2];
long len = NUM2LONG(n);
if (len < 0) {
rb_raise(rb_eArgError, "attempt to drop negative size");
}
args[1] = len;
args[0] = rb_ary_new();
rb_block_call(obj, id_each, 0, 0, drop_i, (VALUE)args);
return args[0];
}
static VALUE
drop_while_i(i, args)
VALUE i;
VALUE *args;
{
if (!args[1] && !RTEST(rb_yield(i))) {
args[1] = Qtrue;
}
if (args[1]) {
rb_ary_push(args[0], i);
}
return Qnil;
}
static VALUE
enum_drop_while(obj)
VALUE obj;
{
VALUE args[2];
RETURN_ENUMERATOR(obj, 0, 0);
args[0] = rb_ary_new();
args[1] = Qfalse;
rb_block_call(obj, id_each, 0, 0, drop_while_i, (VALUE)args);
return args[0];
}
static VALUE
cycle_i(i, ary)
VALUE i;
VALUE ary;
{
rb_ary_push(ary, i);
rb_yield(i);
return Qnil;
}
static VALUE
enum_cycle(argc, argv, obj)
int argc;
VALUE *argv;
VALUE obj;
{
VALUE ary;
VALUE nv = Qnil;
long n, i, len;
rb_scan_args(argc, argv, "01", &nv);
RETURN_ENUMERATOR(obj, argc, argv);
if (NIL_P(nv)) {
n = -1;
}
else {
n = NUM2LONG(nv);
if (n <= 0) return Qnil;
}
ary = rb_ary_new();
RBASIC(ary)->klass = 0;
rb_block_call(obj, id_each, 0, 0, cycle_i, ary);
len = RARRAY(ary)->len;
if (len == 0) return Qnil;
while (n < 0 || 0 < --n) {
for (i=0; i<len; i++) {
rb_yield(RARRAY(ary)->ptr[i]);
}
}
return Qnil;
}
void
Init_Enumerable()
{
rb_mEnumerable = rb_define_module("Enumerable");
rb_define_method(rb_mEnumerable, "to_a", enum_to_a, -1);
rb_define_method(rb_mEnumerable, "entries", enum_to_a, -1);
rb_define_method(rb_mEnumerable, "sort", enum_sort, 0);
rb_define_method(rb_mEnumerable, "sort_by", enum_sort_by, 0);
rb_define_method(rb_mEnumerable, "grep", enum_grep, 1);
rb_define_method(rb_mEnumerable, "count", enum_count, -1);
rb_define_method(rb_mEnumerable, "find", enum_find, -1);
rb_define_method(rb_mEnumerable, "detect", enum_find, -1);
rb_define_method(rb_mEnumerable, "find_index", enum_find_index, -1);
rb_define_method(rb_mEnumerable, "find_all", enum_find_all, 0);
rb_define_method(rb_mEnumerable, "select", enum_find_all, 0);
rb_define_method(rb_mEnumerable, "reject", enum_reject, 0);
rb_define_method(rb_mEnumerable, "collect", enum_collect, 0);
rb_define_method(rb_mEnumerable, "map", enum_collect, 0);
rb_define_method(rb_mEnumerable, "inject", enum_inject, -1);
rb_define_method(rb_mEnumerable, "reduce", enum_inject, -1);
rb_define_method(rb_mEnumerable, "partition", enum_partition, 0);
rb_define_method(rb_mEnumerable, "group_by", enum_group_by, 0);
rb_define_method(rb_mEnumerable, "first", enum_first, -1);
rb_define_method(rb_mEnumerable, "all?", enum_all, 0);
rb_define_method(rb_mEnumerable, "any?", enum_any, 0);
rb_define_method(rb_mEnumerable, "one?", enum_one, 0);
rb_define_method(rb_mEnumerable, "none?", enum_none, 0);
rb_define_method(rb_mEnumerable, "min", enum_min, 0);
rb_define_method(rb_mEnumerable, "max", enum_max, 0);
rb_define_method(rb_mEnumerable, "minmax", enum_minmax, 0);
rb_define_method(rb_mEnumerable, "min_by", enum_min_by, 0);
rb_define_method(rb_mEnumerable, "max_by", enum_max_by, 0);
rb_define_method(rb_mEnumerable, "minmax_by", enum_minmax_by, 0);
rb_define_method(rb_mEnumerable, "member?", enum_member, 1);
rb_define_method(rb_mEnumerable, "include?", enum_member, 1);
rb_define_method(rb_mEnumerable, "each_with_index", enum_each_with_index, 0);
rb_define_method(rb_mEnumerable, "enum_with_index", enum_each_with_index, 0);
rb_define_method(rb_mEnumerable, "reverse_each", enum_reverse_each, -1);
rb_define_method(rb_mEnumerable, "zip", enum_zip, -1);
rb_define_method(rb_mEnumerable, "take", enum_take, 1);
rb_define_method(rb_mEnumerable, "take_while", enum_take_while, 0);
rb_define_method(rb_mEnumerable, "drop", enum_drop, 1);
rb_define_method(rb_mEnumerable, "drop_while", enum_drop_while, 0);
rb_define_method(rb_mEnumerable, "cycle", enum_cycle, -1);
id_eqq = rb_intern("===");
id_each = rb_intern("each");
id_cmp = rb_intern("<=>");
id_size = rb_intern("size");
}