mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* enumerator.c, inits.c (rb_call_inits), ruby.h, intern.h,
ext/enumerator, common.mk (OBJS, enumerator.$(OBJEXT)): Make the enumerator module built-in, * enumerator.c: New method: Enumerable::Enumerator#with_index. * enum.c (enum_each_with_index): Enumerable#each_with_index now returns an enumerator instead of raising an exception if no block is given. Enumerable#enum_with_index, formerly defined in the enumerator module, is kept as an alias to each_with_index for backward compatibility. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@15934 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
knu
parent
2e5a7e770c
commit
fd8c8d09f4
11 changed files with 484 additions and 406 deletions
414
enumerator.c
Normal file
414
enumerator.c
Normal file
|
|
@ -0,0 +1,414 @@
|
|||
/************************************************
|
||||
|
||||
enumerator.c - provides Enumerator class
|
||||
|
||||
$Author$
|
||||
|
||||
Copyright (C) 2001-2003 Akinori MUSHA
|
||||
|
||||
$Idaemons: /home/cvs/rb/enumerator/enumerator.c,v 1.1.1.1 2001/07/15 10:12:48 knu Exp $
|
||||
$RoughId: enumerator.c,v 1.6 2003/07/27 11:03:24 nobu Exp $
|
||||
$Id$
|
||||
|
||||
************************************************/
|
||||
|
||||
#include "ruby.h"
|
||||
|
||||
/*
|
||||
* Document-class: Enumerable::Enumerator
|
||||
*
|
||||
* A class which provides a method `each' to be used as an Enumerable
|
||||
* object.
|
||||
*/
|
||||
VALUE rb_cEnumerator;
|
||||
static VALUE sym_each, sym_call;
|
||||
|
||||
static VALUE
|
||||
proc_call(proc, args)
|
||||
VALUE proc;
|
||||
VALUE args;
|
||||
{
|
||||
if (TYPE(args) != T_ARRAY) {
|
||||
args = rb_ary_new3(1, args);
|
||||
}
|
||||
return rb_proc_call(proc, args);
|
||||
}
|
||||
|
||||
struct enumerator {
|
||||
VALUE method;
|
||||
VALUE proc;
|
||||
VALUE args;
|
||||
rb_block_call_func *iter;
|
||||
};
|
||||
|
||||
static void
|
||||
enumerator_mark(p)
|
||||
void *p;
|
||||
{
|
||||
struct enumerator *ptr = p;
|
||||
rb_gc_mark(ptr->method);
|
||||
rb_gc_mark(ptr->proc);
|
||||
rb_gc_mark(ptr->args);
|
||||
}
|
||||
|
||||
static struct enumerator *
|
||||
enumerator_ptr(obj)
|
||||
VALUE obj;
|
||||
{
|
||||
struct enumerator *ptr;
|
||||
|
||||
Data_Get_Struct(obj, struct enumerator, ptr);
|
||||
if (RDATA(obj)->dmark != enumerator_mark) {
|
||||
rb_raise(rb_eTypeError,
|
||||
"wrong argument type %s (expected Enumerable::Enumerator)",
|
||||
rb_obj_classname(obj));
|
||||
}
|
||||
if (!ptr) {
|
||||
rb_raise(rb_eArgError, "uninitialized enumerator");
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
enumerator_iter_i(i, enum_obj, argc, argv)
|
||||
VALUE i;
|
||||
VALUE enum_obj;
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
{
|
||||
struct enumerator *e = (struct enumerator *)enum_obj;
|
||||
return rb_yield(proc_call(e->proc, i));
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* obj.to_enum(method = :each, *args)
|
||||
* obj.enum_for(method = :each, *args)
|
||||
*
|
||||
* Returns Enumerable::Enumerator.new(self, method, *args).
|
||||
*
|
||||
* e.g.:
|
||||
*
|
||||
* str = "xyz"
|
||||
*
|
||||
* enum = str.enum_for(:each_byte)
|
||||
* a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
|
||||
*
|
||||
* # protects an array from being modified
|
||||
* a = [1, 2, 3]
|
||||
* some_method(a.to_enum)
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
obj_to_enum(argc, argv, obj)
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE obj;
|
||||
{
|
||||
VALUE meth = sym_each;
|
||||
|
||||
if (argc > 0) {
|
||||
--argc;
|
||||
meth = *argv++;
|
||||
}
|
||||
return rb_enumeratorize(obj, meth, argc, argv);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
each_slice_i(val, memo)
|
||||
VALUE val;
|
||||
VALUE *memo;
|
||||
{
|
||||
VALUE ary = memo[0];
|
||||
VALUE v = Qnil;
|
||||
long size = (long)memo[1];
|
||||
|
||||
rb_ary_push(ary, val);
|
||||
|
||||
if (RARRAY_LEN(ary) == size) {
|
||||
v = rb_yield(ary);
|
||||
memo[0] = rb_ary_new2(size);
|
||||
}
|
||||
|
||||
return v;
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* e.each_slice(n) {...}
|
||||
*
|
||||
* Iterates the given block for each slice of <n> elements.
|
||||
*
|
||||
* e.g.:
|
||||
* (1..10).each_slice(3) {|a| p a}
|
||||
* # outputs below
|
||||
* [1, 2, 3]
|
||||
* [4, 5, 6]
|
||||
* [7, 8, 9]
|
||||
* [10]
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
enum_each_slice(obj, n)
|
||||
VALUE obj, n;
|
||||
{
|
||||
long size = NUM2LONG(n);
|
||||
VALUE args[2], ary;
|
||||
|
||||
if (size <= 0) rb_raise(rb_eArgError, "invalid slice size");
|
||||
RETURN_ENUMERATOR(obj, 1, &n);
|
||||
args[0] = rb_ary_new2(size);
|
||||
args[1] = (VALUE)size;
|
||||
|
||||
rb_block_call(obj, SYM2ID(sym_each), 0, 0, each_slice_i, (VALUE)args);
|
||||
|
||||
ary = args[0];
|
||||
if (RARRAY_LEN(ary) > 0) rb_yield(ary);
|
||||
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
each_cons_i(val, memo)
|
||||
VALUE val;
|
||||
VALUE *memo;
|
||||
{
|
||||
VALUE ary = memo[0];
|
||||
VALUE v = Qnil;
|
||||
long size = (long)memo[1];
|
||||
|
||||
if (RARRAY_LEN(ary) == size) {
|
||||
rb_ary_shift(ary);
|
||||
}
|
||||
rb_ary_push(ary, val);
|
||||
if (RARRAY_LEN(ary) == size) {
|
||||
v = rb_yield(rb_ary_dup(ary));
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* each_cons(n) {...}
|
||||
*
|
||||
* Iterates the given block for each array of consecutive <n>
|
||||
* elements.
|
||||
*
|
||||
* e.g.:
|
||||
* (1..10).each_cons(3) {|a| p a}
|
||||
* # outputs below
|
||||
* [1, 2, 3]
|
||||
* [2, 3, 4]
|
||||
* [3, 4, 5]
|
||||
* [4, 5, 6]
|
||||
* [5, 6, 7]
|
||||
* [6, 7, 8]
|
||||
* [7, 8, 9]
|
||||
* [8, 9, 10]
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
enum_each_cons(obj, n)
|
||||
VALUE obj, n;
|
||||
{
|
||||
long size = NUM2LONG(n);
|
||||
VALUE args[2];
|
||||
|
||||
if (size <= 0) rb_raise(rb_eArgError, "invalid size");
|
||||
RETURN_ENUMERATOR(obj, 1, &n);
|
||||
args[0] = rb_ary_new2(size);
|
||||
args[1] = (VALUE)size;
|
||||
|
||||
rb_block_call(obj, SYM2ID(sym_each), 0, 0, each_cons_i, (VALUE)args);
|
||||
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
static VALUE
|
||||
enumerator_allocate(klass)
|
||||
VALUE klass;
|
||||
{
|
||||
struct enumerator *ptr;
|
||||
return Data_Make_Struct(klass, struct enumerator,
|
||||
enumerator_mark, -1, ptr);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
enumerator_each_i(v, enum_obj)
|
||||
VALUE v;
|
||||
VALUE enum_obj;
|
||||
{
|
||||
return rb_yield(v);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
enumerator_init(enum_obj, obj, meth, argc, argv)
|
||||
VALUE enum_obj;
|
||||
VALUE obj;
|
||||
VALUE meth;
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
{
|
||||
struct enumerator *ptr = enumerator_ptr(enum_obj);
|
||||
|
||||
ptr->method = rb_obj_method(obj, meth);
|
||||
if (rb_block_given_p()) {
|
||||
ptr->proc = rb_block_proc();
|
||||
ptr->iter = enumerator_iter_i;
|
||||
}
|
||||
else {
|
||||
ptr->iter = enumerator_each_i;
|
||||
}
|
||||
if (argc) ptr->args = rb_ary_new4(argc, argv);
|
||||
|
||||
return enum_obj;
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* Enumerable::Enumerator.new(obj, method = :each, *args)
|
||||
*
|
||||
* Creates a new Enumerable::Enumerator object, which is to be
|
||||
* used as an Enumerable object using the given object's given
|
||||
* method with the given arguments.
|
||||
*
|
||||
* e.g.:
|
||||
* str = "xyz"
|
||||
*
|
||||
* enum = Enumerable::Enumerator.new(str, :each_byte)
|
||||
* a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
enumerator_initialize(argc, argv, obj)
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
VALUE obj;
|
||||
{
|
||||
VALUE recv, meth = sym_each;
|
||||
|
||||
if (argc == 0)
|
||||
rb_raise(rb_eArgError, "wrong number of argument (0 for 1)");
|
||||
recv = *argv++;
|
||||
if (--argc) {
|
||||
meth = *argv++;
|
||||
--argc;
|
||||
}
|
||||
return enumerator_init(obj, recv, meth, argc, argv);
|
||||
}
|
||||
|
||||
/* :nodoc: */
|
||||
static VALUE
|
||||
enumerator_init_copy(obj, orig)
|
||||
VALUE obj;
|
||||
VALUE orig;
|
||||
{
|
||||
struct enumerator *ptr0, *ptr1;
|
||||
|
||||
ptr0 = enumerator_ptr(orig);
|
||||
ptr1 = enumerator_ptr(obj);
|
||||
|
||||
ptr1->method = ptr0->method;
|
||||
ptr1->proc = ptr0->proc;
|
||||
ptr1->iter = ptr0->iter;
|
||||
ptr1->args = ptr0->args;
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
VALUE
|
||||
rb_enumeratorize(obj, meth, argc, argv)
|
||||
VALUE obj;
|
||||
VALUE meth;
|
||||
int argc;
|
||||
VALUE *argv;
|
||||
{
|
||||
return enumerator_init(enumerator_allocate(rb_cEnumerator), obj, meth, argc, argv);
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* enum.each {...}
|
||||
*
|
||||
* Iterates the given block using the object and the method specified
|
||||
* in the first place.
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
enumerator_each(obj)
|
||||
VALUE obj;
|
||||
{
|
||||
struct enumerator *e;
|
||||
int argc = 0;
|
||||
VALUE *argv = 0;
|
||||
|
||||
if (!rb_block_given_p()) return obj;
|
||||
e = enumerator_ptr(obj);
|
||||
if (e->args) {
|
||||
argc = RARRAY_LEN(e->args);
|
||||
argv = RARRAY_PTR(e->args);
|
||||
}
|
||||
return rb_block_call(e->method, SYM2ID(sym_call), argc, argv, e->iter, (VALUE)e);
|
||||
}
|
||||
|
||||
static VALUE
|
||||
enumerator_with_index_i(val, memo)
|
||||
VALUE val;
|
||||
VALUE *memo;
|
||||
{
|
||||
val = rb_yield_values(2, val, INT2FIX(*memo));
|
||||
++*memo;
|
||||
return val;
|
||||
}
|
||||
|
||||
/*
|
||||
* call-seq:
|
||||
* e.with_index {|(*args), idx| ... }
|
||||
*
|
||||
* Iterates the given block for each elements with an index, which
|
||||
* start from 0.
|
||||
*
|
||||
*/
|
||||
static VALUE
|
||||
enumerator_with_index(obj)
|
||||
VALUE obj;
|
||||
{
|
||||
struct enumerator *e = enumerator_ptr(obj);
|
||||
VALUE memo = 0;
|
||||
int argc = 0;
|
||||
VALUE *argv = 0;
|
||||
|
||||
RETURN_ENUMERATOR(obj, 0, 0);
|
||||
if (e->args) {
|
||||
argc = RARRAY_LEN(e->args);
|
||||
argv = RARRAY_PTR(e->args);
|
||||
}
|
||||
return rb_block_call(e->method, SYM2ID(sym_call), argc, argv,
|
||||
enumerator_with_index_i, (VALUE)&memo);
|
||||
}
|
||||
|
||||
void
|
||||
Init_Enumerator()
|
||||
{
|
||||
rb_define_method(rb_mKernel, "to_enum", obj_to_enum, -1);
|
||||
rb_define_method(rb_mKernel, "enum_for", obj_to_enum, -1);
|
||||
|
||||
rb_define_method(rb_mEnumerable, "each_slice", enum_each_slice, 1);
|
||||
rb_define_method(rb_mEnumerable, "enum_slice", enum_each_slice, 1);
|
||||
rb_define_method(rb_mEnumerable, "each_cons", enum_each_cons, 1);
|
||||
rb_define_method(rb_mEnumerable, "enum_cons", enum_each_cons, 1);
|
||||
|
||||
rb_cEnumerator = rb_define_class_under(rb_mEnumerable, "Enumerator", rb_cObject);
|
||||
rb_include_module(rb_cEnumerator, rb_mEnumerable);
|
||||
|
||||
rb_define_alloc_func(rb_cEnumerator, enumerator_allocate);
|
||||
rb_define_method(rb_cEnumerator, "initialize", enumerator_initialize, -1);
|
||||
rb_define_method(rb_cEnumerator, "initialize_copy", enumerator_init_copy, 1);
|
||||
rb_define_method(rb_cEnumerator, "each", enumerator_each, 0);
|
||||
rb_define_method(rb_cEnumerator, "with_index", enumerator_with_index, 0);
|
||||
|
||||
sym_each = ID2SYM(rb_intern("each"));
|
||||
sym_call = ID2SYM(rb_intern("call"));
|
||||
|
||||
rb_provide("enumerator.so"); /* for backward compatibility */
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue