summaryrefslogtreecommitdiff
path: root/trunk/range.c
diff options
context:
space:
mode:
Diffstat (limited to 'trunk/range.c')
-rw-r--r--trunk/range.c939
1 files changed, 939 insertions, 0 deletions
diff --git a/trunk/range.c b/trunk/range.c
new file mode 100644
index 0000000000..09dc762acf
--- /dev/null
+++ b/trunk/range.c
@@ -0,0 +1,939 @@
+/**********************************************************************
+
+ range.c -
+
+ $Author$
+ created at: Thu Aug 19 17:46:47 JST 1993
+
+ Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#include "ruby/ruby.h"
+#include "ruby/encoding.h"
+
+VALUE rb_cRange;
+static ID id_cmp, id_succ, id_beg, id_end, id_excl;
+
+extern VALUE rb_struct_init_copy(VALUE copy, VALUE s);
+
+#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
+#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
+#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
+
+#define EXCL(r) RTEST(RANGE_EXCL(r))
+#define SET_EXCL(r,v) (RSTRUCT(r)->as.ary[2] = (v) ? Qtrue : Qfalse)
+
+static VALUE
+range_failed(void)
+{
+ rb_raise(rb_eArgError, "bad value for range");
+ return Qnil; /* dummy */
+}
+
+static VALUE
+range_check(VALUE *args)
+{
+ return rb_funcall(args[0], id_cmp, 1, args[1]);
+}
+
+static void
+range_init(VALUE range, VALUE beg, VALUE end, int exclude_end)
+{
+ VALUE args[2];
+
+ args[0] = beg;
+ args[1] = end;
+
+ if (!FIXNUM_P(beg) || !FIXNUM_P(end)) {
+ VALUE v;
+
+ v = rb_rescue(range_check, (VALUE)args, range_failed, 0);
+ if (NIL_P(v))
+ range_failed();
+ }
+
+ SET_EXCL(range, exclude_end);
+ RSTRUCT(range)->as.ary[0] = beg;
+ RSTRUCT(range)->as.ary[1] = end;
+}
+
+VALUE
+rb_range_new(VALUE beg, VALUE end, int exclude_end)
+{
+ VALUE range = rb_obj_alloc(rb_cRange);
+
+ range_init(range, beg, end, exclude_end);
+ return range;
+}
+
+/*
+ * call-seq:
+ * Range.new(start, end, exclusive=false) => range
+ *
+ * Constructs a range using the given <i>start</i> and <i>end</i>. If the third
+ * parameter is omitted or is <code>false</code>, the <i>range</i> will include
+ * the end object; otherwise, it will be excluded.
+ */
+
+static VALUE
+range_initialize(int argc, VALUE *argv, VALUE range)
+{
+ VALUE beg, end, flags;
+
+ rb_scan_args(argc, argv, "21", &beg, &end, &flags);
+ /* Ranges are immutable, so that they should be initialized only once. */
+ if (RANGE_EXCL(range) != Qnil) {
+ rb_name_error(rb_intern("initialize"), "`initialize' called twice");
+ }
+ range_init(range, beg, end, RTEST(flags));
+ return Qnil;
+}
+
+#define range_initialize_copy rb_struct_init_copy /* :nodoc: */
+
+/*
+ * call-seq:
+ * rng.exclude_end? => true or false
+ *
+ * Returns <code>true</code> if <i>rng</i> excludes its end value.
+ */
+
+static VALUE
+range_exclude_end_p(VALUE range)
+{
+ return EXCL(range) ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ * rng == obj => true or false
+ *
+ * Returns <code>true</code> only if <i>obj</i> is a Range, has equivalent
+ * beginning and end items (by comparing them with <code>==</code>), and has
+ * the same #exclude_end? setting as <i>rng</t>.
+ *
+ * (0..2) == (0..2) #=> true
+ * (0..2) == Range.new(0,2) #=> true
+ * (0..2) == (0...2) #=> false
+ *
+ */
+
+static VALUE
+range_eq(VALUE range, VALUE obj)
+{
+ if (range == obj)
+ return Qtrue;
+ if (!rb_obj_is_instance_of(obj, rb_obj_class(range)))
+ return Qfalse;
+
+ if (!rb_equal(RANGE_BEG(range), RANGE_BEG(obj)))
+ return Qfalse;
+ if (!rb_equal(RANGE_END(range), RANGE_END(obj)))
+ return Qfalse;
+
+ if (EXCL(range) != EXCL(obj))
+ return Qfalse;
+
+ return Qtrue;
+}
+
+static int
+r_lt(VALUE a, VALUE b)
+{
+ VALUE r = rb_funcall(a, id_cmp, 1, b);
+
+ if (NIL_P(r))
+ return Qfalse;
+ if (rb_cmpint(r, a, b) < 0)
+ return Qtrue;
+ return Qfalse;
+}
+
+static int
+r_le(VALUE a, VALUE b)
+{
+ int c;
+ VALUE r = rb_funcall(a, id_cmp, 1, b);
+
+ if (NIL_P(r))
+ return Qfalse;
+ c = rb_cmpint(r, a, b);
+ if (c == 0)
+ return INT2FIX(0);
+ if (c < 0)
+ return Qtrue;
+ return Qfalse;
+}
+
+
+/*
+ * call-seq:
+ * rng.eql?(obj) => true or false
+ *
+ * Returns <code>true</code> only if <i>obj</i> is a Range, has equivalent
+ * beginning and end items (by comparing them with #eql?), and has the same
+ * #exclude_end? setting as <i>rng</i>.
+ *
+ * (0..2) == (0..2) #=> true
+ * (0..2) == Range.new(0,2) #=> true
+ * (0..2) == (0...2) #=> false
+ *
+ */
+
+static VALUE
+range_eql(VALUE range, VALUE obj)
+{
+ if (range == obj)
+ return Qtrue;
+ if (!rb_obj_is_instance_of(obj, rb_obj_class(range)))
+ return Qfalse;
+
+ if (!rb_eql(RANGE_BEG(range), RANGE_BEG(obj)))
+ return Qfalse;
+ if (!rb_eql(RANGE_END(range), RANGE_END(obj)))
+ return Qfalse;
+
+ if (EXCL(range) != EXCL(obj))
+ return Qfalse;
+
+ return Qtrue;
+}
+
+/*
+ * call-seq:
+ * rng.hash => fixnum
+ *
+ * Generate a hash value such that two ranges with the same start and
+ * end points, and the same value for the "exclude end" flag, generate
+ * the same hash value.
+ */
+
+static VALUE
+range_hash(VALUE range)
+{
+ long hash = EXCL(range);
+ VALUE v;
+
+ v = rb_hash(RANGE_BEG(range));
+ hash ^= v << 1;
+ v = rb_hash(RANGE_END(range));
+ hash ^= v << 9;
+ hash ^= EXCL(range) << 24;
+
+ return LONG2FIX(hash);
+}
+
+static void
+range_each_func(VALUE range, VALUE (*func) (VALUE, void *), void *arg)
+{
+ int c;
+ VALUE b = RANGE_BEG(range);
+ VALUE e = RANGE_END(range);
+ VALUE v = b;
+
+ if (EXCL(range)) {
+ while (r_lt(v, e)) {
+ (*func) (v, arg);
+ v = rb_funcall(v, id_succ, 0, 0);
+ }
+ }
+ else {
+ while (RTEST(c = r_le(v, e))) {
+ (*func) (v, arg);
+ if (c == INT2FIX(0))
+ break;
+ v = rb_funcall(v, id_succ, 0, 0);
+ }
+ }
+}
+
+static VALUE
+step_i(VALUE i, void *arg)
+{
+ VALUE *iter = arg;
+
+ if (FIXNUM_P(iter[0])) {
+ iter[0] -= INT2FIX(1) & ~FIXNUM_FLAG;
+ }
+ else {
+ iter[0] = rb_funcall(iter[0], '-', 1, INT2FIX(1));
+ }
+ if (iter[0] == INT2FIX(0)) {
+ rb_yield(i);
+ iter[0] = iter[1];
+ }
+ return Qnil;
+}
+
+/*
+ * call-seq:
+ * rng.step(n=1) {| obj | block } => rng
+ *
+ * Iterates over <i>rng</i>, passing each <i>n</i>th element to the block. If
+ * the range contains numbers, <i>n</i> is added for each iteration. Otherwise
+ * <code>step</code> invokes <code>succ</code> to iterate through range
+ * elements. The following code uses class <code>Xs</code>, which is defined
+ * in the class-level documentation.
+ *
+ * range = Xs.new(1)..Xs.new(10)
+ * range.step(2) {|x| puts x}
+ * range.step(3) {|x| puts x}
+ *
+ * <em>produces:</em>
+ *
+ * 1 x
+ * 3 xxx
+ * 5 xxxxx
+ * 7 xxxxxxx
+ * 9 xxxxxxxxx
+ * 1 x
+ * 4 xxxx
+ * 7 xxxxxxx
+ * 10 xxxxxxxxxx
+ */
+
+
+static VALUE
+range_step(int argc, VALUE *argv, VALUE range)
+{
+ VALUE b, e, step, tmp;
+
+ RETURN_ENUMERATOR(range, argc, argv);
+
+ b = RANGE_BEG(range);
+ e = RANGE_END(range);
+ if (argc == 0) {
+ step = INT2FIX(1);
+ }
+ else {
+ rb_scan_args(argc, argv, "01", &step);
+ if (!rb_obj_is_kind_of(step, rb_cNumeric)) {
+ step = rb_to_int(step);
+ }
+ if (rb_funcall(step, '<', 1, INT2FIX(0))) {
+ rb_raise(rb_eArgError, "step can't be negative");
+ }
+ else if (!rb_funcall(step, '>', 1, INT2FIX(0))) {
+ rb_raise(rb_eArgError, "step can't be 0");
+ }
+ }
+
+ if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
+ long end = FIX2LONG(e);
+ long i, unit = FIX2LONG(step);
+
+ if (!EXCL(range))
+ end += 1;
+ i = FIX2LONG(b);
+ while (i < end) {
+ rb_yield(LONG2NUM(i));
+ if (i + unit < i) break;
+ i += unit;
+ }
+
+ }
+ else if (rb_obj_is_kind_of(b, rb_cNumeric) ||
+ !NIL_P(rb_check_to_integer(b, "to_int")) ||
+ !NIL_P(rb_check_to_integer(e, "to_int"))) {
+ ID op = EXCL(range) ? '<' : rb_intern("<=");
+
+ while (RTEST(rb_funcall(b, op, 1, e))) {
+ rb_yield(b);
+ b = rb_funcall(b, '+', 1, step);
+ }
+ }
+ else {
+ tmp = rb_check_string_type(b);
+
+ if (!NIL_P(tmp)) {
+ VALUE args[2], iter[2];
+
+ b = tmp;
+ args[0] = e;
+ args[1] = EXCL(range) ? Qtrue : Qfalse;
+ iter[0] = INT2FIX(1);
+ iter[1] = step;
+ rb_block_call(b, rb_intern("upto"), 2, args, step_i, (VALUE)iter);
+ }
+ else {
+ VALUE args[2];
+
+ if (!rb_respond_to(b, id_succ)) {
+ rb_raise(rb_eTypeError, "can't iterate from %s",
+ rb_obj_classname(b));
+ }
+ args[0] = INT2FIX(1);
+ args[1] = step;
+ range_each_func(range, step_i, args);
+ }
+ }
+ return range;
+}
+
+static VALUE
+each_i(VALUE v, void *arg)
+{
+ rb_yield(v);
+ return Qnil;
+}
+
+/*
+ * call-seq:
+ * rng.each {| i | block } => rng
+ *
+ * Iterates over the elements <i>rng</i>, passing each in turn to the
+ * block. You can only iterate if the start object of the range
+ * supports the +succ+ method (which means that you can't iterate over
+ * ranges of +Float+ objects).
+ *
+ * (10..15).each do |n|
+ * print n, ' '
+ * end
+ *
+ * <em>produces:</em>
+ *
+ * 10 11 12 13 14 15
+ */
+
+static VALUE
+range_each(VALUE range)
+{
+ VALUE beg, end;
+
+ RETURN_ENUMERATOR(range, 0, 0);
+
+ beg = RANGE_BEG(range);
+ end = RANGE_END(range);
+
+ if (!rb_respond_to(beg, id_succ)) {
+ rb_raise(rb_eTypeError, "can't iterate from %s",
+ rb_obj_classname(beg));
+ }
+ if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
+ long lim = FIX2LONG(end);
+ long i;
+
+ if (!EXCL(range))
+ lim += 1;
+ for (i = FIX2LONG(beg); i < lim; i++) {
+ rb_yield(LONG2FIX(i));
+ }
+ }
+ else if (TYPE(beg) == T_STRING) {
+ VALUE args[2];
+
+ args[0] = end;
+ args[1] = EXCL(range) ? Qtrue : Qfalse;
+ rb_block_call(beg, rb_intern("upto"), 2, args, rb_yield, 0);
+ }
+ else {
+ range_each_func(range, each_i, NULL);
+ }
+ return range;
+}
+
+/*
+ * call-seq:
+ * rng.begin => obj
+ *
+ * Returns the first object in <i>rng</i>.
+ */
+
+static VALUE
+range_begin(VALUE range)
+{
+ return RANGE_BEG(range);
+}
+
+
+/*
+ * call-seq:
+ * rng.end => obj
+ *
+ * Returns the object that defines the end of <i>rng</i>.
+ *
+ * (1..10).end #=> 10
+ * (1...10).end #=> 10
+ */
+
+
+static VALUE
+range_end(VALUE range)
+{
+ return RANGE_END(range);
+}
+
+
+static VALUE
+first_i(VALUE i, VALUE *ary)
+{
+ long n = NUM2LONG(ary[0]);
+
+ if (n <= 0) {
+ rb_iter_break();
+ }
+ rb_ary_push(ary[1], i);
+ n--;
+ ary[0] = INT2NUM(n);
+ return Qnil;
+}
+
+/*
+ * call-seq:
+ * rng.first => obj
+ * rng.first(n) => an_array
+ *
+ * Returns the first object in <i>rng</i>, or the first +n+ elements.
+ */
+
+static VALUE
+range_first(int argc, VALUE *argv, VALUE range)
+{
+ VALUE n, ary[2];
+
+ if (argc == 0) return RANGE_BEG(range);
+
+ rb_scan_args(argc, argv, "1", &n);
+ ary[0] = n;
+ ary[1] = rb_ary_new2(NUM2LONG(n));
+ rb_block_call(range, rb_intern("each"), 0, 0, first_i, (VALUE)ary);
+
+ return ary[1];
+}
+
+
+/*
+ * call-seq:
+ * rng.last => obj
+ * rng.last(n) => an_array
+ *
+ * Returns the last object in <i>rng</i>, or the last +n+ elements.
+ */
+
+static VALUE
+range_last(int argc, VALUE *argv, VALUE range)
+{
+ VALUE rb_ary_last(int, VALUE *, VALUE);
+
+ if (argc == 0) return RANGE_END(range);
+ return rb_ary_last(argc, argv, rb_Array(range));
+}
+
+
+/*
+ * call-seq:
+ * rng.min => obj
+ * rng.min {| a,b | block } => obj
+ *
+ * Returns the minimum value in <i>rng</i>. The second uses
+ * the block to compare values. Returns nil if the first
+ * value in range is larger than the last value.
+ *
+ */
+
+
+static VALUE
+range_min(VALUE range)
+{
+ if (rb_block_given_p()) {
+ return rb_call_super(0, 0);
+ }
+ else {
+ VALUE b = RANGE_BEG(range);
+ VALUE e = RANGE_END(range);
+ int c = rb_cmpint(rb_funcall(b, id_cmp, 1, e), b, e);
+
+ if (c > 0 || (c == 0 && EXCL(range)))
+ return Qnil;
+ return b;
+ }
+}
+
+/*
+ * call-seq:
+ * rng.max => obj
+ * rng.max {| a,b | block } => obj
+ *
+ * Returns the maximum value in <i>rng</i>. The second uses
+ * the block to compare values. Returns nil if the first
+ * value in range is larger than the last value.
+ *
+ */
+
+
+static VALUE
+range_max(VALUE range)
+{
+ VALUE e = RANGE_END(range);
+ int ip = FIXNUM_P(e) || rb_obj_is_kind_of(e, rb_cInteger);
+
+ if (rb_block_given_p() || (EXCL(range) && !ip)) {
+ return rb_call_super(0, 0);
+ }
+ else {
+ VALUE b = RANGE_BEG(range);
+ int c = rb_cmpint(rb_funcall(b, id_cmp, 1, e), b, e);
+
+ if (c > 0)
+ return Qnil;
+ if (EXCL(range)) {
+ if (c == 0) return Qnil;
+ if (FIXNUM_P(e)) {
+ return LONG2NUM(FIX2LONG(e) - 1);
+ }
+ return rb_funcall(e, '-', 1, INT2FIX(1));
+ }
+ return e;
+ }
+}
+
+VALUE
+rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
+{
+ VALUE b, e;
+ long beg, end, excl;
+
+ if (rb_obj_is_kind_of(range, rb_cRange)) {
+ b = RANGE_BEG(range);
+ e = RANGE_END(range);
+ excl = EXCL(range);
+ }
+ else {
+ if (!rb_respond_to(range, id_beg)) return Qfalse;
+ if (!rb_respond_to(range, id_end)) return Qfalse;
+ b = rb_funcall(range, id_beg, 0);
+ e = rb_funcall(range, id_end, 0);
+ excl = RTEST(rb_funcall(range, rb_intern("exclude_end?"), 0));
+ }
+ beg = NUM2LONG(b);
+ end = NUM2LONG(e);
+
+ if (beg < 0) {
+ beg += len;
+ if (beg < 0)
+ goto out_of_range;
+ }
+ if (err == 0 || err == 2) {
+ if (beg > len)
+ goto out_of_range;
+ if (end > len)
+ end = len;
+ }
+ if (end < 0)
+ end += len;
+ if (!excl)
+ end++; /* include end point */
+ len = end - beg;
+ if (len < 0)
+ len = 0;
+
+ *begp = beg;
+ *lenp = len;
+ return Qtrue;
+
+ out_of_range:
+ if (err) {
+ rb_raise(rb_eRangeError, "%ld..%s%ld out of range",
+ b, excl ? "." : "", e);
+ }
+ return Qnil;
+}
+
+/*
+ * call-seq:
+ * rng.to_s => string
+ *
+ * Convert this range object to a printable form.
+ */
+
+static VALUE
+range_to_s(VALUE range)
+{
+ VALUE str, str2;
+
+ str = rb_obj_as_string(RANGE_BEG(range));
+ str2 = rb_obj_as_string(RANGE_END(range));
+ str = rb_str_dup(str);
+ rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
+ rb_str_append(str, str2);
+ OBJ_INFECT(str, str2);
+
+ return str;
+}
+
+/*
+ * call-seq:
+ * rng.inspect => string
+ *
+ * Convert this range object to a printable form (using
+ * <code>inspect</code> to convert the start and end
+ * objects).
+ */
+
+
+static VALUE
+range_inspect(VALUE range)
+{
+ VALUE str, str2;
+
+ str = rb_inspect(RANGE_BEG(range));
+ str2 = rb_inspect(RANGE_END(range));
+ str = rb_str_dup(str);
+ rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
+ rb_str_append(str, str2);
+ OBJ_INFECT(str, str2);
+
+ return str;
+}
+
+/*
+ * call-seq:
+ * rng === obj => true or false
+ *
+ * Returns <code>true</code> if <i>obj</i> is an element of
+ * <i>rng</i>, <code>false</code> otherwise. Conveniently,
+ * <code>===</code> is the comparison operator used by
+ * <code>case</code> statements.
+ *
+ * case 79
+ * when 1..50 then print "low\n"
+ * when 51..75 then print "medium\n"
+ * when 76..100 then print "high\n"
+ * end
+ *
+ * <em>produces:</em>
+ *
+ * high
+ */
+
+static VALUE
+range_eqq(VALUE range, VALUE val)
+{
+ return rb_funcall(range, rb_intern("include?"), 1, val);
+}
+
+
+/*
+ * call-seq:
+ * rng.member?(val) => true or false
+ * rng.include?(val) => true or false
+ *
+ * Returns <code>true</code> if <i>obj</i> is an element of
+ * <i>rng</i>, <code>false</code> otherwise. If beg and end are
+ * numeric, comparison is done according magnitude of values.
+ *
+ * ("a".."z").include?("g") # => true
+ * ("a".."z").include?("A") # => false
+ */
+
+static VALUE
+range_include(VALUE range, VALUE val)
+{
+ VALUE beg = RANGE_BEG(range);
+ VALUE end = RANGE_END(range);
+ int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||
+ rb_obj_is_kind_of(beg, rb_cNumeric) ||
+ rb_obj_is_kind_of(end, rb_cNumeric);
+
+ if (nv ||
+ !NIL_P(rb_check_to_integer(beg, "to_int")) ||
+ !NIL_P(rb_check_to_integer(end, "to_int"))) {
+ if (r_le(beg, val)) {
+ if (EXCL(range)) {
+ if (r_lt(val, end))
+ return Qtrue;
+ }
+ else {
+ if (r_le(val, end))
+ return Qtrue;
+ }
+ }
+ return Qfalse;
+ }
+ else if (TYPE(beg) == T_STRING && TYPE(end) == T_STRING &&
+ RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
+ if (NIL_P(val)) return Qfalse;
+ if (TYPE(val) == T_STRING) {
+ if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
+ return Qfalse;
+ else {
+ char b = RSTRING_PTR(beg)[0];
+ char e = RSTRING_PTR(end)[0];
+ char v = RSTRING_PTR(val)[0];
+
+ if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
+ if (b <= v && v < e) return Qtrue;
+ if (!EXCL(range) && v == e) return Qtrue;
+ return Qfalse;
+ }
+ }
+ }
+ }
+ /* TODO: ruby_frame->this_func = rb_intern("include?"); */
+ return rb_call_super(1, &val);
+}
+
+
+/*
+ * call-seq:
+ * rng.cover?(val) => true or false
+ *
+ * Returns <code>true</code> if <i>obj</i> is between beg and end,
+ * i.e <code>beg <= obj <= end</code> (or <i>end</i> exclusive when
+ * <code>exclude_end?</code> is true).
+ *
+ * ("a".."z").cover?("c") #=> true
+ * ("a".."z").cover?("5") #=> false
+ */
+
+static VALUE
+range_cover(VALUE range, VALUE val)
+{
+ VALUE beg, end;
+
+ beg = RANGE_BEG(range);
+ end = RANGE_END(range);
+ if (r_le(beg, val)) {
+ if (EXCL(range)) {
+ if (r_lt(val, end))
+ return Qtrue;
+ }
+ else {
+ if (r_le(val, end))
+ return Qtrue;
+ }
+ }
+ return Qfalse;
+}
+
+static VALUE
+range_dumper(VALUE range)
+{
+ VALUE v;
+ NEWOBJ(m, struct RObject);
+ OBJSETUP(m, rb_cObject, T_OBJECT);
+
+ v = (VALUE)m;
+
+ rb_ivar_set(v, id_excl, RANGE_EXCL(range));
+ rb_ivar_set(v, id_beg, RANGE_BEG(range));
+ rb_ivar_set(v, id_end, RANGE_END(range));
+ return v;
+}
+
+static VALUE
+range_loader(VALUE range, VALUE obj)
+{
+ if (TYPE(obj) != T_OBJECT || RBASIC(obj)->klass != rb_cObject) {
+ rb_raise(rb_eTypeError, "not a dumped range object");
+ }
+
+ RSTRUCT(range)->as.ary[0] = rb_ivar_get(obj, id_beg);
+ RSTRUCT(range)->as.ary[1] = rb_ivar_get(obj, id_end);
+ RSTRUCT(range)->as.ary[2] = rb_ivar_get(obj, id_excl);
+ return range;
+}
+
+static VALUE
+range_alloc(VALUE klass)
+{
+ /* rb_struct_alloc_noinit itself should not be used because
+ * rb_marshal_define_compat uses equality of allocaiton function */
+ return rb_struct_alloc_noinit(klass);
+}
+
+/* A <code>Range</code> represents an interval---a set of values with a
+ * start and an end. Ranges may be constructed using the
+ * <em>s</em><code>..</code><em>e</em> and
+ * <em>s</em><code>...</code><em>e</em> literals, or with
+ * <code>Range::new</code>. Ranges constructed using <code>..</code>
+ * run from the start to the end inclusively. Those created using
+ * <code>...</code> exclude the end value. When used as an iterator,
+ * ranges return each value in the sequence.
+ *
+ * (-1..-5).to_a #=> []
+ * (-5..-1).to_a #=> [-5, -4, -3, -2, -1]
+ * ('a'..'e').to_a #=> ["a", "b", "c", "d", "e"]
+ * ('a'...'e').to_a #=> ["a", "b", "c", "d"]
+ *
+ * Ranges can be constructed using objects of any type, as long as the
+ * objects can be compared using their <code><=></code> operator and
+ * they support the <code>succ</code> method to return the next object
+ * in sequence.
+ *
+ * class Xs # represent a string of 'x's
+ * include Comparable
+ * attr :length
+ * def initialize(n)
+ * @length = n
+ * end
+ * def succ
+ * Xs.new(@length + 1)
+ * end
+ * def <=>(other)
+ * @length <=> other.length
+ * end
+ * def to_s
+ * sprintf "%2d #{inspect}", @length
+ * end
+ * def inspect
+ * 'x' * @length
+ * end
+ * end
+ *
+ * r = Xs.new(3)..Xs.new(6) #=> xxx..xxxxxx
+ * r.to_a #=> [xxx, xxxx, xxxxx, xxxxxx]
+ * r.member?(Xs.new(5)) #=> true
+ *
+ * In the previous code example, class <code>Xs</code> includes the
+ * <code>Comparable</code> module. This is because
+ * <code>Enumerable#member?</code> checks for equality using
+ * <code>==</code>. Including <code>Comparable</code> ensures that the
+ * <code>==</code> method is defined in terms of the <code><=></code>
+ * method implemented in <code>Xs</code>.
+ *
+ */
+
+void
+Init_Range(void)
+{
+#undef rb_intern
+#define rb_intern(str) rb_intern_const(str)
+
+ id_cmp = rb_intern("<=>");
+ id_succ = rb_intern("succ");
+ id_beg = rb_intern("begin");
+ id_end = rb_intern("end");
+ id_excl = rb_intern("excl");
+
+ rb_cRange = rb_struct_define_without_accessor(
+ "Range", rb_cObject, range_alloc,
+ "begin", "end", "excl", NULL);
+
+ rb_include_module(rb_cRange, rb_mEnumerable);
+ rb_marshal_define_compat(rb_cRange, rb_cObject, range_dumper, range_loader);
+ rb_define_method(rb_cRange, "initialize", range_initialize, -1);
+ rb_define_method(rb_cRange, "initialize_copy", range_initialize_copy, 1);
+ rb_define_method(rb_cRange, "==", range_eq, 1);
+ rb_define_method(rb_cRange, "===", range_eqq, 1);
+ rb_define_method(rb_cRange, "eql?", range_eql, 1);
+ rb_define_method(rb_cRange, "hash", range_hash, 0);
+ rb_define_method(rb_cRange, "each", range_each, 0);
+ rb_define_method(rb_cRange, "step", range_step, -1);
+ rb_define_method(rb_cRange, "begin", range_begin, 0);
+ rb_define_method(rb_cRange, "end", range_end, 0);
+ rb_define_method(rb_cRange, "first", range_first, -1);
+ rb_define_method(rb_cRange, "last", range_last, -1);
+ rb_define_method(rb_cRange, "min", range_min, 0);
+ rb_define_method(rb_cRange, "max", range_max, 0);
+ rb_define_method(rb_cRange, "to_s", range_to_s, 0);
+ rb_define_method(rb_cRange, "inspect", range_inspect, 0);
+
+ rb_define_method(rb_cRange, "exclude_end?", range_exclude_end_p, 0);
+
+ rb_define_method(rb_cRange, "member?", range_include, 1);
+ rb_define_method(rb_cRange, "include?", range_include, 1);
+ rb_define_method(rb_cRange, "cover?", range_cover, 1);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 17:38:00 +0000