diff options
Diffstat (limited to 'ruby_2_2/enumerator.c')
-rw-r--r-- | ruby_2_2/enumerator.c | 2092 |
1 files changed, 0 insertions, 2092 deletions
diff --git a/ruby_2_2/enumerator.c b/ruby_2_2/enumerator.c deleted file mode 100644 index 4d989c3941..0000000000 --- a/ruby_2_2/enumerator.c +++ /dev/null @@ -1,2092 +0,0 @@ -/************************************************ - - enumerator.c - provides Enumerator class - - $Author$ - - Copyright (C) 2001-2003 Akinori MUSHA - - $Idaemons: /home/cvs/rb/enumerator/enumerator.c,v 1.1.1.1 2001/07/15 10:12:48 knu Exp $ - $RoughId: enumerator.c,v 1.6 2003/07/27 11:03:24 nobu Exp $ - $Id$ - -************************************************/ - -#include "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); -} |