Fresh start

1 files changed, 2092 insertions, 0 deletions

diff --git a/jni/ruby/enumerator.c b/jni/ruby/enumerator.c
new file mode 100644
index 0000000..fff699e
--- /dev/null
+++ b/jni/ruby/enumerator.c
@@ -0,0 +1,2092 @@
+/************************************************
+
+  enumerator.c - provides Enumerator class
+
+  $Author: nobu $
+
+  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: enumerator.c 48662 2014-12-01 06:38:04Z nobu $
+
+************************************************/
+
+#include "internal.h"
+#include "node.h"
+
+/*
+ * Document-class: Enumerator
+ *
+ * A class which allows both internal and external iteration.
+ *
+ * An Enumerator can be created by the following methods.
+ * - Kernel#to_enum
+ * - Kernel#enum_for
+ * - Enumerator.new
+ *
+ * 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.
+ *
+ *   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:
+ *
+ *   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.
+ *
+ *   e = [1,2,3].each   # returns an enumerator object.
+ *   puts e.next   # => 1
+ *   puts e.next   # => 2
+ *   puts e.next   # => 3
+ *   puts e.next   # raises StopIteration
+ *
+ * You can use this to implement an internal iterator as follows:
+ *
+ *   def ext_each(e)
+ *     while true
+ *       begin
+ *         vs = e.next_values
+ *       rescue StopIteration
+ *         return $!.result
+ *       end
+ *       y = yield(*vs)
+ *       e.feed y
+ *     end
+ *   end
+ *
+ *   o = Object.new
+ *
+ *   def o.each
+ *     puts yield
+ *     puts yield(1)
+ *     puts yield(1, 2)
+ *     3
+ *   end
+ *
+ *   # use o.each as an internal iterator directly.
+ *   puts o.each {|*x| puts x; [:b, *x] }
+ *   # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
+ *
+ *   # convert o.each to an external iterator for
+ *   # implementing an internal iterator.
+ *   puts ext_each(o.to_enum) {|*x| puts x; [:b, *x] }
+ *   # => [], [:b], [1], [:b, 1], [1, 2], [:b, 1, 2], 3
+ *
+ */
+VALUE rb_cEnumerator;
+VALUE rb_cLazy;
+static ID id_rewind, id_each, id_new, id_initialize, id_yield, id_call, id_size, id_to_enum;
+static ID id_eqq, id_next, id_result, id_lazy, id_receiver, id_arguments, id_memo, id_method, id_force;
+static VALUE sym_each, sym_cycle;
+
+VALUE rb_eStopIteration;
+
+struct enumerator {
+    VALUE obj;
+    ID    meth;
+    VALUE args;
+    VALUE fib;
+    VALUE dst;
+    VALUE lookahead;
+    VALUE feedvalue;
+    VALUE stop_exc;
+    VALUE size;
+    rb_enumerator_size_func *size_fn;
+};
+
+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
+ */
+static void
+enumerator_mark(void *p)
+{
+    struct enumerator *ptr = p;
+    rb_gc_mark(ptr->obj);
+    rb_gc_mark(ptr->args);
+    rb_gc_mark(ptr->fib);
+    rb_gc_mark(ptr->dst);
+    rb_gc_mark(ptr->lookahead);
+    rb_gc_mark(ptr->feedvalue);
+    rb_gc_mark(ptr->stop_exc);
+    rb_gc_mark(ptr->size);
+}
+
+#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",
+    {
+	enumerator_mark,
+	enumerator_free,
+	enumerator_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static struct enumerator *
+enumerator_ptr(VALUE obj)
+{
+    struct enumerator *ptr;
+
+    TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, ptr);
+    if (!ptr || ptr->obj == Qundef) {
+	rb_raise(rb_eArgError, "uninitialized enumerator");
+    }
+    return ptr;
+}
+
+/*
+ * call-seq:
+ *   obj.to_enum(method = :each, *args)                 -> enum
+ *   obj.enum_for(method = :each, *args)                -> enum
+ *   obj.to_enum(method = :each, *args) {|*args| block} -> enum
+ *   obj.enum_for(method = :each, *args){|*args| block} -> enum
+ *
+ * Creates a new Enumerator which will enumerate by calling +method+ on
+ * +obj+, passing +args+ if any.
+ *
+ * If a block is given, it will be used to calculate the size of
+ * the enumerator without the need to iterate it (see Enumerator#size).
+ *
+ * === Examples
+ *
+ *   str = "xyz"
+ *
+ *   enum = str.enum_for(:each_byte)
+ *   enum.each { |b| puts b }
+ *   # => 120
+ *   # => 121
+ *   # => 122
+ *
+ *   # protect an array from being modified by some_method
+ *   a = [1, 2, 3]
+ *   some_method(a.to_enum)
+ *
+ * It is typical to call to_enum when defining methods for
+ * a generic Enumerable, in case no block is passed.
+ *
+ * Here is such an example, with parameter passing and a sizing block:
+ *
+ *   module Enumerable
+ *     # a generic method to repeat the values of any enumerable
+ *     def repeat(n)
+ *       raise ArgumentError, "#{n} is negative!" if n < 0
+ *       unless block_given?
+ *         return to_enum(__method__, n) do # __method__ is :repeat here
+ *           sz = size     # Call size and multiply by n...
+ *           sz * n if sz  # but return nil if size itself is nil
+ *         end
+ *       end
+ *       each do |*val|
+ *         n.times { yield *val }
+ *       end
+ *     end
+ *   end
+ *
+ *   %i[hello world].repeat(2) { |w| puts w }
+ *     # => Prints 'hello', 'hello', 'world', 'world'
+ *   enum = (1..14).repeat(3)
+ *     # => returns an Enumerator when called without a block
+ *   enum.first(4) # => [1, 1, 1, 2]
+ *   enum.size # => 42
+ */
+static VALUE
+obj_to_enum(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE enumerator, meth = sym_each;
+
+    if (argc > 0) {
+	--argc;
+	meth = *argv++;
+    }
+    enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
+    if (rb_block_given_p()) {
+	enumerator_ptr(enumerator)->size = rb_block_proc();
+    }
+    return enumerator;
+}
+
+static VALUE
+enumerator_allocate(VALUE klass)
+{
+    struct enumerator *ptr;
+    VALUE enum_obj;
+
+    enum_obj = TypedData_Make_Struct(klass, struct enumerator, &enumerator_data_type, ptr);
+    ptr->obj = Qundef;
+
+    return enum_obj;
+}
+
+static VALUE
+enumerator_init(VALUE enum_obj, VALUE obj, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *size_fn, VALUE size)
+{
+    struct enumerator *ptr;
+
+    rb_check_frozen(enum_obj);
+    TypedData_Get_Struct(enum_obj, struct enumerator, &enumerator_data_type, ptr);
+
+    if (!ptr) {
+	rb_raise(rb_eArgError, "unallocated enumerator");
+    }
+
+    ptr->obj  = obj;
+    ptr->meth = rb_to_id(meth);
+    if (argc) ptr->args = rb_ary_new4(argc, argv);
+    ptr->fib = 0;
+    ptr->dst = Qnil;
+    ptr->lookahead = Qundef;
+    ptr->feedvalue = Qundef;
+    ptr->stop_exc = Qfalse;
+    ptr->size = size;
+    ptr->size_fn = size_fn;
+
+    return enum_obj;
+}
+
+/*
+ * call-seq:
+ *   Enumerator.new(size = nil) { |yielder| ... }
+ *   Enumerator.new(obj, method = :each, *args)
+ *
+ * Creates a new Enumerator object, which can be used as an
+ * Enumerable.
+ *
+ * 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 +<<+):
+ *
+ *   fib = Enumerator.new do |y|
+ *     a = b = 1
+ *     loop do
+ *       y << a
+ *       a, b = b, a + b
+ *     end
+ *   end
+ *
+ *   p fib.take(10) # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+ *
+ * The optional parameter can be used to specify how to calculate the size
+ * in a lazy fashion (see Enumerator#size). It can either be a value or
+ * a callable object.
+ *
+ * In the second, deprecated, form, a generated Enumerator iterates over the
+ * given object using the given method with the given arguments passed.
+ *
+ * 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
+ *
+ */
+static VALUE
+enumerator_initialize(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE recv, meth = sym_each;
+    VALUE size = Qnil;
+
+    if (rb_block_given_p()) {
+	rb_check_arity(argc, 0, 1);
+	recv = generator_init(generator_allocate(rb_cGenerator), rb_block_proc());
+	if (argc) {
+            if (NIL_P(argv[0]) || rb_respond_to(argv[0], id_call) ||
+                (RB_TYPE_P(argv[0], T_FLOAT) && RFLOAT_VALUE(argv[0]) == INFINITY)) {
+                size = argv[0];
+            }
+            else {
+                size = rb_to_int(argv[0]);
+            }
+            argc = 0;
+        }
+    }
+    else {
+	rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+	rb_warn("Enumerator.new without a block is deprecated; use Object#to_enum");
+	recv = *argv++;
+	if (--argc) {
+	    meth = *argv++;
+	    --argc;
+	}
+    }
+
+    return enumerator_init(obj, recv, meth, argc, argv, 0, size);
+}
+
+/* :nodoc: */
+static VALUE
+enumerator_init_copy(VALUE obj, VALUE orig)
+{
+    struct enumerator *ptr0, *ptr1;
+
+    if (!OBJ_INIT_COPY(obj, orig)) return obj;
+    ptr0 = enumerator_ptr(orig);
+    if (ptr0->fib) {
+	/* Fibers cannot be copied */
+	rb_raise(rb_eTypeError, "can't copy execution context");
+    }
+
+    TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, ptr1);
+
+    if (!ptr1) {
+	rb_raise(rb_eArgError, "unallocated enumerator");
+    }
+
+    ptr1->obj  = ptr0->obj;
+    ptr1->meth = ptr0->meth;
+    ptr1->args = ptr0->args;
+    ptr1->fib  = 0;
+    ptr1->lookahead  = Qundef;
+    ptr1->feedvalue  = Qundef;
+    ptr1->size  = ptr0->size;
+    ptr1->size_fn  = ptr0->size_fn;
+
+    return obj;
+}
+
+/*
+ * For backwards compatibility; use rb_enumeratorize_with_size
+ */
+VALUE
+rb_enumeratorize(VALUE obj, VALUE meth, int argc, const VALUE *argv)
+{
+    return rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
+}
+
+static VALUE
+lazy_to_enum_i(VALUE self, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *size_fn);
+
+VALUE
+rb_enumeratorize_with_size(VALUE obj, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *size_fn)
+{
+    /* Similar effect as calling obj.to_enum, i.e. dispatching to either
+       Kernel#to_enum vs Lazy#to_enum */
+    if (RTEST(rb_obj_is_kind_of(obj, rb_cLazy)))
+	return lazy_to_enum_i(obj, meth, argc, argv, size_fn);
+    else
+	return enumerator_init(enumerator_allocate(rb_cEnumerator),
+			       obj, meth, argc, argv, size_fn, Qnil);
+}
+
+static VALUE
+enumerator_block_call(VALUE obj, rb_block_call_func *func, VALUE arg)
+{
+    int argc = 0;
+    const VALUE *argv = 0;
+    const struct enumerator *e = enumerator_ptr(obj);
+    ID meth = e->meth;
+
+    if (e->args) {
+	argc = RARRAY_LENINT(e->args);
+	argv = RARRAY_CONST_PTR(e->args);
+    }
+    return rb_block_call(e->obj, meth, argc, argv, func, arg);
+}
+
+/*
+ * call-seq:
+ *   enum.each { |elm| block }                    -> obj
+ *   enum.each                                    -> enum
+ *   enum.each(*appending_args) { |elm| block }   -> obj
+ *   enum.each(*appending_args)                   -> an_enumerator
+ *
+ * Iterates over the block according to how this Enumerator was constructed.
+ * If no block and no arguments are given, returns self.
+ *
+ * === Examples
+ *
+ *   "Hello, world!".scan(/\w+/)                     #=> ["Hello", "world"]
+ *   "Hello, world!".to_enum(:scan, /\w+/).to_a      #=> ["Hello", "world"]
+ *   "Hello, world!".to_enum(:scan).each(/\w+/).to_a #=> ["Hello", "world"]
+ *
+ *   obj = Object.new
+ *
+ *   def obj.each_arg(a, b=:b, *rest)
+ *     yield a
+ *     yield b
+ *     yield rest
+ *     :method_returned
+ *   end
+ *
+ *   enum = obj.to_enum :each_arg, :a, :x
+ *
+ *   enum.each.to_a                  #=> [:a, :x, []]
+ *   enum.each.equal?(enum)          #=> true
+ *   enum.each { |elm| elm }         #=> :method_returned
+ *
+ *   enum.each(:y, :z).to_a          #=> [:a, :x, [:y, :z]]
+ *   enum.each(:y, :z).equal?(enum)  #=> false
+ *   enum.each(:y, :z) { |elm| elm } #=> :method_returned
+ *
+ */
+static VALUE
+enumerator_each(int argc, VALUE *argv, VALUE obj)
+{
+    if (argc > 0) {
+	struct enumerator *e = enumerator_ptr(obj = rb_obj_dup(obj));
+	VALUE args = e->args;
+	if (args) {
+#if SIZEOF_INT < SIZEOF_LONG
+	    /* check int range overflow */
+	    rb_long2int(RARRAY_LEN(args) + argc);
+#endif
+	    args = rb_ary_dup(args);
+	    rb_ary_cat(args, argv, argc);
+	}
+	else {
+	    args = rb_ary_new4(argc, argv);
+	}
+	e->args = args;
+    }
+    if (!rb_block_given_p()) return obj;
+    return enumerator_block_call(obj, 0, obj);
+}
+
+static VALUE
+enumerator_with_index_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    NODE *memo = (NODE *)m;
+    VALUE idx = memo->u1.value;
+    memo->u1.value = rb_int_succ(idx);
+
+    if (argc <= 1)
+	return rb_yield_values(2, val, idx);
+
+    return rb_yield_values(2, rb_ary_new4(argc, argv), idx);
+}
+
+static VALUE
+enumerator_size(VALUE obj);
+
+static VALUE
+enumerator_enum_size(VALUE obj, VALUE args, VALUE eobj)
+{
+    return enumerator_size(obj);
+}
+
+/*
+ * 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+
+ *
+ * +offset+:: the starting index to use
+ *
+ */
+static VALUE
+enumerator_with_index(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE memo;
+
+    rb_scan_args(argc, argv, "01", &memo);
+    RETURN_SIZED_ENUMERATOR(obj, argc, argv, enumerator_enum_size);
+    if (NIL_P(memo))
+	memo = INT2FIX(0);
+    else
+	memo = rb_to_int(memo);
+    return enumerator_block_call(obj, enumerator_with_index_i, (VALUE)NEW_MEMO(memo, 0, 0));
+}
+
+/*
+ * call-seq:
+ *   e.each_with_index {|(*args), idx| ... }
+ *   e.each_with_index
+ *
+ * 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.
+ *
+ */
+static VALUE
+enumerator_each_with_index(VALUE obj)
+{
+    return enumerator_with_index(0, NULL, obj);
+}
+
+static VALUE
+enumerator_with_object_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, memo))
+{
+    if (argc <= 1)
+	return rb_yield_values(2, val, memo);
+
+    return rb_yield_values(2, rb_ary_new4(argc, argv), memo);
+}
+
+/*
+ * call-seq:
+ *   e.each_with_object(obj) {|(*args), obj| ... }
+ *   e.each_with_object(obj)
+ *   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+
+ *
+ * If no block is given, returns a new Enumerator.
+ *
+ * === Example
+ *
+ *   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
+ */
+static VALUE
+enumerator_with_object(VALUE obj, VALUE memo)
+{
+    RETURN_SIZED_ENUMERATOR(obj, 1, &memo, enumerator_enum_size);
+    enumerator_block_call(obj, enumerator_with_object_i, memo);
+
+    return memo;
+}
+
+static VALUE
+next_ii(RB_BLOCK_CALL_FUNC_ARGLIST(i, obj))
+{
+    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;
+}
+
+static VALUE
+next_i(VALUE curr, VALUE obj)
+{
+    struct enumerator *e = enumerator_ptr(obj);
+    VALUE nil = Qnil;
+    VALUE result;
+
+    result = rb_block_call(obj, id_each, 0, 0, next_ii, obj);
+    e->stop_exc = rb_exc_new2(rb_eStopIteration, "iteration reached an end");
+    rb_ivar_set(e->stop_exc, id_result, result);
+    return rb_fiber_yield(1, &nil);
+}
+
+static void
+next_init(VALUE obj, struct enumerator *e)
+{
+    VALUE curr = rb_fiber_current();
+    e->dst = curr;
+    e->fib = rb_fiber_new(next_i, obj);
+    e->lookahead = Qundef;
+}
+
+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;
+}
+
+/*
+ * call-seq:
+ *   e.next_values   -> array
+ *
+ * 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>.
+ *
+ * === Example
+ *
+ *   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
+ *
+ *   ## 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]
+ *
+ * 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.
+ *
+ */
+
+static VALUE
+enumerator_next_values(VALUE obj)
+{
+    struct enumerator *e = enumerator_ptr(obj);
+    VALUE vs;
+
+    if (e->lookahead != Qundef) {
+        vs = e->lookahead;
+        e->lookahead = Qundef;
+        return vs;
+    }
+
+    return get_next_values(obj, e);
+}
+
+static VALUE
+ary2sv(VALUE args, int dup)
+{
+    if (!RB_TYPE_P(args, T_ARRAY))
+        return args;
+
+    switch (RARRAY_LEN(args)) {
+      case 0:
+        return Qnil;
+
+      case 1:
+        return RARRAY_AREF(args, 0);
+
+      default:
+        if (dup)
+            return rb_ary_dup(args);
+        return args;
+    }
+}
+
+/*
+ * call-seq:
+ *   e.next   -> object
+ *
+ * Returns the next object in the enumerator, and move the internal position
+ * forward.  When the position reached at the end, StopIteration is raised.
+ *
+ * === Example
+ *
+ *   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
+ *
+ * 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.
+ *
+ */
+
+static VALUE
+enumerator_next(VALUE obj)
+{
+    VALUE vs = enumerator_next_values(obj);
+    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;
+}
+
+/*
+ * call-seq:
+ *   e.peek_values   -> array
+ *
+ * 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
+ *
+ *   o = Object.new
+ *   def o.each
+ *     yield
+ *     yield 1
+ *     yield 1, 2
+ *   end
+ *   e = o.to_enum
+ *   p e.peek_values    #=> []
+ *   e.next
+ *   p e.peek_values    #=> [1]
+ *   p e.peek_values    #=> [1]
+ *   e.next
+ *   p e.peek_values    #=> [1, 2]
+ *   e.next
+ *   p e.peek_values    # raises StopIteration
+ *
+ */
+
+static VALUE
+enumerator_peek_values_m(VALUE obj)
+{
+    return rb_ary_dup(enumerator_peek_values(obj));
+}
+
+/*
+ * call-seq:
+ *   e.peek   -> object
+ *
+ * Returns the next object in the enumerator, but doesn't move the internal
+ * position forward.  If the position is already at the end, StopIteration
+ * is raised.
+ *
+ * === Example
+ *
+ *   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.peek   #raises StopIteration
+ *
+ */
+
+static VALUE
+enumerator_peek(VALUE obj)
+{
+    VALUE vs = enumerator_peek_values(obj);
+    return ary2sv(vs, 1);
+}
+
+/*
+ * call-seq:
+ *   e.feed obj   -> nil
+ *
+ * Sets the value to be returned by the next yield inside +e+.
+ *
+ * If the value is not set, the yield returns nil.
+ *
+ * This value is cleared after being yielded.
+ *
+ *   # Array#map passes the array's elements to "yield" and collects the
+ *   # results of "yield" as an array.
+ *   # Following example shows that "next" returns the passed elements and
+ *   # values passed to "feed" are collected as an array which can be
+ *   # obtained by StopIteration#result.
+ *   e = [1,2,3].map
+ *   p e.next           #=> 1
+ *   e.feed "a"
+ *   p e.next           #=> 2
+ *   e.feed "b"
+ *   p e.next           #=> 3
+ *   e.feed "c"
+ *   begin
+ *     e.next
+ *   rescue StopIteration
+ *     p $!.result      #=> ["a", "b", "c"]
+ *   end
+ *
+ *   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
+ *   end
+ *
+ *   e = o.to_enum
+ *   e.next              # (1)
+ *   e.feed "foo"        # (3)
+ *   e.next              # (4)
+ *   e.next              # (7)
+ *                       # (10)
+ */
+
+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;
+}
+
+/*
+ * call-seq:
+ *   e.rewind   -> e
+ *
+ * Rewinds the enumeration sequence to the beginning.
+ *
+ * If the enclosed object responds to a "rewind" method, it is called.
+ */
+
+static VALUE
+enumerator_rewind(VALUE obj)
+{
+    struct enumerator *e = enumerator_ptr(obj);
+
+    rb_check_funcall(e->obj, id_rewind, 0, 0);
+
+    e->fib = 0;
+    e->dst = Qnil;
+    e->lookahead = Qundef;
+    e->feedvalue = Qundef;
+    e->stop_exc = Qfalse;
+    return obj;
+}
+
+static VALUE append_method(VALUE obj, VALUE str, ID default_method, VALUE default_args);
+
+static VALUE
+inspect_enumerator(VALUE obj, VALUE dummy, int recur)
+{
+    struct enumerator *e;
+    VALUE eobj, str, cname;
+
+    TypedData_Get_Struct(obj, struct enumerator, &enumerator_data_type, e);
+
+    cname = rb_obj_class(obj);
+
+    if (!e || e->obj == Qundef) {
+	return rb_sprintf("#<%"PRIsVALUE": uninitialized>", rb_class_path(cname));
+    }
+
+    if (recur) {
+	str = rb_sprintf("#<%"PRIsVALUE": ...>", rb_class_path(cname));
+	OBJ_TAINT(str);
+	return str;
+    }
+
+    eobj = rb_attr_get(obj, id_receiver);
+    if (NIL_P(eobj)) {
+	eobj = e->obj;
+    }
+
+    /* (1..100).each_cons(2) => "#<Enumerator: 1..100:each_cons(2)>" */
+    str = rb_sprintf("#<%"PRIsVALUE": %+"PRIsVALUE, rb_class_path(cname), eobj);
+    append_method(obj, str, e->meth, e->args);
+
+    rb_str_buf_cat2(str, ">");
+
+    return str;
+}
+
+static VALUE
+append_method(VALUE obj, VALUE str, ID default_method, VALUE default_args)
+{
+    VALUE method, eargs;
+
+    method = rb_attr_get(obj, id_method);
+    if (method != Qfalse) {
+	if (!NIL_P(method)) {
+	    Check_Type(method, T_SYMBOL);
+	    method = rb_sym2str(method);
+	}
+	else {
+	    method = rb_id2str(default_method);
+	}
+	rb_str_buf_cat2(str, ":");
+	rb_str_buf_append(str, method);
+    }
+
+    eargs = rb_attr_get(obj, id_arguments);
+    if (NIL_P(eargs)) {
+	eargs = default_args;
+    }
+    if (eargs != Qfalse) {
+	long   argc = RARRAY_LEN(eargs);
+	const VALUE *argv = RARRAY_CONST_PTR(eargs); /* WB: no new reference */
+
+	if (argc > 0) {
+	    rb_str_buf_cat2(str, "(");
+
+	    while (argc--) {
+		VALUE arg = *argv++;
+
+		rb_str_append(str, rb_inspect(arg));
+		rb_str_buf_cat2(str, argc > 0 ? ", " : ")");
+		OBJ_INFECT(str, arg);
+	    }
+	}
+    }
+
+    return str;
+}
+
+/*
+ * call-seq:
+ *   e.inspect  -> string
+ *
+ * Creates a printable version of <i>e</i>.
+ */
+
+static VALUE
+enumerator_inspect(VALUE obj)
+{
+    return rb_exec_recursive(inspect_enumerator, obj, 0);
+}
+
+/*
+ * call-seq:
+ *   e.size          -> int, Float::INFINITY or nil
+ *
+ * Returns the size of the enumerator, or +nil+ if it can't be calculated lazily.
+ *
+ *   (1..100).to_a.permutation(4).size # => 94109400
+ *   loop.size # => Float::INFINITY
+ *   (1..100).drop_while.size # => nil
+ */
+
+static VALUE
+enumerator_size(VALUE obj)
+{
+    struct enumerator *e = enumerator_ptr(obj);
+    int argc = 0;
+    const VALUE *argv = NULL;
+    VALUE size;
+
+    if (e->size_fn) {
+	return (*e->size_fn)(e->obj, e->args, obj);
+    }
+    if (e->args) {
+	argc = (int)RARRAY_LEN(e->args);
+	argv = RARRAY_CONST_PTR(e->args);
+    }
+    size = rb_check_funcall(e->size, id_call, argc, argv);
+    if (size != Qundef) return size;
+    return e->size;
+}
+
+/*
+ * Yielder
+ */
+static void
+yielder_mark(void *p)
+{
+    struct yielder *ptr = p;
+    rb_gc_mark(ptr->proc);
+}
+
+#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",
+    {
+	yielder_mark,
+	yielder_free,
+	yielder_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static struct yielder *
+yielder_ptr(VALUE obj)
+{
+    struct yielder *ptr;
+
+    TypedData_Get_Struct(obj, struct yielder, &yielder_data_type, ptr);
+    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;
+
+    obj = TypedData_Make_Struct(klass, struct yielder, &yielder_data_type, ptr);
+    ptr->proc = Qundef;
+
+    return obj;
+}
+
+static VALUE
+yielder_init(VALUE obj, VALUE proc)
+{
+    struct yielder *ptr;
+
+    TypedData_Get_Struct(obj, struct yielder, &yielder_data_type, ptr);
+
+    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);
+
+    return rb_proc_call(ptr->proc, args);
+}
+
+/* :nodoc: */
+static VALUE
+yielder_yield_push(VALUE obj, VALUE args)
+{
+    yielder_yield(obj, args);
+    return obj;
+}
+
+static VALUE
+yielder_yield_i(RB_BLOCK_CALL_FUNC_ARGLIST(obj, memo))
+{
+    return rb_yield_values2(argc, argv);
+}
+
+static VALUE
+yielder_new(void)
+{
+    return yielder_init(yielder_allocate(rb_cYielder), rb_proc_new(yielder_yield_i, 0));
+}
+
+/*
+ * Generator
+ */
+static void
+generator_mark(void *p)
+{
+    struct generator *ptr = p;
+    rb_gc_mark(ptr->proc);
+}
+
+#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",
+    {
+	generator_mark,
+	generator_free,
+	generator_memsize,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static struct generator *
+generator_ptr(VALUE obj)
+{
+    struct generator *ptr;
+
+    TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr);
+    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;
+
+    obj = TypedData_Make_Struct(klass, struct generator, &generator_data_type, ptr);
+    ptr->proc = Qundef;
+
+    return obj;
+}
+
+static VALUE
+generator_init(VALUE obj, VALUE proc)
+{
+    struct generator *ptr;
+
+    rb_check_frozen(obj);
+    TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr);
+
+    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;
+
+    if (!OBJ_INIT_COPY(obj, orig)) return obj;
+
+    ptr0 = generator_ptr(orig);
+
+    TypedData_Get_Struct(obj, struct generator, &generator_data_type, ptr1);
+
+    if (!ptr1) {
+	rb_raise(rb_eArgError, "unallocated generator");
+    }
+
+    ptr1->proc = ptr0->proc;
+
+    return obj;
+}
+
+/* :nodoc: */
+static VALUE
+generator_each(int argc, VALUE *argv, VALUE obj)
+{
+    struct generator *ptr = generator_ptr(obj);
+    VALUE args = rb_ary_new2(argc + 1);
+
+    rb_ary_push(args, yielder_new());
+    if (argc > 0) {
+	rb_ary_cat(args, argv, argc);
+    }
+
+    return rb_proc_call(ptr->proc, args);
+}
+
+/* Lazy Enumerator methods */
+static VALUE
+enum_size(VALUE self)
+{
+    VALUE r = rb_check_funcall(self, id_size, 0, 0);
+    return (r == Qundef) ? Qnil : r;
+}
+
+static VALUE
+lazyenum_size(VALUE self, VALUE args, VALUE eobj)
+{
+    return enum_size(self);
+}
+
+static VALUE
+lazy_size(VALUE self)
+{
+    return enum_size(rb_ivar_get(self, id_receiver));
+}
+
+static VALUE
+lazy_receiver_size(VALUE generator, VALUE args, VALUE lazy)
+{
+    return lazy_size(lazy);
+}
+
+static VALUE
+lazy_init_iterator(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE result;
+    if (argc == 1) {
+	VALUE args[2];
+	args[0] = m;
+	args[1] = val;
+	result = rb_yield_values2(2, args);
+    }
+    else {
+	VALUE args;
+	int len = rb_long2int((long)argc + 1);
+
+	args = rb_ary_tmp_new(len);
+	rb_ary_push(args, m);
+	if (argc > 0) {
+	    rb_ary_cat(args, argv, argc);
+	}
+	result = rb_yield_values2(len, RARRAY_CONST_PTR(args));
+	RB_GC_GUARD(args);
+    }
+    if (result == Qundef) rb_iter_break();
+    return Qnil;
+}
+
+static VALUE
+lazy_init_block_i(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    rb_block_call(m, id_each, argc-1, argv+1, lazy_init_iterator, val);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   Lazy.new(obj, size=nil) { |yielder, *values| ... }
+ *
+ * Creates a new Lazy enumerator. When the enumerator is actually enumerated
+ * (e.g. by calling #force), +obj+ will be enumerated and each value passed
+ * to the given block. The block can yield values back using +yielder+.
+ * For example, to create a method +filter_map+ in both lazy and
+ * non-lazy fashions:
+ *
+ *   module Enumerable
+ *     def filter_map(&block)
+ *       map(&block).compact
+ *     end
+ *   end
+ *
+ *   class Enumerator::Lazy
+ *     def filter_map
+ *       Lazy.new(self) do |yielder, *values|
+ *         result = yield *values
+ *         yielder << result if result
+ *       end
+ *     end
+ *   end
+ *
+ *   (1..Float::INFINITY).lazy.filter_map{|i| i*i if i.even?}.first(5)
+ *       # => [4, 16, 36, 64, 100]
+ */
+static VALUE
+lazy_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE obj, size = Qnil;
+    VALUE generator;
+
+    rb_check_arity(argc, 1, 2);
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy new without a block");
+    }
+    obj = argv[0];
+    if (argc > 1) {
+	size = argv[1];
+    }
+    generator = generator_allocate(rb_cGenerator);
+    rb_block_call(generator, id_initialize, 0, 0, lazy_init_block_i, obj);
+    enumerator_init(self, generator, sym_each, 0, 0, 0, size);
+    rb_ivar_set(self, id_receiver, obj);
+
+    return self;
+}
+
+static VALUE
+lazy_set_method(VALUE lazy, VALUE args, rb_enumerator_size_func *size_fn)
+{
+    ID id = rb_frame_this_func();
+    struct enumerator *e = enumerator_ptr(lazy);
+    rb_ivar_set(lazy, id_method, ID2SYM(id));
+    if (NIL_P(args)) {
+	/* Qfalse indicates that the arguments are empty */
+	rb_ivar_set(lazy, id_arguments, Qfalse);
+    }
+    else {
+	rb_ivar_set(lazy, id_arguments, args);
+    }
+    e->size_fn = size_fn;
+    return lazy;
+}
+
+/*
+ * call-seq:
+ *   e.lazy -> lazy_enumerator
+ *
+ * Returns a lazy enumerator, whose methods map/collect,
+ * flat_map/collect_concat, select/find_all, reject, grep, zip, take,
+ * take_while, drop, and drop_while enumerate values only on an
+ * as-needed basis.  However, if a block is given to zip, values
+ * are enumerated immediately.
+ *
+ * === Example
+ *
+ * The following program finds pythagorean triples:
+ *
+ *   def pythagorean_triples
+ *     (1..Float::INFINITY).lazy.flat_map {|z|
+ *       (1..z).flat_map {|x|
+ *         (x..z).select {|y|
+ *           x**2 + y**2 == z**2
+ *         }.map {|y|
+ *           [x, y, z]
+ *         }
+ *       }
+ *     }
+ *   end
+ *   # show first ten pythagorean triples
+ *   p pythagorean_triples.take(10).force # take is lazy, so force is needed
+ *   p pythagorean_triples.first(10)      # first is eager
+ *   # show pythagorean triples less than 100
+ *   p pythagorean_triples.take_while { |*, z| z < 100 }.force
+ */
+static VALUE
+enumerable_lazy(VALUE obj)
+{
+    VALUE result = lazy_to_enum_i(obj, sym_each, 0, 0, lazyenum_size);
+    /* Qfalse indicates that the Enumerator::Lazy has no method name */
+    rb_ivar_set(result, id_method, Qfalse);
+    return result;
+}
+
+static VALUE
+lazy_to_enum_i(VALUE obj, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *size_fn)
+{
+    return enumerator_init(enumerator_allocate(rb_cLazy),
+			   obj, meth, argc, argv, size_fn, Qnil);
+}
+
+/*
+ * call-seq:
+ *   lzy.to_enum(method = :each, *args)                 -> lazy_enum
+ *   lzy.enum_for(method = :each, *args)                -> lazy_enum
+ *   lzy.to_enum(method = :each, *args) {|*args| block} -> lazy_enum
+ *   lzy.enum_for(method = :each, *args){|*args| block} -> lazy_enum
+ *
+ * Similar to Kernel#to_enum, except it returns a lazy enumerator.
+ * This makes it easy to define Enumerable methods that will
+ * naturally remain lazy if called from a lazy enumerator.
+ *
+ * For example, continuing from the example in Kernel#to_enum:
+ *
+ *   # See Kernel#to_enum for the definition of repeat
+ *   r = 1..Float::INFINITY
+ *   r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
+ *   r.repeat(2).class # => Enumerator
+ *   r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
+ *   # works naturally on lazy enumerator:
+ *   r.lazy.repeat(2).class # => Enumerator::Lazy
+ *   r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]
+ */
+
+static VALUE
+lazy_to_enum(int argc, VALUE *argv, VALUE self)
+{
+    VALUE lazy, meth = sym_each;
+
+    if (argc > 0) {
+	--argc;
+	meth = *argv++;
+    }
+    lazy = lazy_to_enum_i(self, meth, argc, argv, 0);
+    if (rb_block_given_p()) {
+	enumerator_ptr(lazy)->size = rb_block_proc();
+    }
+    return lazy;
+}
+
+static VALUE
+lazy_map_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE result = rb_yield_values2(argc - 1, &argv[1]);
+
+    rb_funcall(argv[0], id_yield, 1, result);
+    return Qnil;
+}
+
+static VALUE
+lazy_map(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy map without a block");
+    }
+
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_map_func, 0),
+			   Qnil, lazy_receiver_size);
+}
+
+static VALUE
+lazy_flat_map_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, yielder))
+{
+    return rb_funcall2(yielder, id_yield, argc, argv);
+}
+
+static VALUE
+lazy_flat_map_each(VALUE obj, VALUE yielder)
+{
+    rb_block_call(obj, id_each, 0, 0, lazy_flat_map_i, yielder);
+    return Qnil;
+}
+
+static VALUE
+lazy_flat_map_to_ary(VALUE obj, VALUE yielder)
+{
+    VALUE ary = rb_check_array_type(obj);
+    if (NIL_P(ary)) {
+	rb_funcall(yielder, id_yield, 1, obj);
+    }
+    else {
+	long i;
+	for (i = 0; i < RARRAY_LEN(ary); i++) {
+	    rb_funcall(yielder, id_yield, 1, RARRAY_AREF(ary, i));
+	}
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_flat_map_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE result = rb_yield_values2(argc - 1, &argv[1]);
+    if (RB_TYPE_P(result, T_ARRAY)) {
+	long i;
+	for (i = 0; i < RARRAY_LEN(result); i++) {
+	    rb_funcall(argv[0], id_yield, 1, RARRAY_AREF(result, i));
+	}
+    }
+    else {
+	if (rb_respond_to(result, id_force) && rb_respond_to(result, id_each)) {
+	    lazy_flat_map_each(result, argv[0]);
+	}
+	else {
+	    lazy_flat_map_to_ary(result, argv[0]);
+	}
+    }
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     lazy.collect_concat { |obj| block } -> a_lazy_enumerator
+ *     lazy.flat_map       { |obj| block } -> a_lazy_enumerator
+ *
+ *  Returns a new lazy enumerator with the concatenated results of running
+ *  <i>block</i> once for every element in <i>lazy</i>.
+ *
+ *    ["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
+ *    #=> ["f", "o", "o", "b", "a", "r"]
+ *
+ *  A value <i>x</i> returned by <i>block</i> is decomposed if either of
+ *  the following conditions is true:
+ *
+ *    a) <i>x</i> responds to both each and force, which means that
+ *       <i>x</i> is a lazy enumerator.
+ *    b) <i>x</i> is an array or responds to to_ary.
+ *
+ *  Otherwise, <i>x</i> is contained as-is in the return value.
+ *
+ *    [{a:1}, {b:2}].lazy.flat_map {|i| i}.force
+ *    #=> [{:a=>1}, {:b=>2}]
+ */
+static VALUE
+lazy_flat_map(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy flat_map without a block");
+    }
+
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_flat_map_func, 0),
+			   Qnil, 0);
+}
+
+static VALUE
+lazy_select_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE element = rb_enum_values_pack(argc - 1, argv + 1);
+
+    if (RTEST(rb_yield(element))) {
+	return rb_funcall(argv[0], id_yield, 1, element);
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_select(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy select without a block");
+    }
+
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_select_func, 0),
+			   Qnil, 0);
+}
+
+static VALUE
+lazy_reject_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE element = rb_enum_values_pack(argc - 1, argv + 1);
+
+    if (!RTEST(rb_yield(element))) {
+	return rb_funcall(argv[0], id_yield, 1, element);
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_reject(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy reject without a block");
+    }
+
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_reject_func, 0),
+			   Qnil, 0);
+}
+
+static VALUE
+lazy_grep_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE i = rb_enum_values_pack(argc - 1, argv + 1);
+    VALUE result = rb_funcall(m, id_eqq, 1, i);
+
+    if (RTEST(result)) {
+	rb_funcall(argv[0], id_yield, 1, i);
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_grep_iter(RB_BLOCK_CALL_FUNC_ARGLIST(val, m))
+{
+    VALUE i = rb_enum_values_pack(argc - 1, argv + 1);
+    VALUE result = rb_funcall(m, id_eqq, 1, i);
+
+    if (RTEST(result)) {
+	rb_funcall(argv[0], id_yield, 1, rb_yield(i));
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_grep(VALUE obj, VALUE pattern)
+{
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 rb_block_given_p() ?
+					 lazy_grep_iter : lazy_grep_func,
+					 pattern),
+			   rb_ary_new3(1, pattern), 0);
+}
+
+static VALUE
+call_next(VALUE obj)
+{
+    return rb_funcall(obj, id_next, 0);
+}
+
+static VALUE
+next_stopped(VALUE obj)
+{
+    return Qnil;
+}
+
+static VALUE
+lazy_zip_arrays_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, arrays))
+{
+    VALUE yielder, ary, memo;
+    long i, count;
+
+    yielder = argv[0];
+    memo = rb_attr_get(yielder, id_memo);
+    count = NIL_P(memo) ? 0 : NUM2LONG(memo);
+
+    ary = rb_ary_new2(RARRAY_LEN(arrays) + 1);
+    rb_ary_push(ary, argv[1]);
+    for (i = 0; i < RARRAY_LEN(arrays); i++) {
+	rb_ary_push(ary, rb_ary_entry(RARRAY_AREF(arrays, i), count));
+    }
+    rb_funcall(yielder, id_yield, 1, ary);
+    rb_ivar_set(yielder, id_memo, LONG2NUM(++count));
+    return Qnil;
+}
+
+static VALUE
+lazy_zip_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, zip_args))
+{
+    VALUE yielder, ary, arg, v;
+    long i;
+
+    yielder = argv[0];
+    arg = rb_attr_get(yielder, id_memo);
+    if (NIL_P(arg)) {
+	arg = rb_ary_new2(RARRAY_LEN(zip_args));
+	for (i = 0; i < RARRAY_LEN(zip_args); i++) {
+	    rb_ary_push(arg, rb_funcall(RARRAY_AREF(zip_args, i), id_to_enum, 0));
+	}
+	rb_ivar_set(yielder, id_memo, arg);
+    }
+
+    ary = rb_ary_new2(RARRAY_LEN(arg) + 1);
+    v = Qnil;
+    if (--argc > 0) {
+	++argv;
+	v = argc > 1 ? rb_ary_new_from_values(argc, argv) : *argv;
+    }
+    rb_ary_push(ary, v);
+    for (i = 0; i < RARRAY_LEN(arg); i++) {
+	v = rb_rescue2(call_next, RARRAY_AREF(arg, i), next_stopped, 0,
+		       rb_eStopIteration, (VALUE)0);
+	rb_ary_push(ary, v);
+    }
+    rb_funcall(yielder, id_yield, 1, ary);
+    return Qnil;
+}
+
+static VALUE
+lazy_zip(int argc, VALUE *argv, VALUE obj)
+{
+    VALUE ary, v;
+    long i;
+    rb_block_call_func *func = lazy_zip_arrays_func;
+
+    if (rb_block_given_p()) {
+	return rb_call_super(argc, argv);
+    }
+
+    ary = rb_ary_new2(argc);
+    for (i = 0; i < argc; i++) {
+	v = rb_check_array_type(argv[i]);
+	if (NIL_P(v)) {
+	    for (; i < argc; i++) {
+		if (!rb_respond_to(argv[i], id_each)) {
+		    rb_raise(rb_eTypeError, "wrong argument type %s (must respond to :each)",
+			rb_obj_classname(argv[i]));
+		}
+	    }
+	    ary = rb_ary_new4(argc, argv);
+	    func = lazy_zip_func;
+	    break;
+	}
+	rb_ary_push(ary, v);
+    }
+
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 func, ary),
+			   ary, lazy_receiver_size);
+}
+
+static VALUE
+lazy_take_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, args))
+{
+    long remain;
+    VALUE memo = rb_attr_get(argv[0], id_memo);
+    if (NIL_P(memo)) {
+	memo = args;
+    }
+
+    rb_funcall2(argv[0], id_yield, argc - 1, argv + 1);
+    if ((remain = NUM2LONG(memo)-1) == 0) {
+	return Qundef;
+    }
+    else {
+	rb_ivar_set(argv[0], id_memo, LONG2NUM(remain));
+	return Qnil;
+    }
+}
+
+static VALUE
+lazy_take_size(VALUE generator, VALUE args, VALUE lazy)
+{
+    VALUE receiver = lazy_size(lazy);
+    long len = NUM2LONG(RARRAY_AREF(rb_ivar_get(lazy, id_arguments), 0));
+    if (NIL_P(receiver) || (FIXNUM_P(receiver) && FIX2LONG(receiver) < len))
+	return receiver;
+    return LONG2NUM(len);
+}
+
+static VALUE
+lazy_take(VALUE obj, VALUE n)
+{
+    long len = NUM2LONG(n);
+    VALUE lazy;
+
+    if (len < 0) {
+	rb_raise(rb_eArgError, "attempt to take negative size");
+    }
+    if (len == 0) {
+	VALUE len = INT2FIX(0);
+	lazy = lazy_to_enum_i(obj, sym_cycle, 1, &len, 0);
+    }
+    else {
+	lazy = rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_take_func, n);
+    }
+    return lazy_set_method(lazy, rb_ary_new3(1, n), lazy_take_size);
+}
+
+static VALUE
+lazy_take_while_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, args))
+{
+    VALUE result = rb_yield_values2(argc - 1, &argv[1]);
+    if (!RTEST(result)) return Qundef;
+    rb_funcall2(argv[0], id_yield, argc - 1, argv + 1);
+    return Qnil;
+}
+
+static VALUE
+lazy_take_while(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy take_while without a block");
+    }
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_take_while_func, 0),
+			   Qnil, 0);
+}
+
+static VALUE
+lazy_drop_size(VALUE generator, VALUE args, VALUE lazy)
+{
+    long len = NUM2LONG(RARRAY_AREF(rb_ivar_get(lazy, id_arguments), 0));
+    VALUE receiver = lazy_size(lazy);
+    if (NIL_P(receiver))
+	return receiver;
+    if (FIXNUM_P(receiver)) {
+	len = FIX2LONG(receiver) - len;
+	return LONG2FIX(len < 0 ? 0 : len);
+    }
+    return rb_funcall(receiver, '-', 1, LONG2NUM(len));
+}
+
+static VALUE
+lazy_drop_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, args))
+{
+    long remain;
+    VALUE memo = rb_attr_get(argv[0], id_memo);
+    if (NIL_P(memo)) {
+	memo = args;
+    }
+    if ((remain = NUM2LONG(memo)) == 0) {
+	rb_funcall2(argv[0], id_yield, argc - 1, argv + 1);
+    }
+    else {
+	rb_ivar_set(argv[0], id_memo, LONG2NUM(--remain));
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_drop(VALUE obj, VALUE n)
+{
+    long len = NUM2LONG(n);
+
+    if (len < 0) {
+	rb_raise(rb_eArgError, "attempt to drop negative size");
+    }
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_drop_func, n),
+			   rb_ary_new3(1, n), lazy_drop_size);
+}
+
+static VALUE
+lazy_drop_while_func(RB_BLOCK_CALL_FUNC_ARGLIST(val, args))
+{
+    VALUE memo = rb_attr_get(argv[0], id_memo);
+    if (NIL_P(memo) && !RTEST(rb_yield_values2(argc - 1, &argv[1]))) {
+	rb_ivar_set(argv[0], id_memo, memo = Qtrue);
+    }
+    if (memo == Qtrue) {
+	rb_funcall2(argv[0], id_yield, argc - 1, argv + 1);
+    }
+    return Qnil;
+}
+
+static VALUE
+lazy_drop_while(VALUE obj)
+{
+    if (!rb_block_given_p()) {
+	rb_raise(rb_eArgError, "tried to call lazy drop_while without a block");
+    }
+    return lazy_set_method(rb_block_call(rb_cLazy, id_new, 1, &obj,
+					 lazy_drop_while_func, 0),
+			   Qnil, 0);
+}
+
+static VALUE
+lazy_super(int argc, VALUE *argv, VALUE lazy)
+{
+    return enumerable_lazy(rb_call_super(argc, argv));
+}
+
+static VALUE
+lazy_lazy(VALUE obj)
+{
+    return obj;
+}
+
+/*
+ * Document-class: StopIteration
+ *
+ * Raised to stop the iteration, in particular by Enumerator#next. It is
+ * rescued by Kernel#loop.
+ *
+ *   loop do
+ *     puts "Hello"
+ *     raise StopIteration
+ *     puts "World"
+ *   end
+ *   puts "Done!"
+ *
+ * <em>produces:</em>
+ *
+ *   Hello
+ *   Done!
+ */
+
+/*
+ * call-seq:
+ *   result       -> value
+ *
+ * Returns the return value of the iterator.
+ *
+ *   o = Object.new
+ *   def o.each
+ *     yield 1
+ *     yield 2
+ *     yield 3
+ *     100
+ *   end
+ *
+ *   e = o.to_enum
+ *
+ *   puts e.next                   #=> 1
+ *   puts e.next                   #=> 2
+ *   puts e.next                   #=> 3
+ *
+ *   begin
+ *     e.next
+ *   rescue StopIteration => ex
+ *     puts ex.result              #=> 100
+ *   end
+ *
+ */
+
+static VALUE
+stop_result(VALUE self)
+{
+    return rb_attr_get(self, id_result);
+}
+
+void
+InitVM_Enumerator(void)
+{
+    rb_define_method(rb_mKernel, "to_enum", obj_to_enum, -1);
+    rb_define_method(rb_mKernel, "enum_for", obj_to_enum, -1);
+
+    rb_cEnumerator = rb_define_class("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, -1);
+    rb_define_method(rb_cEnumerator, "each_with_index", enumerator_each_with_index, 0);
+    rb_define_method(rb_cEnumerator, "each_with_object", enumerator_with_object, 1);
+    rb_define_method(rb_cEnumerator, "with_index", enumerator_with_index, -1);
+    rb_define_method(rb_cEnumerator, "with_object", enumerator_with_object, 1);
+    rb_define_method(rb_cEnumerator, "next_values", enumerator_next_values, 0);
+    rb_define_method(rb_cEnumerator, "peek_values", enumerator_peek_values_m, 0);
+    rb_define_method(rb_cEnumerator, "next", enumerator_next, 0);
+    rb_define_method(rb_cEnumerator, "peek", enumerator_peek, 0);
+    rb_define_method(rb_cEnumerator, "feed", enumerator_feed, 1);
+    rb_define_method(rb_cEnumerator, "rewind", enumerator_rewind, 0);
+    rb_define_method(rb_cEnumerator, "inspect", enumerator_inspect, 0);
+    rb_define_method(rb_cEnumerator, "size", enumerator_size, 0);
+
+    /* Lazy */
+    rb_cLazy = rb_define_class_under(rb_cEnumerator, "Lazy", rb_cEnumerator);
+    rb_define_method(rb_mEnumerable, "lazy", enumerable_lazy, 0);
+    rb_define_method(rb_cLazy, "initialize", lazy_initialize, -1);
+    rb_define_method(rb_cLazy, "to_enum", lazy_to_enum, -1);
+    rb_define_method(rb_cLazy, "enum_for", lazy_to_enum, -1);
+    rb_define_method(rb_cLazy, "map", lazy_map, 0);
+    rb_define_method(rb_cLazy, "collect", lazy_map, 0);
+    rb_define_method(rb_cLazy, "flat_map", lazy_flat_map, 0);
+    rb_define_method(rb_cLazy, "collect_concat", lazy_flat_map, 0);
+    rb_define_method(rb_cLazy, "select", lazy_select, 0);
+    rb_define_method(rb_cLazy, "find_all", lazy_select, 0);
+    rb_define_method(rb_cLazy, "reject", lazy_reject, 0);
+    rb_define_method(rb_cLazy, "grep", lazy_grep, 1);
+    rb_define_method(rb_cLazy, "zip", lazy_zip, -1);
+    rb_define_method(rb_cLazy, "take", lazy_take, 1);
+    rb_define_method(rb_cLazy, "take_while", lazy_take_while, 0);
+    rb_define_method(rb_cLazy, "drop", lazy_drop, 1);
+    rb_define_method(rb_cLazy, "drop_while", lazy_drop_while, 0);
+    rb_define_method(rb_cLazy, "lazy", lazy_lazy, 0);
+    rb_define_method(rb_cLazy, "chunk", lazy_super, -1);
+    rb_define_method(rb_cLazy, "slice_before", lazy_super, -1);
+    rb_define_method(rb_cLazy, "slice_after", lazy_super, -1);
+    rb_define_method(rb_cLazy, "slice_when", lazy_super, -1);
+
+    rb_define_alias(rb_cLazy, "force", "to_a");
+
+    rb_eStopIteration = rb_define_class("StopIteration", rb_eIndexError);
+    rb_define_method(rb_eStopIteration, "result", stop_result, 0);
+
+    /* 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, -1);
+
+    /* 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);
+    rb_define_method(rb_cYielder, "<<", yielder_yield_push, -2);
+
+    rb_provide("enumerator.so");	/* for backward compatibility */
+}
+
+#undef rb_intern
+void
+Init_Enumerator(void)
+{
+    id_rewind = rb_intern("rewind");
+    id_each = rb_intern("each");
+    id_call = rb_intern("call");
+    id_size = rb_intern("size");
+    id_yield = rb_intern("yield");
+    id_new = rb_intern("new");
+    id_initialize = rb_intern("initialize");
+    id_next = rb_intern("next");
+    id_result = rb_intern("result");
+    id_lazy = rb_intern("lazy");
+    id_eqq = rb_intern("===");
+    id_receiver = rb_intern("receiver");
+    id_arguments = rb_intern("arguments");
+    id_memo = rb_intern("memo");
+    id_method = rb_intern("method");
+    id_force = rb_intern("force");
+    id_to_enum = rb_intern("to_enum");
+    sym_each = ID2SYM(id_each);
+    sym_cycle = ID2SYM(rb_intern("cycle"));
+
+    InitVM(Enumerator);
+}