2003-10-13 13:09:23 -04:00
|
|
|
/************************************************
|
|
|
|
|
|
|
|
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$
|
|
|
|
|
|
|
|
************************************************/
|
|
|
|
|
2007-06-09 23:06:15 -04:00
|
|
|
#include "ruby/ruby.h"
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
/*
|
2008-08-13 02:25:53 -04:00
|
|
|
* Document-class: Enumerator
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* A class which allows both internal and external iteration.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* An Enumerator can be created by the following methods.
|
2009-08-19 12:36:00 -04:00
|
|
|
* - Kernel#to_enum
|
2010-05-29 14:51:39 -04:00
|
|
|
* - Kernel#enum_for
|
2009-08-19 12:36:00 -04:00
|
|
|
* - Enumerator.new
|
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Most methods have two forms: a block form where the contents
|
|
|
|
* are evaluated for each item in the enumeration, and a non-block form
|
|
|
|
* which returns a new Enumerator wrapping the iteration.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* enumerator = %w(one two three).each
|
|
|
|
* puts enumerator.class # => Enumerator
|
|
|
|
* enumerator.each_with_object("foo") do |item,obj|
|
|
|
|
* puts "#{obj}: #{item}"
|
|
|
|
* end
|
|
|
|
* # foo: one
|
|
|
|
* # foo: two
|
|
|
|
* # foo: three
|
|
|
|
* enum_with_obj = enumerator.each_with_object("foo")
|
|
|
|
* puts enum_with_obj.class # => Enumerator
|
|
|
|
* enum_with_obj.each do |item,obj|
|
|
|
|
* puts "#{obj: #{item}"
|
|
|
|
* end
|
|
|
|
* # foo: one
|
|
|
|
* # foo: two
|
|
|
|
* # foo: three
|
|
|
|
*
|
|
|
|
* This allows you to chain Enumerators together. For example, you
|
|
|
|
* can map a list's elements to strings containing the index
|
|
|
|
* and the element as a string via:
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* puts %w[foo bar baz].map.with_index {|w,i| "#{i}:#{w}" }
|
|
|
|
* # => ["0:foo", "1:bar", "2:baz"]
|
|
|
|
*
|
|
|
|
* An Enumerator can also be used as an external iterator.
|
|
|
|
* For example, Enumerator#next returns the next value of the iterator
|
|
|
|
* or raises StopIteration if the Enumerator is at the end.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2009-08-21 11:18:57 -04:00
|
|
|
* e = [1,2,3].each # returns an enumerator object.
|
2011-05-22 19:33:21 -04:00
|
|
|
* puts e.next # => 1
|
|
|
|
* puts e.next # => 2
|
|
|
|
* puts e.next # => 3
|
|
|
|
* puts e.next # raises StopIteration
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* You can use this to implement an internal iterator as follows:
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
|
|
|
* def ext_each(e)
|
|
|
|
* while true
|
|
|
|
* begin
|
|
|
|
* vs = e.next_values
|
|
|
|
* rescue StopIteration
|
|
|
|
* return $!.result
|
|
|
|
* end
|
2009-08-21 23:19:53 -04:00
|
|
|
* y = yield(*vs)
|
2009-08-19 12:36:00 -04:00
|
|
|
* e.feed y
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
*
|
|
|
|
* o = Object.new
|
2011-05-22 19:33:21 -04:00
|
|
|
*
|
2009-08-19 12:36:00 -04:00
|
|
|
* def o.each
|
2011-05-22 19:33:21 -04:00
|
|
|
* puts yield
|
|
|
|
* puts yield(1)
|
|
|
|
* puts yield(1, 2)
|
2009-08-21 23:40:35 -04:00
|
|
|
* 3
|
2009-08-19 12:36:00 -04:00
|
|
|
* end
|
|
|
|
*
|
|
|
|
* # use o.each as an internal iterator directly.
|
2011-05-22 19:33:21 -04:00
|
|
|
* puts o.each {|*x| puts x; [:b, *x] }
|
|
|
|
* # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2009-08-21 23:19:53 -04:00
|
|
|
* # convert o.each to an external iterator for
|
2009-08-19 12:36:00 -04:00
|
|
|
* # implementing an internal iterator.
|
2011-05-22 19:33:21 -04:00
|
|
|
* puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
|
|
|
|
* # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2005-07-14 11:15:22 -04:00
|
|
|
*/
|
2008-04-20 08:01:27 -04:00
|
|
|
VALUE rb_cEnumerator;
|
2009-02-02 06:50:49 -05:00
|
|
|
static ID id_rewind, id_each;
|
2008-04-20 07:58:44 -04:00
|
|
|
static VALUE sym_each;
|
2005-07-11 10:50:42 -04:00
|
|
|
|
2007-08-08 03:07:03 -04:00
|
|
|
VALUE rb_eStopIteration;
|
|
|
|
|
2005-07-11 10:50:42 -04:00
|
|
|
struct enumerator {
|
2008-04-20 07:58:44 -04:00
|
|
|
VALUE obj;
|
2008-04-21 03:07:39 -04:00
|
|
|
ID meth;
|
2005-07-11 10:50:42 -04:00
|
|
|
VALUE args;
|
2007-08-06 12:41:17 -04:00
|
|
|
VALUE fib;
|
2007-08-06 12:53:36 -04:00
|
|
|
VALUE dst;
|
2009-08-18 08:02:53 -04:00
|
|
|
VALUE lookahead;
|
2009-08-19 12:36:00 -04:00
|
|
|
VALUE feedvalue;
|
|
|
|
VALUE stop_exc;
|
2005-07-11 10:50:42 -04:00
|
|
|
};
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
static VALUE rb_cGenerator, rb_cYielder;
|
|
|
|
|
|
|
|
struct generator {
|
|
|
|
VALUE proc;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct yielder {
|
|
|
|
VALUE proc;
|
|
|
|
};
|
|
|
|
|
|
|
|
static VALUE generator_allocate(VALUE klass);
|
|
|
|
static VALUE generator_init(VALUE obj, VALUE proc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enumerator
|
|
|
|
*/
|
2005-07-11 10:50:42 -04:00
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_mark(void *p)
|
2005-07-11 10:50:42 -04:00
|
|
|
{
|
|
|
|
struct enumerator *ptr = p;
|
2008-04-20 07:58:44 -04:00
|
|
|
rb_gc_mark(ptr->obj);
|
2005-07-11 10:50:42 -04:00
|
|
|
rb_gc_mark(ptr->args);
|
2007-08-06 12:41:17 -04:00
|
|
|
rb_gc_mark(ptr->fib);
|
2007-08-06 12:53:36 -04:00
|
|
|
rb_gc_mark(ptr->dst);
|
2009-08-18 08:02:53 -04:00
|
|
|
rb_gc_mark(ptr->lookahead);
|
2009-08-19 12:36:00 -04:00
|
|
|
rb_gc_mark(ptr->feedvalue);
|
|
|
|
rb_gc_mark(ptr->stop_exc);
|
2005-07-11 10:50:42 -04:00
|
|
|
}
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
#define enumerator_free RUBY_TYPED_DEFAULT_FREE
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
enumerator_memsize(const void *p)
|
|
|
|
{
|
|
|
|
return p ? sizeof(struct enumerator) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t enumerator_data_type = {
|
|
|
|
"enumerator",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
enumerator_mark,
|
|
|
|
enumerator_free,
|
|
|
|
enumerator_memsize,
|
|
|
|
},
|
2009-09-08 22:46:00 -04:00
|
|
|
};
|
|
|
|
|
2005-07-11 10:50:42 -04:00
|
|
|
static struct enumerator *
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_ptr(VALUE obj)
|
2005-07-11 10:50:42 -04:00
|
|
|
{
|
|
|
|
struct enumerator *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, ptr);
|
2008-06-02 23:58:30 -04:00
|
|
|
if (!ptr || ptr->obj == Qundef) {
|
2005-07-11 10:50:42 -04:00
|
|
|
rb_raise(rb_eArgError, "uninitialized enumerator");
|
|
|
|
}
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* obj.to_enum(method = :each, *args)
|
|
|
|
* obj.enum_for(method = :each, *args)
|
|
|
|
*
|
|
|
|
* Creates a new Enumerator which will enumerate by on calling +method+ on
|
|
|
|
* +obj+.
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* +method+:: the method to call on +obj+ to generate the enumeration
|
|
|
|
* +args+:: arguments that will be passed in +method+ <i>in addition</i>
|
|
|
|
* to the item itself. Note that the number of args
|
|
|
|
* must not exceed the number expected by +method+
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* === Example
|
2008-03-08 20:04:46 -05:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* str = "xyz"
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* enum = str.enum_for(:each_byte)
|
|
|
|
* enum.each { |b| puts b }
|
|
|
|
* # => 120
|
|
|
|
* # => 121
|
|
|
|
* # => 122
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* # protect an array from being modified by some_method
|
|
|
|
* a = [1, 2, 3]
|
|
|
|
* some_method(a.to_enum)
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
|
|
|
*/
|
2003-10-13 13:09:23 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
obj_to_enum(int argc, VALUE *argv, VALUE obj)
|
2003-10-13 13:09:23 -04:00
|
|
|
{
|
2005-07-14 11:15:22 -04:00
|
|
|
VALUE meth = sym_each;
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
if (argc > 0) {
|
|
|
|
--argc;
|
|
|
|
meth = *argv++;
|
|
|
|
}
|
|
|
|
return rb_enumeratorize(obj, meth, argc, argv);
|
2003-10-13 13:09:23 -04:00
|
|
|
}
|
|
|
|
|
2005-07-11 10:50:42 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_allocate(VALUE klass)
|
2005-07-11 10:50:42 -04:00
|
|
|
{
|
|
|
|
struct enumerator *ptr;
|
2008-06-02 23:58:30 -04:00
|
|
|
VALUE enum_obj;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
enum_obj = TypedData_Make_Struct(klass, struct enumerator, &enumerator_data_type, ptr);
|
2008-06-02 23:58:30 -04:00
|
|
|
ptr->obj = Qundef;
|
|
|
|
|
|
|
|
return enum_obj;
|
2003-10-13 13:09:23 -04:00
|
|
|
}
|
|
|
|
|
2005-10-18 13:35:18 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_init(VALUE enum_obj, VALUE obj, VALUE meth, int argc, VALUE *argv)
|
2003-10-13 13:09:23 -04:00
|
|
|
{
|
2008-06-02 23:58:30 -04:00
|
|
|
struct enumerator *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(enum_obj, struct enumerator, &enumerator_data_type, ptr);
|
2008-06-02 23:58:30 -04:00
|
|
|
|
|
|
|
if (!ptr) {
|
|
|
|
rb_raise(rb_eArgError, "unallocated enumerator");
|
|
|
|
}
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2008-04-20 07:58:44 -04:00
|
|
|
ptr->obj = obj;
|
2008-04-21 03:07:39 -04:00
|
|
|
ptr->meth = rb_to_id(meth);
|
2005-07-14 11:15:22 -04:00
|
|
|
if (argc) ptr->args = rb_ary_new4(argc, argv);
|
2007-08-06 12:41:17 -04:00
|
|
|
ptr->fib = 0;
|
2007-08-24 06:48:43 -04:00
|
|
|
ptr->dst = Qnil;
|
2009-08-18 08:02:53 -04:00
|
|
|
ptr->lookahead = Qundef;
|
2009-08-19 12:36:00 -04:00
|
|
|
ptr->feedvalue = Qundef;
|
|
|
|
ptr->stop_exc = Qfalse;
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
return enum_obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* Enumerator.new { |yielder| ... }
|
|
|
|
* Enumerator.new(obj, method = :each, *args)
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Creates a new Enumerator object, which can be used as an
|
|
|
|
* Enumerable.
|
2008-08-26 01:42:12 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* In the first form, iteration is defined by the given block, in
|
|
|
|
* which a "yielder" object, given as block parameter, can be used to
|
|
|
|
* yield a value by calling the +yield+ method (aliased as +<<+):
|
2008-08-26 01:42:12 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* fib = Enumerator.new do |y|
|
|
|
|
* a = b = 1
|
|
|
|
* loop do
|
|
|
|
* y << a
|
|
|
|
* a, b = b, a + b
|
|
|
|
* end
|
|
|
|
* end
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
|
2008-08-26 01:42:12 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* In the second, deprecated, form, a generated Enumerator iterates over the
|
|
|
|
* given object using the given method with the given arguments passed.
|
2008-08-26 01:42:12 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Use of this form is discouraged. Use Kernel#enum_for or Kernel#to_enum
|
|
|
|
* instead.
|
|
|
|
*
|
|
|
|
* e = Enumerator.new(ObjectSpace, :each_object)
|
|
|
|
* #-> ObjectSpace.enum_for(:each_object)
|
|
|
|
*
|
|
|
|
* e.select { |obj| obj.is_a?(Class) } #=> array of all classes
|
2008-08-26 01:42:12 -04:00
|
|
|
*
|
2005-07-14 11:15:22 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_initialize(int argc, VALUE *argv, VALUE obj)
|
2005-07-14 11:15:22 -04:00
|
|
|
{
|
|
|
|
VALUE recv, meth = sym_each;
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
if (argc == 0) {
|
|
|
|
if (!rb_block_given_p())
|
|
|
|
rb_raise(rb_eArgError, "wrong number of argument (0 for 1+)");
|
|
|
|
|
|
|
|
recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc());
|
2009-09-29 11:37:28 -04:00
|
|
|
}
|
|
|
|
else {
|
2008-08-26 01:42:12 -04:00
|
|
|
recv = *argv++;
|
|
|
|
if (--argc) {
|
|
|
|
meth = *argv++;
|
|
|
|
--argc;
|
|
|
|
}
|
2005-07-14 11:15:22 -04:00
|
|
|
}
|
2008-08-26 01:42:12 -04:00
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
return enumerator_init(obj, recv, meth, argc, argv);
|
|
|
|
}
|
|
|
|
|
2007-01-25 17:52:38 -05:00
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
enumerator_init_copy(VALUE obj, VALUE orig)
|
|
|
|
{
|
2007-12-21 00:59:20 -05:00
|
|
|
struct enumerator *ptr0, *ptr1;
|
|
|
|
|
|
|
|
ptr0 = enumerator_ptr(orig);
|
2007-12-21 01:18:25 -05:00
|
|
|
if (ptr0->fib) {
|
2007-12-21 00:59:20 -05:00
|
|
|
/* Fibers cannot be copied */
|
|
|
|
rb_raise(rb_eTypeError, "can't copy execution context");
|
|
|
|
}
|
2008-06-03 06:34:45 -04:00
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, ptr1);
|
2008-06-03 06:34:45 -04:00
|
|
|
|
|
|
|
if (!ptr1) {
|
|
|
|
rb_raise(rb_eArgError, "unallocated enumerator");
|
|
|
|
}
|
2007-01-25 17:52:38 -05:00
|
|
|
|
2008-04-20 07:58:44 -04:00
|
|
|
ptr1->obj = ptr0->obj;
|
|
|
|
ptr1->meth = ptr0->meth;
|
2007-01-25 17:52:38 -05:00
|
|
|
ptr1->args = ptr0->args;
|
2007-12-21 00:59:20 -05:00
|
|
|
ptr1->fib = 0;
|
2009-08-18 08:02:53 -04:00
|
|
|
ptr1->lookahead = Qundef;
|
2009-08-19 12:36:00 -04:00
|
|
|
ptr1->feedvalue = Qundef;
|
2007-01-25 17:52:38 -05:00
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_enumeratorize(VALUE obj, VALUE meth, int argc, VALUE *argv)
|
2005-07-14 11:15:22 -04:00
|
|
|
{
|
|
|
|
return enumerator_init(enumerator_allocate(rb_cEnumerator), obj, meth, argc, argv);
|
2003-10-13 13:09:23 -04:00
|
|
|
}
|
|
|
|
|
2009-09-29 11:37:28 -04:00
|
|
|
static VALUE
|
|
|
|
enumerator_block_call(VALUE obj, rb_block_call_func *func, VALUE arg)
|
|
|
|
{
|
|
|
|
int argc = 0;
|
|
|
|
VALUE *argv = 0;
|
|
|
|
const struct enumerator *e = enumerator_ptr(obj);
|
|
|
|
ID meth = e->meth;
|
|
|
|
|
|
|
|
if (e->args) {
|
|
|
|
argc = RARRAY_LENINT(e->args);
|
|
|
|
argv = RARRAY_PTR(e->args);
|
|
|
|
}
|
|
|
|
return rb_block_call(e->obj, meth, argc, argv, func, arg);
|
|
|
|
}
|
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* enum.each {...}
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Iterates over the block according to how this Enumerable was constructed.
|
|
|
|
* If no block is given, returns self.
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
|
|
|
*/
|
2003-10-13 13:09:23 -04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
enumerator_each(VALUE obj)
|
2003-10-13 13:09:23 -04:00
|
|
|
{
|
2006-02-14 07:36:11 -05:00
|
|
|
if (!rb_block_given_p()) return obj;
|
2009-12-20 07:31:26 -05:00
|
|
|
return enumerator_block_call(obj, 0, obj);
|
2005-07-11 10:50:42 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2009-09-29 11:37:28 -04:00
|
|
|
enumerator_with_index_i(VALUE val, VALUE m, int argc, VALUE *argv)
|
2005-07-11 10:50:42 -04:00
|
|
|
{
|
2009-03-17 05:07:18 -04:00
|
|
|
VALUE idx;
|
2009-09-29 11:37:28 -04:00
|
|
|
VALUE *memo = (VALUE *)m;
|
2009-03-17 05:07:18 -04:00
|
|
|
|
|
|
|
idx = INT2FIX(*memo);
|
2005-07-11 10:50:42 -04:00
|
|
|
++*memo;
|
2009-03-17 05:07:18 -04:00
|
|
|
|
|
|
|
if (argc <= 1)
|
|
|
|
return rb_yield_values(2, val, idx);
|
|
|
|
|
|
|
|
return rb_yield_values(2, rb_ary_new4(argc, argv), idx);
|
2003-10-13 13:09:23 -04:00
|
|
|
}
|
|
|
|
|
2005-07-14 11:15:22 -04:00
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* e.with_index(offset = 0) {|(*args), idx| ... }
|
|
|
|
* e.with_index(offset = 0)
|
|
|
|
*
|
|
|
|
* Iterates the given block for each element with an index, which
|
|
|
|
* starts from +offset+. If no block is given, returns a new Enumerator
|
|
|
|
* that includes the index, starting from +offset+
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* +offset+:: the starting index to use
|
2005-07-14 11:15:22 -04:00
|
|
|
*
|
|
|
|
*/
|
2005-07-11 10:50:42 -04:00
|
|
|
static VALUE
|
2009-02-08 09:42:01 -05:00
|
|
|
enumerator_with_index(int argc, VALUE *argv, VALUE obj)
|
2005-07-11 10:50:42 -04:00
|
|
|
{
|
2009-02-08 09:42:01 -05:00
|
|
|
VALUE memo;
|
2006-02-03 04:15:42 -05:00
|
|
|
|
2009-02-08 09:42:01 -05:00
|
|
|
rb_scan_args(argc, argv, "01", &memo);
|
|
|
|
RETURN_ENUMERATOR(obj, argc, argv);
|
|
|
|
memo = NIL_P(memo) ? 0 : (VALUE)NUM2LONG(memo);
|
2009-09-29 11:37:28 -04:00
|
|
|
return enumerator_block_call(obj, enumerator_with_index_i, (VALUE)&memo);
|
2005-07-11 10:50:42 -04:00
|
|
|
}
|
|
|
|
|
2009-02-08 09:42:01 -05:00
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* e.each_with_index {|(*args), idx| ... }
|
|
|
|
* e.each_with_index
|
2009-02-08 09:42:01 -05:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Same as Enumerator#with_index(0), i.e. there is no starting offset.
|
|
|
|
*
|
|
|
|
* If no block is given, a new Enumerator is returned that includes the index.
|
2009-02-08 09:42:01 -05:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
enumerator_each_with_index(VALUE obj)
|
|
|
|
{
|
|
|
|
return enumerator_with_index(0, NULL, obj);
|
|
|
|
}
|
|
|
|
|
2008-06-03 08:43:45 -04:00
|
|
|
static VALUE
|
2009-03-17 05:07:18 -04:00
|
|
|
enumerator_with_object_i(VALUE val, VALUE memo, int argc, VALUE *argv)
|
2008-06-03 08:43:45 -04:00
|
|
|
{
|
2009-03-17 05:07:18 -04:00
|
|
|
if (argc <= 1)
|
|
|
|
return rb_yield_values(2, val, memo);
|
|
|
|
|
|
|
|
return rb_yield_values(2, rb_ary_new4(argc, argv), memo);
|
2008-06-03 08:43:45 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* call-seq:
|
|
|
|
* e.with_object(obj) {|(*args), obj| ... }
|
|
|
|
* e.with_object(obj)
|
|
|
|
*
|
|
|
|
* Iterates the given block for each element with an arbitrary object, +obj+,
|
|
|
|
* and returns +obj+
|
2008-06-03 08:43:45 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* If no block is given, returns a new Enumerator.
|
2008-06-03 08:43:45 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* === Example
|
2008-06-03 08:43:45 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* to_three = Enumerator.new do |y|
|
|
|
|
* 3.times do |x|
|
|
|
|
* y << x
|
|
|
|
* end
|
|
|
|
* end
|
|
|
|
*
|
|
|
|
* to_three_with_string = to_three.with_object("foo")
|
|
|
|
* to_three_with_string.each do |x,string|
|
|
|
|
* puts "#{string}: #{x}"
|
|
|
|
* end
|
|
|
|
*
|
|
|
|
* # => foo:0
|
|
|
|
* # => foo:1
|
|
|
|
* # => foo:2
|
2008-06-03 08:43:45 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
2008-06-15 20:49:25 -04:00
|
|
|
enumerator_with_object(VALUE obj, VALUE memo)
|
2008-06-03 08:43:45 -04:00
|
|
|
{
|
2008-08-26 01:45:18 -04:00
|
|
|
RETURN_ENUMERATOR(obj, 1, &memo);
|
2009-09-29 11:37:28 -04:00
|
|
|
enumerator_block_call(obj, enumerator_with_object_i, memo);
|
2008-06-03 08:43:45 -04:00
|
|
|
|
|
|
|
return memo;
|
|
|
|
}
|
|
|
|
|
2007-08-06 12:41:17 -04:00
|
|
|
static VALUE
|
2008-01-08 04:50:01 -05:00
|
|
|
next_ii(VALUE i, VALUE obj, int argc, VALUE *argv)
|
2007-08-06 12:41:17 -04:00
|
|
|
{
|
2009-08-19 12:36:00 -04:00
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
|
|
|
VALUE feedvalue = Qnil;
|
|
|
|
VALUE args = rb_ary_new4(argc, argv);
|
|
|
|
rb_fiber_yield(1, &args);
|
|
|
|
if (e->feedvalue != Qundef) {
|
|
|
|
feedvalue = e->feedvalue;
|
|
|
|
e->feedvalue = Qundef;
|
|
|
|
}
|
|
|
|
return feedvalue;
|
2007-08-06 12:41:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2007-08-06 12:53:36 -04:00
|
|
|
next_i(VALUE curr, VALUE obj)
|
2007-08-06 12:41:17 -04:00
|
|
|
{
|
2007-08-06 12:53:36 -04:00
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
2007-08-24 06:48:43 -04:00
|
|
|
VALUE nil = Qnil;
|
2009-08-19 12:36:00 -04:00
|
|
|
VALUE result;
|
2007-08-20 14:58:32 -04:00
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
result = rb_block_call(obj, id_each, 0, 0, next_ii, obj);
|
2009-08-27 18:28:15 -04:00
|
|
|
e->stop_exc = rb_exc_new2(rb_eStopIteration, "iteration reached an end");
|
2009-08-19 12:36:00 -04:00
|
|
|
rb_ivar_set(e->stop_exc, rb_intern("result"), result);
|
2007-08-24 06:48:43 -04:00
|
|
|
return rb_fiber_yield(1, &nil);
|
2007-08-06 12:41:17 -04:00
|
|
|
}
|
|
|
|
|
2007-08-08 03:07:03 -04:00
|
|
|
static void
|
|
|
|
next_init(VALUE obj, struct enumerator *e)
|
|
|
|
{
|
|
|
|
VALUE curr = rb_fiber_current();
|
|
|
|
e->dst = curr;
|
2007-08-24 22:03:44 -04:00
|
|
|
e->fib = rb_fiber_new(next_i, obj);
|
2009-08-18 08:02:53 -04:00
|
|
|
e->lookahead = Qundef;
|
2007-08-08 03:07:03 -04:00
|
|
|
}
|
|
|
|
|
2009-08-21 09:39:35 -04:00
|
|
|
static VALUE
|
|
|
|
get_next_values(VALUE obj, struct enumerator *e)
|
|
|
|
{
|
|
|
|
VALUE curr, vs;
|
|
|
|
|
|
|
|
if (e->stop_exc)
|
|
|
|
rb_exc_raise(e->stop_exc);
|
|
|
|
|
|
|
|
curr = rb_fiber_current();
|
|
|
|
|
|
|
|
if (!e->fib || !rb_fiber_alive_p(e->fib)) {
|
|
|
|
next_init(obj, e);
|
|
|
|
}
|
|
|
|
|
|
|
|
vs = rb_fiber_resume(e->fib, 1, &curr);
|
|
|
|
if (e->stop_exc) {
|
|
|
|
e->fib = 0;
|
|
|
|
e->dst = Qnil;
|
|
|
|
e->lookahead = Qundef;
|
|
|
|
e->feedvalue = Qundef;
|
|
|
|
rb_exc_raise(e->stop_exc);
|
|
|
|
}
|
|
|
|
return vs;
|
|
|
|
}
|
|
|
|
|
2007-08-06 12:41:17 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.next_values -> array
|
2007-08-06 12:41:17 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Returns the next object as an array in the enumerator, and move the
|
|
|
|
* internal position forward. When the position reached at the end,
|
|
|
|
* StopIteration is raised.
|
|
|
|
*
|
|
|
|
* This method can be used to distinguish <code>yield</code> and <code>yield
|
|
|
|
* nil</code>.
|
2007-08-06 12:41:17 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* === Example
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
|
|
|
* o = Object.new
|
|
|
|
* def o.each
|
|
|
|
* yield
|
|
|
|
* yield 1
|
|
|
|
* yield 1, 2
|
|
|
|
* yield nil
|
|
|
|
* yield [1, 2]
|
|
|
|
* end
|
|
|
|
* e = o.to_enum
|
|
|
|
* p e.next_values
|
|
|
|
* p e.next_values
|
|
|
|
* p e.next_values
|
|
|
|
* p e.next_values
|
|
|
|
* p e.next_values
|
|
|
|
* e = o.to_enum
|
|
|
|
* p e.next
|
|
|
|
* p e.next
|
|
|
|
* p e.next
|
|
|
|
* p e.next
|
|
|
|
* p e.next
|
|
|
|
*
|
2009-08-19 16:26:38 -04:00
|
|
|
* ## yield args next_values next
|
|
|
|
* # yield [] nil
|
|
|
|
* # yield 1 [1] 1
|
|
|
|
* # yield 1, 2 [1, 2] [1, 2]
|
|
|
|
* # yield nil [nil] nil
|
|
|
|
* # yield [1, 2] [[1, 2]] [1, 2]
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-07-08 20:25:27 -04:00
|
|
|
* Note that +next_values+ does not affect other non-external enumeration
|
|
|
|
* methods unless underlying iteration method itself has side-effect, e.g.
|
|
|
|
* IO#each_line.
|
2007-08-06 12:41:17 -04:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2009-08-19 12:36:00 -04:00
|
|
|
enumerator_next_values(VALUE obj)
|
2007-08-06 12:41:17 -04:00
|
|
|
{
|
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
2009-08-21 09:39:35 -04:00
|
|
|
VALUE vs;
|
2009-08-18 08:02:53 -04:00
|
|
|
|
|
|
|
if (e->lookahead != Qundef) {
|
2009-08-21 09:39:35 -04:00
|
|
|
vs = e->lookahead;
|
2009-08-18 08:02:53 -04:00
|
|
|
e->lookahead = Qundef;
|
2009-08-21 09:39:35 -04:00
|
|
|
return vs;
|
2009-08-18 08:02:53 -04:00
|
|
|
}
|
|
|
|
|
2009-08-21 09:39:35 -04:00
|
|
|
return get_next_values(obj, e);
|
2007-08-06 12:41:17 -04:00
|
|
|
}
|
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
static VALUE
|
2009-08-21 11:51:35 -04:00
|
|
|
ary2sv(VALUE args, int dup)
|
2009-08-19 12:36:00 -04:00
|
|
|
{
|
2011-09-29 07:07:45 -04:00
|
|
|
if (!RB_TYPE_P(args, T_ARRAY))
|
2009-08-19 12:36:00 -04:00
|
|
|
return args;
|
|
|
|
|
|
|
|
switch (RARRAY_LEN(args)) {
|
|
|
|
case 0:
|
|
|
|
return Qnil;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
return RARRAY_PTR(args)[0];
|
|
|
|
|
|
|
|
default:
|
2009-08-21 11:51:35 -04:00
|
|
|
if (dup)
|
|
|
|
return rb_ary_dup(args);
|
2009-08-19 12:36:00 -04:00
|
|
|
return args;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-18 08:02:53 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.next -> object
|
2009-08-18 08:02:53 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Returns the next object in the enumerator, and move the internal position
|
|
|
|
* forward. When the position reached at the end, StopIteration is raised.
|
|
|
|
*
|
|
|
|
* === Example
|
2009-08-18 08:02:53 -04:00
|
|
|
*
|
2009-08-21 23:19:53 -04:00
|
|
|
* a = [1,2,3]
|
|
|
|
* e = a.to_enum
|
|
|
|
* p e.next #=> 1
|
|
|
|
* p e.next #=> 2
|
|
|
|
* p e.next #=> 3
|
|
|
|
* p e.next #raises StopIteration
|
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Note that enumeration sequence by +next+ does not affect other non-external
|
|
|
|
* enumeration methods, unless the underlying iteration methods itself has
|
|
|
|
* side-effect, e.g. IO#each_line.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2009-08-18 08:02:53 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2009-08-19 12:36:00 -04:00
|
|
|
enumerator_next(VALUE obj)
|
|
|
|
{
|
|
|
|
VALUE vs = enumerator_next_values(obj);
|
2009-08-21 11:51:35 -04:00
|
|
|
return ary2sv(vs, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
enumerator_peek_values(VALUE obj)
|
|
|
|
{
|
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
|
|
|
|
|
|
|
if (e->lookahead == Qundef) {
|
|
|
|
e->lookahead = get_next_values(obj, e);
|
|
|
|
}
|
|
|
|
return e->lookahead;
|
2009-08-19 12:36:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.peek_values -> array
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Returns the next object as an array, similar to Enumerator#next_values, but
|
|
|
|
* doesn't move the internal position forward. If the position is already at
|
|
|
|
* the end, StopIteration is raised.
|
|
|
|
*
|
|
|
|
* === Example
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
|
|
|
* o = Object.new
|
|
|
|
* def o.each
|
2010-05-29 14:51:39 -04:00
|
|
|
* yield
|
2009-08-19 12:36:00 -04:00
|
|
|
* yield 1
|
|
|
|
* yield 1, 2
|
|
|
|
* end
|
|
|
|
* e = o.to_enum
|
|
|
|
* p e.peek_values #=> []
|
2010-05-29 14:51:39 -04:00
|
|
|
* e.next
|
2009-08-19 12:36:00 -04:00
|
|
|
* p e.peek_values #=> [1]
|
2009-08-21 23:19:53 -04:00
|
|
|
* p e.peek_values #=> [1]
|
2010-05-29 14:51:39 -04:00
|
|
|
* e.next
|
2009-08-19 12:36:00 -04:00
|
|
|
* p e.peek_values #=> [1, 2]
|
2010-05-29 14:51:39 -04:00
|
|
|
* e.next
|
2009-08-19 12:36:00 -04:00
|
|
|
* p e.peek_values # raises StopIteration
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2009-08-21 11:51:35 -04:00
|
|
|
enumerator_peek_values_m(VALUE obj)
|
2009-08-18 08:02:53 -04:00
|
|
|
{
|
2009-08-21 11:51:35 -04:00
|
|
|
return rb_ary_dup(enumerator_peek_values(obj));
|
2009-08-18 08:02:53 -04:00
|
|
|
}
|
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.peek -> object
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Returns the next object in the enumerator, but doesn't move the internal
|
|
|
|
* position forward. If the position is already at the end, StopIteration
|
2009-08-19 12:36:00 -04:00
|
|
|
* is raised.
|
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* === Example
|
|
|
|
*
|
2009-08-21 23:19:53 -04:00
|
|
|
* a = [1,2,3]
|
|
|
|
* e = a.to_enum
|
|
|
|
* p e.next #=> 1
|
|
|
|
* p e.peek #=> 2
|
|
|
|
* p e.peek #=> 2
|
|
|
|
* p e.peek #=> 2
|
|
|
|
* p e.next #=> 2
|
|
|
|
* p e.next #=> 3
|
|
|
|
* p e.next #raises StopIteration
|
|
|
|
*
|
2009-08-19 12:36:00 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
enumerator_peek(VALUE obj)
|
|
|
|
{
|
|
|
|
VALUE vs = enumerator_peek_values(obj);
|
2009-08-21 11:51:35 -04:00
|
|
|
return ary2sv(vs, 1);
|
2009-08-19 12:36:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.feed obj -> nil
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-06-01 17:16:05 -04:00
|
|
|
* Sets the value to be returned by the next yield inside +e+.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-31 19:19:50 -04:00
|
|
|
* If the value is not set, the yield returns nil.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-06-01 17:16:05 -04:00
|
|
|
* This value is cleared after being yielded.
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
2011-05-31 19:19:50 -04:00
|
|
|
* o = Object.new
|
|
|
|
* def o.each
|
|
|
|
* x = yield # (2) blocks
|
|
|
|
* p x # (5) => "foo"
|
|
|
|
* x = yield # (6) blocks
|
|
|
|
* p x # (8) => nil
|
|
|
|
* x = yield # (9) blocks
|
|
|
|
* p x # not reached w/o another e.next
|
2009-08-19 12:36:00 -04:00
|
|
|
* end
|
|
|
|
*
|
2011-05-31 19:19:50 -04:00
|
|
|
* e = o.to_enum
|
|
|
|
* e.next # (1)
|
|
|
|
* e.feed "foo" # (3)
|
|
|
|
* e.next # (4)
|
|
|
|
* e.next # (7)
|
|
|
|
* # (10)
|
2009-08-19 12:36:00 -04:00
|
|
|
*/
|
2011-05-31 19:19:50 -04:00
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
static VALUE
|
|
|
|
enumerator_feed(VALUE obj, VALUE v)
|
|
|
|
{
|
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
|
|
|
|
|
|
|
if (e->feedvalue != Qundef) {
|
|
|
|
rb_raise(rb_eTypeError, "feed value already set");
|
|
|
|
}
|
|
|
|
e->feedvalue = v;
|
|
|
|
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2007-08-06 12:41:17 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.rewind -> e
|
2007-08-06 12:41:17 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Rewinds the enumeration sequence by one step.
|
2008-12-09 22:58:56 -05:00
|
|
|
*
|
|
|
|
* If the enclosed object responds to a "rewind" method, it is called.
|
2007-08-06 12:41:17 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
enumerator_rewind(VALUE obj)
|
|
|
|
{
|
|
|
|
struct enumerator *e = enumerator_ptr(obj);
|
|
|
|
|
2009-10-29 00:55:10 -04:00
|
|
|
rb_check_funcall(e->obj, id_rewind, 0, 0);
|
2008-12-09 22:58:56 -05:00
|
|
|
|
2007-08-06 12:41:17 -04:00
|
|
|
e->fib = 0;
|
2007-08-24 06:48:43 -04:00
|
|
|
e->dst = Qnil;
|
2009-08-18 08:02:53 -04:00
|
|
|
e->lookahead = Qundef;
|
2009-08-19 12:36:00 -04:00
|
|
|
e->feedvalue = Qundef;
|
|
|
|
e->stop_exc = Qfalse;
|
2007-08-06 12:41:17 -04:00
|
|
|
return obj;
|
2006-10-02 13:39:57 -04:00
|
|
|
}
|
|
|
|
|
2008-12-03 21:44:38 -05:00
|
|
|
static VALUE
|
|
|
|
inspect_enumerator(VALUE obj, VALUE dummy, int recur)
|
|
|
|
{
|
2010-04-12 09:49:44 -04:00
|
|
|
struct enumerator *e;
|
|
|
|
const char *cname;
|
2008-12-03 21:44:38 -05:00
|
|
|
VALUE eobj, str;
|
|
|
|
int tainted, untrusted;
|
|
|
|
|
2010-04-12 09:49:44 -04:00
|
|
|
TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, e);
|
|
|
|
|
|
|
|
cname = rb_obj_classname(obj);
|
|
|
|
|
|
|
|
if (!e || e->obj == Qundef) {
|
|
|
|
return rb_sprintf("#<%s: uninitialized>", cname);
|
|
|
|
}
|
|
|
|
|
2008-12-03 21:44:38 -05:00
|
|
|
if (recur) {
|
|
|
|
str = rb_sprintf("#<%s: ...>", cname);
|
|
|
|
OBJ_TAINT(str);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
eobj = e->obj;
|
|
|
|
|
|
|
|
tainted = OBJ_TAINTED(eobj);
|
|
|
|
untrusted = OBJ_UNTRUSTED(eobj);
|
|
|
|
|
|
|
|
/* (1..100).each_cons(2) => "#<Enumerator: 1..100:each_cons(2)>" */
|
|
|
|
str = rb_sprintf("#<%s: ", cname);
|
|
|
|
rb_str_concat(str, rb_inspect(eobj));
|
|
|
|
rb_str_buf_cat2(str, ":");
|
|
|
|
rb_str_buf_cat2(str, rb_id2name(e->meth));
|
|
|
|
|
|
|
|
if (e->args) {
|
2009-05-20 05:34:34 -04:00
|
|
|
long argc = RARRAY_LEN(e->args);
|
2008-12-03 21:44:38 -05:00
|
|
|
VALUE *argv = RARRAY_PTR(e->args);
|
|
|
|
|
|
|
|
rb_str_buf_cat2(str, "(");
|
|
|
|
|
|
|
|
while (argc--) {
|
|
|
|
VALUE arg = *argv++;
|
|
|
|
|
|
|
|
rb_str_concat(str, rb_inspect(arg));
|
|
|
|
rb_str_buf_cat2(str, argc > 0 ? ", " : ")");
|
|
|
|
|
2009-07-18 04:05:32 -04:00
|
|
|
if (OBJ_TAINTED(arg)) tainted = TRUE;
|
|
|
|
if (OBJ_UNTRUSTED(arg)) untrusted = TRUE;
|
2008-12-03 21:44:38 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_str_buf_cat2(str, ">");
|
|
|
|
|
|
|
|
if (tainted) OBJ_TAINT(str);
|
|
|
|
if (untrusted) OBJ_UNTRUST(str);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:07:33 -04:00
|
|
|
* e.inspect -> string
|
2008-12-03 21:44:38 -05:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Creates a printable version of <i>e</i>.
|
2008-12-03 21:44:38 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
enumerator_inspect(VALUE obj)
|
|
|
|
{
|
|
|
|
return rb_exec_recursive(inspect_enumerator, obj, 0);
|
|
|
|
}
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
/*
|
|
|
|
* Yielder
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
yielder_mark(void *p)
|
|
|
|
{
|
|
|
|
struct yielder *ptr = p;
|
|
|
|
rb_gc_mark(ptr->proc);
|
|
|
|
}
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
#define yielder_free RUBY_TYPED_DEFAULT_FREE
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
yielder_memsize(const void *p)
|
|
|
|
{
|
|
|
|
return p ? sizeof(struct yielder) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t yielder_data_type = {
|
|
|
|
"yielder",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
yielder_mark,
|
|
|
|
yielder_free,
|
|
|
|
yielder_memsize,
|
|
|
|
},
|
2009-09-08 22:46:00 -04:00
|
|
|
};
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
static struct yielder *
|
|
|
|
yielder_ptr(VALUE obj)
|
|
|
|
{
|
|
|
|
struct yielder *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct yielder, &yielder_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
if (!ptr || ptr->proc == Qundef) {
|
|
|
|
rb_raise(rb_eArgError, "uninitialized yielder");
|
|
|
|
}
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
yielder_allocate(VALUE klass)
|
|
|
|
{
|
|
|
|
struct yielder *ptr;
|
|
|
|
VALUE obj;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
obj = TypedData_Make_Struct(klass, struct yielder, &yielder_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
ptr->proc = Qundef;
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
yielder_init(VALUE obj, VALUE proc)
|
|
|
|
{
|
|
|
|
struct yielder *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct yielder, &yielder_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
|
|
|
|
if (!ptr) {
|
|
|
|
rb_raise(rb_eArgError, "unallocated yielder");
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr->proc = proc;
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
yielder_initialize(VALUE obj)
|
|
|
|
{
|
|
|
|
rb_need_block();
|
|
|
|
|
|
|
|
return yielder_init(obj, rb_block_proc());
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
yielder_yield(VALUE obj, VALUE args)
|
|
|
|
{
|
|
|
|
struct yielder *ptr = yielder_ptr(obj);
|
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
return rb_proc_call(ptr->proc, args);
|
2008-08-26 01:42:12 -04:00
|
|
|
}
|
|
|
|
|
2009-11-11 11:32:34 -05:00
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE yielder_yield_push(VALUE obj, VALUE args)
|
|
|
|
{
|
|
|
|
yielder_yield(obj, args);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
static VALUE
|
|
|
|
yielder_yield_i(VALUE obj, VALUE memo, int argc, VALUE *argv)
|
|
|
|
{
|
|
|
|
return rb_yield_values2(argc, argv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
yielder_new(void)
|
|
|
|
{
|
2009-07-13 12:07:43 -04:00
|
|
|
return yielder_init(yielder_allocate(rb_cYielder), rb_proc_new(yielder_yield_i, 0));
|
2008-08-26 01:42:12 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generator
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
generator_mark(void *p)
|
|
|
|
{
|
|
|
|
struct generator *ptr = p;
|
|
|
|
rb_gc_mark(ptr->proc);
|
|
|
|
}
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
#define generator_free RUBY_TYPED_DEFAULT_FREE
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
generator_memsize(const void *p)
|
|
|
|
{
|
|
|
|
return p ? sizeof(struct generator) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t generator_data_type = {
|
|
|
|
"generator",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
generator_mark,
|
|
|
|
generator_free,
|
|
|
|
generator_memsize,
|
|
|
|
},
|
2009-09-08 22:46:00 -04:00
|
|
|
};
|
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
static struct generator *
|
|
|
|
generator_ptr(VALUE obj)
|
|
|
|
{
|
|
|
|
struct generator *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
if (!ptr || ptr->proc == Qundef) {
|
|
|
|
rb_raise(rb_eArgError, "uninitialized generator");
|
|
|
|
}
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
generator_allocate(VALUE klass)
|
|
|
|
{
|
|
|
|
struct generator *ptr;
|
|
|
|
VALUE obj;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
obj = TypedData_Make_Struct(klass, struct generator, &generator_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
ptr->proc = Qundef;
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
generator_init(VALUE obj, VALUE proc)
|
|
|
|
{
|
|
|
|
struct generator *ptr;
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr);
|
2008-08-26 01:42:12 -04:00
|
|
|
|
|
|
|
if (!ptr) {
|
|
|
|
rb_raise(rb_eArgError, "unallocated generator");
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr->proc = proc;
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
generator_initialize(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
|
|
|
VALUE proc;
|
|
|
|
|
|
|
|
if (argc == 0) {
|
|
|
|
rb_need_block();
|
|
|
|
|
|
|
|
proc = rb_block_proc();
|
|
|
|
} else {
|
|
|
|
rb_scan_args(argc, argv, "1", &proc);
|
|
|
|
|
|
|
|
if (!rb_obj_is_proc(proc))
|
|
|
|
rb_raise(rb_eTypeError,
|
|
|
|
"wrong argument type %s (expected Proc)",
|
|
|
|
rb_obj_classname(proc));
|
|
|
|
|
|
|
|
if (rb_block_given_p()) {
|
|
|
|
rb_warn("given block not used");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return generator_init(obj, proc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
generator_init_copy(VALUE obj, VALUE orig)
|
|
|
|
{
|
|
|
|
struct generator *ptr0, *ptr1;
|
|
|
|
|
|
|
|
ptr0 = generator_ptr(orig);
|
|
|
|
|
2009-09-08 22:46:00 -04:00
|
|
|
TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr1);
|
2008-08-26 01:42:12 -04:00
|
|
|
|
|
|
|
if (!ptr1) {
|
|
|
|
rb_raise(rb_eArgError, "unallocated generator");
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr1->proc = ptr0->proc;
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
generator_each(VALUE obj)
|
|
|
|
{
|
|
|
|
struct generator *ptr = generator_ptr(obj);
|
|
|
|
VALUE yielder;
|
|
|
|
|
|
|
|
yielder = yielder_new();
|
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
return rb_proc_call(ptr->proc, rb_ary_new3(1, yielder));
|
|
|
|
}
|
2008-08-26 01:42:12 -04:00
|
|
|
|
2009-08-19 12:36:00 -04:00
|
|
|
/*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Document-class: StopIteration
|
2010-05-08 00:50:09 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Raised to stop the iteration, in particular by Enumerator#next. It is
|
|
|
|
* rescued by Kernel#loop.
|
2010-05-08 00:50:09 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* loop do
|
|
|
|
* puts "Hello"
|
|
|
|
* raise StopIteration
|
|
|
|
* puts "World"
|
|
|
|
* end
|
|
|
|
* puts "Done!"
|
2010-05-08 00:50:09 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* <em>produces:</em>
|
2010-05-08 00:50:09 -04:00
|
|
|
*
|
2011-05-22 19:33:21 -04:00
|
|
|
* Hello
|
|
|
|
* Done!
|
2009-08-19 12:36:00 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-05-22 19:33:21 -04:00
|
|
|
* result -> value
|
2009-08-19 12:36:00 -04:00
|
|
|
*
|
|
|
|
* Returns the return value of the iterator.
|
|
|
|
*
|
|
|
|
* o = Object.new
|
|
|
|
* def o.each
|
|
|
|
* yield 1
|
|
|
|
* yield 2
|
|
|
|
* yield 3
|
|
|
|
* 100
|
|
|
|
* end
|
2011-05-22 19:33:21 -04:00
|
|
|
*
|
2009-08-19 12:36:00 -04:00
|
|
|
* e = o.to_enum
|
2011-05-22 19:33:21 -04:00
|
|
|
*
|
|
|
|
* puts e.next #=> 1
|
|
|
|
* puts e.next #=> 2
|
|
|
|
* puts e.next #=> 3
|
|
|
|
*
|
2009-08-19 12:36:00 -04:00
|
|
|
* begin
|
|
|
|
* e.next
|
2011-05-22 19:33:21 -04:00
|
|
|
* rescue StopIteration => ex
|
|
|
|
* puts ex.result #=> 100
|
2009-08-19 12:36:00 -04:00
|
|
|
* end
|
2010-05-29 14:51:39 -04:00
|
|
|
*
|
2009-08-19 12:36:00 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
stop_result(VALUE self)
|
|
|
|
{
|
|
|
|
return rb_attr_get(self, rb_intern("result"));
|
2008-08-26 01:42:12 -04:00
|
|
|
}
|
|
|
|
|
2003-10-13 13:09:23 -04:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
Init_Enumerator(void)
|
2003-10-13 13:09:23 -04:00
|
|
|
{
|
2005-07-16 10:43:34 -04:00
|
|
|
rb_define_method(rb_mKernel, "to_enum", obj_to_enum, -1);
|
|
|
|
rb_define_method(rb_mKernel, "enum_for", obj_to_enum, -1);
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2008-08-13 02:25:53 -04:00
|
|
|
rb_cEnumerator = rb_define_class("Enumerator", rb_cObject);
|
2003-10-13 13:09:23 -04:00
|
|
|
rb_include_module(rb_cEnumerator, rb_mEnumerable);
|
|
|
|
|
2005-07-11 10:50:42 -04:00
|
|
|
rb_define_alloc_func(rb_cEnumerator, enumerator_allocate);
|
2003-10-13 13:09:23 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "initialize", enumerator_initialize, -1);
|
2007-01-25 17:52:38 -05:00
|
|
|
rb_define_method(rb_cEnumerator, "initialize_copy", enumerator_init_copy, 1);
|
2003-10-13 13:09:23 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "each", enumerator_each, 0);
|
2009-02-08 09:42:01 -05:00
|
|
|
rb_define_method(rb_cEnumerator, "each_with_index", enumerator_each_with_index, 0);
|
2008-08-26 01:45:18 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "each_with_object", enumerator_with_object, 1);
|
2009-02-08 09:42:01 -05:00
|
|
|
rb_define_method(rb_cEnumerator, "with_index", enumerator_with_index, -1);
|
2008-06-15 20:49:25 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "with_object", enumerator_with_object, 1);
|
2009-08-19 12:36:00 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "next_values", enumerator_next_values, 0);
|
2009-08-21 11:51:35 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "peek_values", enumerator_peek_values_m, 0);
|
2007-08-06 12:41:17 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "next", enumerator_next, 0);
|
2009-08-18 08:02:53 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "peek", enumerator_peek, 0);
|
2009-08-19 12:36:00 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "feed", enumerator_feed, 1);
|
2007-08-06 12:41:17 -04:00
|
|
|
rb_define_method(rb_cEnumerator, "rewind", enumerator_rewind, 0);
|
2008-12-03 21:44:38 -05:00
|
|
|
rb_define_method(rb_cEnumerator, "inspect", enumerator_inspect, 0);
|
2003-10-13 13:09:23 -04:00
|
|
|
|
2008-08-26 01:42:12 -04:00
|
|
|
rb_eStopIteration = rb_define_class("StopIteration", rb_eIndexError);
|
2009-08-19 12:36:00 -04:00
|
|
|
rb_define_method(rb_eStopIteration, "result", stop_result, 0);
|
2008-08-26 01:42:12 -04:00
|
|
|
|
|
|
|
/* Generator */
|
|
|
|
rb_cGenerator = rb_define_class_under(rb_cEnumerator, "Generator", rb_cObject);
|
|
|
|
rb_include_module(rb_cGenerator, rb_mEnumerable);
|
|
|
|
rb_define_alloc_func(rb_cGenerator, generator_allocate);
|
|
|
|
rb_define_method(rb_cGenerator, "initialize", generator_initialize, -1);
|
|
|
|
rb_define_method(rb_cGenerator, "initialize_copy", generator_init_copy, 1);
|
|
|
|
rb_define_method(rb_cGenerator, "each", generator_each, 0);
|
|
|
|
|
|
|
|
/* Yielder */
|
|
|
|
rb_cYielder = rb_define_class_under(rb_cEnumerator, "Yielder", rb_cObject);
|
|
|
|
rb_define_alloc_func(rb_cYielder, yielder_allocate);
|
|
|
|
rb_define_method(rb_cYielder, "initialize", yielder_initialize, 0);
|
|
|
|
rb_define_method(rb_cYielder, "yield", yielder_yield, -2);
|
2009-11-11 11:32:34 -05:00
|
|
|
rb_define_method(rb_cYielder, "<<", yielder_yield_push, -2);
|
2007-08-08 03:07:03 -04:00
|
|
|
|
2008-12-09 22:58:56 -05:00
|
|
|
id_rewind = rb_intern("rewind");
|
2009-02-02 06:50:49 -05:00
|
|
|
id_each = rb_intern("each");
|
|
|
|
sym_each = ID2SYM(id_each);
|
2005-07-14 11:15:22 -04:00
|
|
|
|
2005-08-04 11:09:03 -04:00
|
|
|
rb_provide("enumerator.so"); /* for backward compatibility */
|
2003-10-13 13:09:23 -04:00
|
|
|
}
|