2000-05-01 13:42:38 +04:00
|
|
|
/**********************************************************************
|
1998-01-16 15:13:05 +03:00
|
|
|
|
|
|
|
range.c -
|
|
|
|
|
|
|
|
$Author$
|
|
|
|
created at: Thu Aug 19 17:46:47 JST 1993
|
|
|
|
|
* encoding.c: provide basic features for M17N.
* parse.y: encoding aware parsing.
* parse.y (pragma_encoding): encoding specification pragma.
* parse.y (rb_intern3): encoding specified symbols.
* string.c (rb_str_length): length based on characters.
for older behavior, bytesize method added.
* string.c (rb_str_index_m): index based on characters. rindex as
well.
* string.c (succ_char): encoding aware succeeding string.
* string.c (rb_str_reverse): reverse based on characters.
* string.c (rb_str_inspect): encoding aware string description.
* string.c (rb_str_upcase_bang): encoding aware case conversion.
downcase, capitalize, swapcase as well.
* string.c (rb_str_tr_bang): tr based on characters. delete,
squeeze, tr_s, count as well.
* string.c (rb_str_split_m): split based on characters.
* string.c (rb_str_each_line): encoding aware each_line.
* string.c (rb_str_each_char): added. iteration based on
characters.
* string.c (rb_str_strip_bang): encoding aware whitespace
stripping. lstrip, rstrip as well.
* string.c (rb_str_justify): encoding aware justifying (ljust,
rjust, center).
* string.c (str_encoding): get encoding attribute from a string.
* re.c (rb_reg_initialize): encoding aware regular expression
* sprintf.c (rb_str_format): formatting (i.e. length count) based
on characters.
* io.c (rb_io_getc): getc to return one-character string.
for older behavior, getbyte method added.
* ext/stringio/stringio.c (strio_getc): ditto.
* io.c (rb_io_ungetc): allow pushing arbitrary string at the
current reading point.
* ext/stringio/stringio.c (strio_ungetc): ditto.
* ext/strscan/strscan.c: encoding support.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13261 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-08-25 07:29:39 +04:00
|
|
|
Copyright (C) 1993-2007 Yukihiro Matsumoto
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2000-05-01 13:42:38 +04:00
|
|
|
**********************************************************************/
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2007-06-10 07:06:15 +04:00
|
|
|
#include "ruby/ruby.h"
|
2008-02-11 20:46:52 +03:00
|
|
|
#include "ruby/encoding.h"
|
* internal.h: declare internal functions here.
* node.h: declare NODE dependent internal functions here.
* iseq.h: declare rb_iseq_t dependent internal functions here.
* vm_core.h: declare rb_thread_t dependent internal functions here.
* bignum.c, class.c, compile.c, complex.c, cont.c, dir.c, encoding.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c, io.c,
iseq.c, load.c, marshal.c, math.c, numeric.c, object.c, parse.y,
proc.c, process.c, range.c, rational.c, re.c, ruby.c, string.c,
thread.c, time.c, transcode.c, variable.c, vm.c,
tool/compile_prelude.rb: don't declare internal functions declared
in above headers. include above headers if required.
Note that rb_thread_mark() was declared as
void rb_thread_mark(rb_thread_t *th) in cont.c but defined as
void rb_thread_mark(void *ptr) in vm.c. Now it is declared as
the later in internal.h.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@32156 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2011-06-18 02:43:38 +04:00
|
|
|
#include "internal.h"
|
2012-12-02 13:57:47 +04:00
|
|
|
#include "id.h"
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2012-11-14 19:53:50 +04:00
|
|
|
#ifdef HAVE_FLOAT_H
|
|
|
|
#include <float.h>
|
|
|
|
#endif
|
|
|
|
#include <math.h>
|
|
|
|
|
1999-01-20 07:59:39 +03:00
|
|
|
VALUE rb_cRange;
|
2001-05-30 13:12:34 +04:00
|
|
|
static ID id_cmp, id_succ, id_beg, id_end, id_excl;
|
1999-08-13 09:45:20 +04:00
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
#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)
|
|
|
|
|
1999-01-20 07:59:39 +03:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_failed(void)
|
1999-01-20 07:59:39 +03:00
|
|
|
{
|
2003-04-18 22:05:11 +04:00
|
|
|
rb_raise(rb_eArgError, "bad value for range");
|
|
|
|
return Qnil; /* dummy */
|
1999-01-20 07:59:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_check(VALUE *args)
|
1999-01-20 07:59:39 +03:00
|
|
|
{
|
2005-08-14 19:39:39 +04:00
|
|
|
return rb_funcall(args[0], id_cmp, 1, args[1]);
|
1999-01-20 07:59:39 +03:00
|
|
|
}
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2000-02-29 11:05:32 +03:00
|
|
|
static void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_init(VALUE range, VALUE beg, VALUE end, int exclude_end)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
1999-08-13 09:45:20 +04:00
|
|
|
VALUE args[2];
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2002-07-30 14:22:32 +04:00
|
|
|
args[0] = beg;
|
|
|
|
args[1] = end;
|
2009-02-22 17:23:33 +03:00
|
|
|
|
1999-01-20 07:59:39 +03:00
|
|
|
if (!FIXNUM_P(beg) || !FIXNUM_P(end)) {
|
2005-08-14 19:39:39 +04:00
|
|
|
VALUE v;
|
|
|
|
|
|
|
|
v = rb_rescue(range_check, (VALUE)args, range_failed, 0);
|
2006-12-31 18:02:22 +03:00
|
|
|
if (NIL_P(v))
|
|
|
|
range_failed();
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2002-06-11 11:02:23 +04:00
|
|
|
SET_EXCL(range, exclude_end);
|
2007-09-08 19:07:18 +04:00
|
|
|
RSTRUCT(range)->as.ary[0] = beg;
|
|
|
|
RSTRUCT(range)->as.ary[1] = end;
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
rb_range_new(VALUE beg, VALUE end, int exclude_end)
|
1999-08-13 09:45:20 +04:00
|
|
|
{
|
2002-06-11 11:02:23 +04:00
|
|
|
VALUE range = rb_obj_alloc(rb_cRange);
|
2000-02-29 11:05:32 +03:00
|
|
|
|
2002-06-11 11:02:23 +04:00
|
|
|
range_init(range, beg, end, exclude_end);
|
|
|
|
return range;
|
1999-08-13 09:45:20 +04:00
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-12-06 03:36:53 +04:00
|
|
|
* Range.new(begin, end, exclude_end=false) -> rng
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Constructs a range using the given +begin+ and +end+. If the +exclude_end+
|
|
|
|
* parameter is omitted or is <code>false</code>, the +rng+ will include
|
2003-12-24 07:29:32 +03:00
|
|
|
* the end object; otherwise, it will be excluded.
|
|
|
|
*/
|
|
|
|
|
1999-08-13 09:45:20 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_initialize(int argc, VALUE *argv, VALUE range)
|
1999-08-13 09:45:20 +04:00
|
|
|
{
|
2001-02-02 14:38:20 +03:00
|
|
|
VALUE beg, end, flags;
|
2009-02-22 17:23:33 +03:00
|
|
|
|
2001-02-02 14:38:20 +03:00
|
|
|
rb_scan_args(argc, argv, "21", &beg, &end, &flags);
|
2000-02-29 11:05:32 +03:00
|
|
|
/* Ranges are immutable, so that they should be initialized only once. */
|
2007-09-10 10:25:40 +04:00
|
|
|
if (RANGE_EXCL(range) != Qnil) {
|
2012-12-02 13:57:47 +04:00
|
|
|
rb_name_error(idInitialize, "`initialize' called twice");
|
2000-02-29 11:05:32 +03:00
|
|
|
}
|
2002-06-11 11:02:23 +04:00
|
|
|
range_init(range, beg, end, RTEST(flags));
|
2000-02-29 11:05:32 +03:00
|
|
|
return Qnil;
|
1999-08-13 09:45:20 +04:00
|
|
|
}
|
|
|
|
|
2008-08-21 01:02:54 +04:00
|
|
|
#define range_initialize_copy rb_struct_init_copy /* :nodoc: */
|
2003-12-24 07:29:32 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.exclude_end? -> true or false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns <code>true</code> if the range excludes its end value.
|
|
|
|
*
|
|
|
|
* (1..5).exclude_end? #=> false
|
|
|
|
* (1...5).exclude_end? #=> true
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
1999-08-13 09:45:20 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_exclude_end_p(VALUE range)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2002-07-30 14:22:32 +04:00
|
|
|
return EXCL(range) ? Qtrue : Qfalse;
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2009-09-20 06:14:02 +04:00
|
|
|
static VALUE
|
|
|
|
recursive_equal(VALUE range, VALUE obj, int recur)
|
|
|
|
{
|
|
|
|
if (recur) return Qtrue; /* Subtle! */
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng == obj -> true or false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns <code>true</code> only if +obj+ is a Range, has equivalent
|
|
|
|
* begin and end items (by comparing them with <code>==</code>), and has
|
|
|
|
* the same #exclude_end? setting as the range.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* (0..2) == (0..2) #=> true
|
|
|
|
* (0..2) == Range.new(0,2) #=> true
|
|
|
|
* (0..2) == (0...2) #=> false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
2000-11-27 12:23:38 +03:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_eq(VALUE range, VALUE obj)
|
2000-11-27 12:23:38 +03:00
|
|
|
{
|
2006-12-31 18:02:22 +03:00
|
|
|
if (range == obj)
|
|
|
|
return Qtrue;
|
2009-08-05 09:01:12 +04:00
|
|
|
if (!rb_obj_is_kind_of(obj, rb_cRange))
|
2002-09-03 09:20:14 +04:00
|
|
|
return Qfalse;
|
2000-11-27 12:23:38 +03:00
|
|
|
|
2009-09-20 06:14:02 +04:00
|
|
|
return rb_exec_recursive_paired(recursive_equal, range, obj, obj);
|
2000-11-27 12:23:38 +03:00
|
|
|
}
|
|
|
|
|
2001-05-30 13:12:34 +04:00
|
|
|
static int
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
r_lt(VALUE a, VALUE b)
|
2001-05-30 13:12:34 +04:00
|
|
|
{
|
|
|
|
VALUE r = rb_funcall(a, id_cmp, 1, b);
|
|
|
|
|
2006-12-31 18:02:22 +03:00
|
|
|
if (NIL_P(r))
|
2009-09-23 07:39:44 +04:00
|
|
|
return (int)Qfalse;
|
2006-12-31 18:02:22 +03:00
|
|
|
if (rb_cmpint(r, a, b) < 0)
|
2009-09-23 07:39:44 +04:00
|
|
|
return (int)Qtrue;
|
|
|
|
return (int)Qfalse;
|
2001-05-30 13:12:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
r_le(VALUE a, VALUE b)
|
2001-05-30 13:12:34 +04:00
|
|
|
{
|
2004-05-14 20:39:15 +04:00
|
|
|
int c;
|
2001-05-30 13:12:34 +04:00
|
|
|
VALUE r = rb_funcall(a, id_cmp, 1, b);
|
|
|
|
|
2006-12-31 18:02:22 +03:00
|
|
|
if (NIL_P(r))
|
2009-09-23 07:39:44 +04:00
|
|
|
return (int)Qfalse;
|
2004-05-14 20:39:15 +04:00
|
|
|
c = rb_cmpint(r, a, b);
|
2006-12-31 18:02:22 +03:00
|
|
|
if (c == 0)
|
2009-05-07 09:01:56 +04:00
|
|
|
return (int)INT2FIX(0);
|
2006-12-31 18:02:22 +03:00
|
|
|
if (c < 0)
|
2009-09-23 07:39:44 +04:00
|
|
|
return (int)Qtrue;
|
|
|
|
return (int)Qfalse;
|
2001-05-30 13:12:34 +04:00
|
|
|
}
|
|
|
|
|
2002-12-19 12:20:20 +03:00
|
|
|
|
2009-09-20 06:14:02 +04:00
|
|
|
static VALUE
|
|
|
|
recursive_eql(VALUE range, VALUE obj, int recur)
|
|
|
|
{
|
|
|
|
if (recur) return Qtrue; /* Subtle! */
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.eql?(obj) -> true or false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns <code>true</code> only if +obj+ is a Range, has equivalent
|
|
|
|
* begin and end items (by comparing them with <code>eql?</code>),
|
|
|
|
* and has the same #exclude_end? setting as the range.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2009-05-07 08:58:54 +04:00
|
|
|
* (0..2).eql?(0..2) #=> true
|
|
|
|
* (0..2).eql?(Range.new(0,2)) #=> true
|
|
|
|
* (0..2).eql?(0...2) #=> false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
2001-11-08 12:21:59 +03:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_eql(VALUE range, VALUE obj)
|
2001-11-08 12:21:59 +03:00
|
|
|
{
|
2006-12-31 18:02:22 +03:00
|
|
|
if (range == obj)
|
|
|
|
return Qtrue;
|
2009-08-05 09:01:12 +04:00
|
|
|
if (!rb_obj_is_kind_of(obj, rb_cRange))
|
2002-09-03 09:20:14 +04:00
|
|
|
return Qfalse;
|
2009-09-20 06:14:02 +04:00
|
|
|
return rb_exec_recursive_paired(recursive_eql, range, obj, obj);
|
2001-11-08 12:21:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2009-07-17 13:28:46 +04:00
|
|
|
recursive_hash(VALUE range, VALUE dummy, int recur)
|
2001-11-08 12:21:59 +03:00
|
|
|
{
|
2009-09-08 17:10:04 +04:00
|
|
|
st_index_t hash = EXCL(range);
|
2001-11-08 12:21:59 +03:00
|
|
|
VALUE v;
|
|
|
|
|
* string.c (rb_hash_uint32, rb_hash_uint, rb_hash_start, rb_hash_end),
include/ruby/intern.h: add Murmurhash API. [ruby-dev:37784]
* complex.c (nucomp_hash), array.c (rb_ary_hash), time.c (time_hash),
string.c (rb_str_hsah), object.c (rb_obj_hash), range.c
(range_hash), struct.c (rb_struct_hash), hash.c (rb_any_hash),
rational.c (nurat_hash): use Murmurhash. [ruby-dev:37784]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22317 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-02-14 22:55:34 +03:00
|
|
|
hash = rb_hash_start(hash);
|
2009-09-16 01:30:50 +04:00
|
|
|
if (!recur) {
|
|
|
|
v = rb_hash(RANGE_BEG(range));
|
|
|
|
hash = rb_hash_uint(hash, NUM2LONG(v));
|
|
|
|
v = rb_hash(RANGE_END(range));
|
|
|
|
hash = rb_hash_uint(hash, NUM2LONG(v));
|
|
|
|
}
|
* string.c (rb_hash_uint32, rb_hash_uint, rb_hash_start, rb_hash_end),
include/ruby/intern.h: add Murmurhash API. [ruby-dev:37784]
* complex.c (nucomp_hash), array.c (rb_ary_hash), time.c (time_hash),
string.c (rb_str_hsah), object.c (rb_obj_hash), range.c
(range_hash), struct.c (rb_struct_hash), hash.c (rb_any_hash),
rational.c (nurat_hash): use Murmurhash. [ruby-dev:37784]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22317 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2009-02-14 22:55:34 +03:00
|
|
|
hash = rb_hash_uint(hash, EXCL(range) << 24);
|
|
|
|
hash = rb_hash_end(hash);
|
2001-11-08 12:21:59 +03:00
|
|
|
|
2002-07-30 14:22:32 +04:00
|
|
|
return LONG2FIX(hash);
|
2001-11-08 12:21:59 +03:00
|
|
|
}
|
|
|
|
|
2009-07-17 13:28:46 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.hash -> fixnum
|
2009-07-17 13:28:46 +04:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Compute a hash-code for this range. Two ranges with equal
|
|
|
|
* begin and end points (using <code>eql?</code>), and the same
|
|
|
|
* #exclude_end? value will generate the same hash-code.
|
2009-07-17 13:28:46 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_hash(VALUE range)
|
|
|
|
{
|
2009-09-16 01:30:50 +04:00
|
|
|
return rb_exec_recursive_outer(recursive_hash, range, 0);
|
2009-07-17 13:28:46 +04:00
|
|
|
}
|
|
|
|
|
2002-05-30 10:12:29 +04:00
|
|
|
static void
|
2008-04-06 21:11:50 +04:00
|
|
|
range_each_func(VALUE range, VALUE (*func) (VALUE, void *), void *arg)
|
2002-05-30 10:12:29 +04:00
|
|
|
{
|
2004-05-14 20:39:15 +04:00
|
|
|
int c;
|
2008-04-06 21:11:50 +04:00
|
|
|
VALUE b = RANGE_BEG(range);
|
|
|
|
VALUE e = RANGE_END(range);
|
2008-04-07 07:15:26 +04:00
|
|
|
VALUE v = b;
|
2004-05-14 20:39:15 +04:00
|
|
|
|
2002-05-30 10:12:29 +04:00
|
|
|
if (EXCL(range)) {
|
|
|
|
while (r_lt(v, e)) {
|
2006-12-31 18:02:22 +03:00
|
|
|
(*func) (v, arg);
|
2002-05-30 10:12:29 +04:00
|
|
|
v = rb_funcall(v, id_succ, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2009-05-07 09:01:56 +04:00
|
|
|
while ((c = r_le(v, e)) != Qfalse) {
|
2006-12-31 18:02:22 +03:00
|
|
|
(*func) (v, arg);
|
2009-05-07 09:01:56 +04:00
|
|
|
if (c == (int)INT2FIX(0))
|
2006-12-31 18:02:22 +03:00
|
|
|
break;
|
2002-05-30 10:12:29 +04:00
|
|
|
v = rb_funcall(v, id_succ, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-17 21:00:47 +04:00
|
|
|
static VALUE
|
|
|
|
sym_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(rb_str_intern(i));
|
|
|
|
iter[0] = iter[1];
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2004-10-06 11:40:06 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
step_i(VALUE i, void *arg)
|
2004-10-06 11:40:06 +04:00
|
|
|
{
|
2007-12-05 09:15:23 +03:00
|
|
|
VALUE *iter = arg;
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
|
2007-12-05 09:15:23 +03:00
|
|
|
if (FIXNUM_P(iter[0])) {
|
|
|
|
iter[0] -= INT2FIX(1) & ~FIXNUM_FLAG;
|
|
|
|
}
|
|
|
|
else {
|
2008-01-29 16:27:51 +03:00
|
|
|
iter[0] = rb_funcall(iter[0], '-', 1, INT2FIX(1));
|
2007-12-05 09:15:23 +03:00
|
|
|
}
|
|
|
|
if (iter[0] == INT2FIX(0)) {
|
2004-10-06 11:40:06 +04:00
|
|
|
rb_yield(i);
|
|
|
|
iter[0] = iter[1];
|
|
|
|
}
|
2004-10-19 14:25:23 +04:00
|
|
|
return Qnil;
|
2004-10-06 11:40:06 +04:00
|
|
|
}
|
|
|
|
|
2009-09-30 12:32:43 +04:00
|
|
|
static int
|
2009-10-02 19:31:05 +04:00
|
|
|
discrete_object_p(VALUE obj)
|
2009-09-30 12:32:43 +04:00
|
|
|
{
|
2009-10-02 19:31:05 +04:00
|
|
|
if (rb_obj_is_kind_of(obj, rb_cTime)) return FALSE; /* until Time#succ removed */
|
|
|
|
return rb_respond_to(obj, id_succ);
|
2009-09-30 12:32:43 +04:00
|
|
|
}
|
|
|
|
|
2012-11-06 21:15:00 +04:00
|
|
|
static VALUE
|
|
|
|
range_step_size(VALUE range, VALUE args)
|
|
|
|
{
|
|
|
|
VALUE b = RANGE_BEG(range), e = RANGE_END(range);
|
|
|
|
VALUE step = INT2FIX(1);
|
|
|
|
if (args) {
|
|
|
|
step = RARRAY_PTR(args)[0];
|
|
|
|
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 (rb_obj_is_kind_of(b, rb_cNumeric) && rb_obj_is_kind_of(e, rb_cNumeric)) {
|
|
|
|
return num_interval_step_size(b, e, step, EXCL(range));
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
2009-09-30 12:32:43 +04:00
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.step(n=1) {| obj | block } -> rng
|
|
|
|
* rng.step(n=1) -> an_enumerator
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Iterates over the range, passing each <code>n</code>th element to the block.
|
|
|
|
* If begin and end are numeric, +n+ is added for each iteration.
|
|
|
|
* Otherwise <code>step</code> invokes <code>succ</code> to iterate through
|
|
|
|
* range elements.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2010-05-13 09:49:55 +04:00
|
|
|
* If no block is given, an enumerator is returned instead.
|
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* range = Xs.new(1)..Xs.new(10)
|
|
|
|
* range.step(2) {|x| puts x}
|
|
|
|
* puts
|
|
|
|
* range.step(3) {|x| puts x}
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* <em>produces:</em>
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* 1 x
|
|
|
|
* 3 xxx
|
|
|
|
* 5 xxxxx
|
|
|
|
* 7 xxxxxxx
|
|
|
|
* 9 xxxxxxxxx
|
|
|
|
*
|
|
|
|
* 1 x
|
|
|
|
* 4 xxxx
|
|
|
|
* 7 xxxxxxx
|
|
|
|
* 10 xxxxxxxxxx
|
|
|
|
*
|
|
|
|
* See Range for the definition of class Xs.
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
2001-08-14 12:13:31 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_step(int argc, VALUE *argv, VALUE range)
|
2001-08-14 12:13:31 +04:00
|
|
|
{
|
2008-04-07 07:15:26 +04:00
|
|
|
VALUE b, e, step, tmp;
|
2001-08-14 12:13:31 +04:00
|
|
|
|
2012-11-06 21:15:00 +04:00
|
|
|
RETURN_SIZED_ENUMERATOR(range, argc, argv, range_step_size);
|
2005-08-30 18:49:51 +04:00
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
b = RANGE_BEG(range);
|
|
|
|
e = RANGE_END(range);
|
2008-03-05 08:22:17 +03:00
|
|
|
if (argc == 0) {
|
2002-05-01 13:41:50 +04:00
|
|
|
step = INT2FIX(1);
|
2007-12-05 09:15:23 +03:00
|
|
|
}
|
|
|
|
else {
|
2008-03-05 08:22:17 +03:00
|
|
|
rb_scan_args(argc, argv, "01", &step);
|
2008-05-02 12:31:04 +04:00
|
|
|
if (!rb_obj_is_kind_of(step, rb_cNumeric)) {
|
|
|
|
step = rb_to_int(step);
|
|
|
|
}
|
2008-05-02 11:15:28 +04:00
|
|
|
if (rb_funcall(step, '<', 1, INT2FIX(0))) {
|
|
|
|
rb_raise(rb_eArgError, "step can't be negative");
|
2008-03-05 08:22:17 +03:00
|
|
|
}
|
2008-05-02 11:15:28 +04:00
|
|
|
else if (!rb_funcall(step, '>', 1, INT2FIX(0))) {
|
|
|
|
rb_raise(rb_eArgError, "step can't be 0");
|
2008-03-05 08:22:17 +03:00
|
|
|
}
|
2002-05-01 13:41:50 +04:00
|
|
|
}
|
2008-04-06 21:11:50 +04:00
|
|
|
|
2007-12-05 09:15:23 +03:00
|
|
|
if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
|
2002-05-30 10:12:29 +04:00
|
|
|
long end = FIX2LONG(e);
|
2008-05-02 11:15:28 +04:00
|
|
|
long i, unit = FIX2LONG(step);
|
2002-05-30 10:12:29 +04:00
|
|
|
|
2006-12-31 18:02:22 +03:00
|
|
|
if (!EXCL(range))
|
|
|
|
end += 1;
|
2009-02-22 17:23:33 +03:00
|
|
|
i = FIX2LONG(b);
|
2007-09-09 20:11:28 +04:00
|
|
|
while (i < end) {
|
2002-08-21 19:47:54 +04:00
|
|
|
rb_yield(LONG2NUM(i));
|
2007-09-09 20:11:28 +04:00
|
|
|
if (i + unit < i) break;
|
|
|
|
i += unit;
|
2001-08-14 12:13:31 +04:00
|
|
|
}
|
2008-04-06 21:11:50 +04:00
|
|
|
|
|
|
|
}
|
2009-08-17 21:00:47 +04:00
|
|
|
else if (SYMBOL_P(b) && SYMBOL_P(e)) { /* symbols are special */
|
|
|
|
VALUE args[2], iter[2];
|
|
|
|
|
|
|
|
args[0] = rb_sym_to_s(e);
|
|
|
|
args[1] = EXCL(range) ? Qtrue : Qfalse;
|
|
|
|
iter[0] = INT2FIX(1);
|
|
|
|
iter[1] = step;
|
|
|
|
rb_block_call(rb_sym_to_s(b), rb_intern("upto"), 2, args, sym_step_i, (VALUE)iter);
|
|
|
|
}
|
2009-01-04 05:58:45 +03:00
|
|
|
else if (ruby_float_step(b, e, step, EXCL(range))) {
|
|
|
|
/* done */
|
|
|
|
}
|
2008-04-06 21:11:50 +04:00
|
|
|
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"))) {
|
2012-12-02 13:57:47 +04:00
|
|
|
ID op = EXCL(range) ? '<' : idLE;
|
2009-01-05 02:20:39 +03:00
|
|
|
VALUE v = b;
|
|
|
|
int i = 0;
|
2008-04-06 21:11:50 +04:00
|
|
|
|
2009-01-05 02:20:39 +03:00
|
|
|
while (RTEST(rb_funcall(v, op, 1, e))) {
|
|
|
|
rb_yield(v);
|
|
|
|
i++;
|
|
|
|
v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 1, step));
|
2008-04-06 21:11:50 +04:00
|
|
|
}
|
2001-08-14 12:13:31 +04:00
|
|
|
}
|
2002-05-30 10:12:29 +04:00
|
|
|
else {
|
2008-04-06 21:11:50 +04:00
|
|
|
tmp = rb_check_string_type(b);
|
2001-08-14 12:13:31 +04:00
|
|
|
|
2003-06-07 19:34:31 +04:00
|
|
|
if (!NIL_P(tmp)) {
|
2007-12-05 09:15:23 +03:00
|
|
|
VALUE args[2], iter[2];
|
2003-06-07 19:34:31 +04:00
|
|
|
|
|
|
|
b = tmp;
|
2007-06-22 20:23:16 +04:00
|
|
|
args[0] = e;
|
|
|
|
args[1] = EXCL(range) ? Qtrue : Qfalse;
|
2007-12-05 09:15:23 +03:00
|
|
|
iter[0] = INT2FIX(1);
|
|
|
|
iter[1] = step;
|
2007-06-22 20:23:16 +04:00
|
|
|
rb_block_call(b, rb_intern("upto"), 2, args, step_i, (VALUE)iter);
|
2003-06-07 19:34:31 +04:00
|
|
|
}
|
|
|
|
else {
|
2007-12-05 09:15:23 +03:00
|
|
|
VALUE args[2];
|
2003-06-07 19:34:31 +04:00
|
|
|
|
2009-09-30 12:32:43 +04:00
|
|
|
if (!discrete_object_p(b)) {
|
* array.c: replace rb_protect_inspect() and rb_inspecting_p() by
rb_exec_recursive() in eval.c.
* eval.c (rb_exec_recursive): new function.
* array.c (rb_ary_join): use rb_exec_recursive().
* array.c (rb_ary_inspect, rb_ary_hash): ditto.
* file.c (rb_file_join): ditto.
* hash.c (rb_hash_inspect, rb_hash_to_s, rb_hash_hash): ditto.
* io.c (rb_io_puts): ditto.
* object.c (rb_obj_inspect): ditto
* struct.c (rb_struct_inspect): ditto.
* lib/set.rb (SortedSet::setup): a hack to shut up warning.
[ruby-talk:132866]
* lib/time.rb (Time::strptime): add new function. inspired by
[ruby-talk:132815].
* lib/parsedate.rb (ParseDate::strptime): ditto.
* regparse.c: move st_*_strend() functions from st.c. fixed some
potential memory leaks.
* exception error messages updated. [ruby-core:04497]
* ext/socket/socket.c (Init_socket): add bunch of Socket
constants. Patch from Sam Roberts <sroberts@uniserve.com>.
[ruby-core:04409]
* array.c (rb_ary_s_create): no need for negative argc check.
[ruby-core:04463]
* array.c (rb_ary_unshift_m): ditto.
* lib/xmlrpc/parser.rb (XMLRPC::FaultException): make it subclass
of StandardError class, not Exception class. [ruby-core:04429]
* parse.y (fcall_gen): lvar(arg) will be evaluated as
lvar.call(arg) when lvar is a defined local variable. [new]
* object.c (rb_class_initialize): call inherited method before
calling initializing block.
* eval.c (rb_thread_start_1): initialize newly pushed frame.
* lib/open3.rb (Open3::popen3): $? should not be EXIT_FAILURE.
fixed: [ruby-core:04444]
* eval.c (is_defined): NODE_IASGN is an assignment.
* ext/readline/readline.c (Readline.readline): use rl_outstream
and rl_instream. [ruby-dev:25699]
* ext/etc/etc.c (Init_etc): sGroup needs HAVE_ST_GR_PASSWD check
[ruby-dev:25675]
* misc/ruby-mode.el: [ruby-core:04415]
* lib/rdoc/generators/html_generator.rb: [ruby-core:04412]
* lib/rdoc/generators/ri_generator.rb: ditto.
* struct.c (make_struct): fixed: [ruby-core:04402]
* ext/curses/curses.c (window_color_set): [ruby-core:04393]
* ext/socket/socket.c (Init_socket): SO_REUSEPORT added.
[ruby-talk:130092]
* object.c: [ruby-doc:818]
* parse.y (open_args): fix too verbose warnings for the space
before argument parentheses. [ruby-dev:25492]
* parse.y (parser_yylex): ditto.
* parse.y (parser_yylex): the first expression in the parentheses
should not be a command. [ruby-dev:25492]
* lib/irb/context.rb (IRB::Context::initialize): [ruby-core:04330]
* object.c (Init_Object): remove Object#type. [ruby-core:04335]
* st.c (st_foreach): report success/failure by return value.
[ruby-Bugs-1396]
* parse.y: forgot to initialize parser struct. [ruby-dev:25492]
* parse.y (parser_yylex): no tLABEL on EXPR_BEG.
[ruby-talk:127711]
* document updates - [ruby-core:04296], [ruby-core:04301],
[ruby-core:04302], [ruby-core:04307]
* dir.c (rb_push_glob): should work for NUL delimited patterns.
* dir.c (rb_glob2): should aware of offset in the pattern.
* string.c (rb_str_new4): should propagate taintedness.
* env.h: rename member names in struct FRAME; last_func -> callee,
orig_func -> this_func, last_class -> this_class.
* struct.c (rb_struct_set): use original method name, not callee
name, to retrieve member slot. [ruby-core:04268]
* time.c (time_strftime): protect from format modification from GC
finalizers.
* object.c (Init_Object): remove rb_obj_id_obsolete()
* eval.c (rb_mod_define_method): incomplete subclass check.
[ruby-dev:25464]
* gc.c (rb_data_object_alloc): klass may be NULL.
[ruby-list:40498]
* bignum.c (rb_big_rand): should return positive random number.
[ruby-dev:25401]
* bignum.c (rb_big_rand): do not use rb_big_modulo to generate
random bignums. [ruby-dev:25396]
* variable.c (rb_autoload): [ruby-dev:25373]
* eval.c (svalue_to_avalue): [ruby-dev:25366]
* string.c (rb_str_justify): [ruby-dev:25367]
* io.c (rb_f_select): [ruby-dev:25312]
* ext/socket/socket.c (sock_s_getservbyport): [ruby-talk:124072]
* struct.c (make_struct): [ruby-dev:25249]
* dir.c (dir_open_dir): new function. [ruby-dev:25242]
* io.c (rb_f_open): add type check for return value from to_open.
* lib/pstore.rb (PStore#transaction): Use the empty content when a
file is not found. [ruby-dev:24561]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@8068 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-03-04 09:47:45 +03:00
|
|
|
rb_raise(rb_eTypeError, "can't iterate from %s",
|
2003-06-07 19:34:31 +04:00
|
|
|
rb_obj_classname(b));
|
|
|
|
}
|
2007-12-05 09:15:23 +03:00
|
|
|
args[0] = INT2FIX(1);
|
|
|
|
args[1] = step;
|
2008-04-06 21:11:50 +04:00
|
|
|
range_each_func(range, step_i, args);
|
2003-06-07 19:34:31 +04:00
|
|
|
}
|
2001-08-14 12:13:31 +04:00
|
|
|
}
|
|
|
|
return range;
|
|
|
|
}
|
|
|
|
|
2012-11-14 19:53:50 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* rng.bsearch {|obj| block } -> value
|
|
|
|
*
|
|
|
|
* By using binary search, finds a value in range which meets the given
|
2012-11-20 15:13:45 +04:00
|
|
|
* condition in O(log n) where n is the size of the array.
|
2012-11-14 19:53:50 +04:00
|
|
|
*
|
|
|
|
* You can use this method in two use cases: a find-minimum mode and
|
|
|
|
* a find-any mode. In either case, the elements of the array must be
|
|
|
|
* monotone (or sorted) with respect to the block.
|
|
|
|
*
|
|
|
|
* In find-minimum mode (this is a good choice for typical use case),
|
|
|
|
* the block must return true or false, and there must be a value x
|
|
|
|
* so that:
|
|
|
|
*
|
|
|
|
* - the block returns false for any value which is less than x, and
|
|
|
|
* - the block returns true for any value which is greater than or
|
|
|
|
* equal to i.
|
|
|
|
*
|
2012-11-29 06:58:31 +04:00
|
|
|
* If x is within the range, this method returns the value x.
|
2012-11-14 19:53:50 +04:00
|
|
|
* Otherwise, it returns nil.
|
|
|
|
*
|
|
|
|
* ary = [0, 4, 7, 10, 12]
|
|
|
|
* (0...ary.size).bsearch {|i| ary[i] >= 4 } #=> 1
|
|
|
|
* (0...ary.size).bsearch {|i| ary[i] >= 6 } #=> 2
|
|
|
|
* (0...ary.size).bsearch {|i| ary[i] >= 8 } #=> 3
|
|
|
|
* (0...ary.size).bsearch {|i| ary[i] >= 100 } #=> nil
|
|
|
|
*
|
|
|
|
* (0.0...Float::INFINITY).bsearch {|x| Math.log(x) >= 0 } #=> 1.0
|
|
|
|
*
|
|
|
|
* In find-any mode (this behaves like libc's bsearch(3)), the block
|
|
|
|
* must return a number, and there must be two values x and y (x <= y)
|
|
|
|
* so that:
|
|
|
|
*
|
|
|
|
* - the block returns a positive number for v if v < x,
|
|
|
|
* - the block returns zero for v if x <= v < y, and
|
|
|
|
* - the block returns a negative number for v if y <= v.
|
|
|
|
*
|
|
|
|
* This method returns any value which is within the intersection of
|
|
|
|
* the given range and x...y (if any). If there is no value that
|
|
|
|
* satisfies the condition, it returns nil.
|
|
|
|
*
|
|
|
|
* ary = [0, 100, 100, 100, 200]
|
2012-11-15 17:50:55 +04:00
|
|
|
* (0..4).bsearch {|i| 100 - ary[i] } #=> 1, 2 or 3
|
|
|
|
* (0..4).bsearch {|i| 300 - ary[i] } #=> nil
|
|
|
|
* (0..4).bsearch {|i| 50 - ary[i] } #=> nil
|
2012-11-14 19:53:50 +04:00
|
|
|
*
|
|
|
|
* You must not mix the two modes at a time; the block must always
|
|
|
|
* return either true/false, or always return a number. It is
|
|
|
|
* undefined which value is actually picked up at each iteration.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_bsearch(VALUE range)
|
|
|
|
{
|
|
|
|
VALUE beg, end;
|
|
|
|
int smaller, satisfied = 0;
|
|
|
|
|
|
|
|
#define BSEARCH_CHECK(val) \
|
|
|
|
do { \
|
|
|
|
VALUE v = rb_yield(val); \
|
|
|
|
if (FIXNUM_P(v)) { \
|
|
|
|
if (FIX2INT(v) == 0) return val; \
|
|
|
|
smaller = FIX2INT(v) < 0; \
|
|
|
|
} \
|
|
|
|
else if (v == Qtrue) { \
|
|
|
|
satisfied = 1; \
|
|
|
|
smaller = 1; \
|
|
|
|
} \
|
|
|
|
else if (v == Qfalse || v == Qnil) { \
|
|
|
|
smaller = 0; \
|
|
|
|
} \
|
|
|
|
else if (rb_obj_is_kind_of(v, rb_cNumeric)) { \
|
2012-11-16 11:28:30 +04:00
|
|
|
int cmp = rb_cmpint(rb_funcall(v, id_cmp, 1, INT2FIX(0)), v, INT2FIX(0)); \
|
|
|
|
if (!cmp) return val; \
|
|
|
|
smaller = cmp < 0; \
|
2012-11-14 19:53:50 +04:00
|
|
|
} \
|
|
|
|
else { \
|
|
|
|
smaller = RTEST(v); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
beg = RANGE_BEG(range);
|
|
|
|
end = RANGE_END(range);
|
|
|
|
|
|
|
|
if (FIXNUM_P(beg) && FIXNUM_P(end)) {
|
|
|
|
long low = FIX2LONG(beg);
|
|
|
|
long high = FIX2LONG(end);
|
|
|
|
long mid, org_high;
|
|
|
|
if (EXCL(range)) high--;
|
|
|
|
org_high = high;
|
|
|
|
|
|
|
|
while (low < high) {
|
|
|
|
mid = low + ((high - low) / 2);
|
|
|
|
BSEARCH_CHECK(INT2FIX(mid));
|
|
|
|
if (smaller) {
|
|
|
|
high = mid;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
low = mid + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (low == org_high) {
|
|
|
|
BSEARCH_CHECK(INT2FIX(low));
|
|
|
|
if (!smaller) return Qnil;
|
|
|
|
}
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
return INT2FIX(low);
|
|
|
|
}
|
|
|
|
else if (TYPE(beg) == T_FLOAT || TYPE(end) == T_FLOAT) {
|
|
|
|
double low = RFLOAT_VALUE(rb_Float(beg));
|
|
|
|
double high = RFLOAT_VALUE(rb_Float(end));
|
|
|
|
double mid, org_high;
|
|
|
|
int count;
|
2012-11-15 17:50:55 +04:00
|
|
|
org_high = high;
|
2012-11-14 19:53:50 +04:00
|
|
|
#ifdef FLT_RADIX
|
|
|
|
#ifdef DBL_MANT_DIG
|
|
|
|
#define BSEARCH_MAXCOUNT (((FLT_RADIX) - 1) * (DBL_MANT_DIG + DBL_MAX_EXP) + 100)
|
|
|
|
#else
|
|
|
|
#define BSEARCH_MAXCOUNT (53 + 1023 + 100)
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
#define BSEARCH_MAXCOUNT (53 + 1023 + 100)
|
|
|
|
#endif
|
|
|
|
if (isinf(high) && high > 0) {
|
|
|
|
/* the range is (low..INFINITY) */
|
|
|
|
double nhigh = 1.0, inc;
|
|
|
|
if (nhigh < low) nhigh = low;
|
|
|
|
count = BSEARCH_MAXCOUNT;
|
|
|
|
/* find upper bound by checking low, low*2, low*4, ... */
|
|
|
|
while (count >= 0 && !isinf(nhigh)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(nhigh));
|
|
|
|
if (smaller) break;
|
|
|
|
high = nhigh;
|
|
|
|
nhigh *= 2;
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
if (isinf(nhigh) || count < 0) {
|
|
|
|
/* upper bound not found; then, search in very near INFINITY */
|
|
|
|
/* (x..INFINITY where x is not INFINITY but x*2 is INFINITY) */
|
|
|
|
inc = high / 2;
|
|
|
|
count = BSEARCH_MAXCOUNT;
|
|
|
|
while (count >= 0 && inc > 0) {
|
|
|
|
nhigh = high + inc;
|
|
|
|
if (!isinf(nhigh)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(nhigh));
|
|
|
|
if (smaller) {
|
|
|
|
/* upper bound found; */
|
|
|
|
/* the desired value is within high..nhigh */
|
|
|
|
low = high;
|
|
|
|
high = nhigh;
|
|
|
|
goto binsearch;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
high = nhigh;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
inc /= 2;
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
/* lower bound not found; */
|
|
|
|
/* there is no candidate except INFINITY itself */
|
|
|
|
high *= 2; /* generate INFINITY */
|
|
|
|
if (isinf(high) && !EXCL(range)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(high));
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
if (smaller) return DBL2NUM(high);
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
/* upper bound found; the desired value is within low..nhigh */
|
|
|
|
high = nhigh;
|
|
|
|
}
|
|
|
|
if (isinf(low) && low < 0) {
|
|
|
|
/* the range is (-INFINITY..high) */
|
2012-11-15 17:50:55 +04:00
|
|
|
volatile double nlow = -1.0, dec;
|
2012-11-14 19:53:50 +04:00
|
|
|
if (nlow > high) nlow = high;
|
|
|
|
count = BSEARCH_MAXCOUNT;
|
|
|
|
/* find lower bound by checking low, low*2, low*4, ... */
|
|
|
|
while (count >= 0 && !isinf(nlow)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(nlow));
|
|
|
|
if (!smaller) break;
|
|
|
|
low = nlow;
|
|
|
|
nlow *= 2;
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
if (isinf(nlow) || count < 0) {
|
|
|
|
/* lower bound not found; then, search in very near -INFINITY */
|
|
|
|
/* (-INFINITY..x where x is not -INFINITY but x*2 is -INFINITY) */
|
|
|
|
dec = low / 2;
|
|
|
|
count = BSEARCH_MAXCOUNT;
|
|
|
|
while (count >= 0 && dec < 0) {
|
|
|
|
nlow = low + dec;
|
|
|
|
if (!isinf(nlow)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(nlow));
|
|
|
|
if (!smaller) {
|
|
|
|
/* lower bound found; */
|
|
|
|
/* the desired value is within nlow..low */
|
|
|
|
high = low;
|
|
|
|
low = nlow;
|
|
|
|
goto binsearch;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
low = nlow;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dec /= 2;
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
/* lower bound not found; */
|
|
|
|
/* there is no candidate except -INFINITY itself */
|
|
|
|
nlow = low * 2; /* generate -INFINITY */
|
|
|
|
if (isinf(nlow)) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(nlow));
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
if (smaller) return DBL2NUM(nlow);
|
|
|
|
}
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
return DBL2NUM(low);
|
|
|
|
}
|
|
|
|
low = nlow;
|
|
|
|
}
|
|
|
|
|
|
|
|
binsearch:
|
|
|
|
/* find the desired value within low..high */
|
|
|
|
/* where low is not -INFINITY and high is not INFINITY */
|
|
|
|
count = BSEARCH_MAXCOUNT;
|
|
|
|
while (low < high && count >= 0) {
|
|
|
|
mid = low + ((high - low) / 2);
|
|
|
|
BSEARCH_CHECK(DBL2NUM(mid));
|
|
|
|
if (smaller) {
|
|
|
|
high = mid;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
low = mid;
|
|
|
|
}
|
|
|
|
count--;
|
|
|
|
}
|
|
|
|
BSEARCH_CHECK(DBL2NUM(low));
|
|
|
|
if (!smaller) {
|
|
|
|
BSEARCH_CHECK(DBL2NUM(high));
|
|
|
|
if (!smaller) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
low = high;
|
|
|
|
}
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
if (EXCL(range) && low >= org_high) return Qnil;
|
|
|
|
return DBL2NUM(low);
|
|
|
|
#undef BSEARCH_MAXCOUNT
|
|
|
|
}
|
|
|
|
else if (!NIL_P(rb_check_to_integer(beg, "to_int")) &&
|
|
|
|
!NIL_P(rb_check_to_integer(end, "to_int"))) {
|
|
|
|
VALUE low = beg;
|
|
|
|
VALUE high = end;
|
|
|
|
VALUE mid, org_high;
|
|
|
|
if (EXCL(range)) high = rb_funcall(high, '-', 1, INT2FIX(1));
|
|
|
|
org_high = high;
|
|
|
|
|
|
|
|
while (rb_cmpint(rb_funcall(low, id_cmp, 1, high), low, high) < 0) {
|
|
|
|
mid = rb_funcall(rb_funcall(high, '+', 1, low), '/', 1, INT2FIX(2));
|
|
|
|
BSEARCH_CHECK(mid);
|
|
|
|
if (smaller) {
|
|
|
|
high = mid;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
low = rb_funcall(mid, '+', 1, INT2FIX(1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rb_equal(low, org_high)) {
|
|
|
|
BSEARCH_CHECK(low);
|
|
|
|
if (!smaller) return Qnil;
|
|
|
|
}
|
|
|
|
if (!satisfied) return Qnil;
|
|
|
|
return low;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rb_raise(rb_eTypeError, "can't do binary search for %s", rb_obj_classname(beg));
|
|
|
|
}
|
|
|
|
return range;
|
|
|
|
}
|
|
|
|
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
static VALUE
|
|
|
|
each_i(VALUE v, void *arg)
|
2002-05-30 10:12:29 +04:00
|
|
|
{
|
2004-10-06 11:40:06 +04:00
|
|
|
rb_yield(v);
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
return Qnil;
|
2002-05-30 10:12:29 +04:00
|
|
|
}
|
|
|
|
|
2009-08-17 21:00:47 +04:00
|
|
|
static VALUE
|
|
|
|
sym_each_i(VALUE v, void *arg)
|
|
|
|
{
|
|
|
|
rb_yield(rb_str_intern(v));
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2012-11-06 21:14:46 +04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* rng.size -> num
|
|
|
|
*
|
|
|
|
* Returns the number of elements in the range.
|
|
|
|
*
|
|
|
|
* (10..20).size #=> 11
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_size(VALUE range)
|
|
|
|
{
|
|
|
|
VALUE b = RANGE_BEG(range), e = RANGE_END(range);
|
|
|
|
if (rb_obj_is_kind_of(b, rb_cNumeric) && rb_obj_is_kind_of(e, rb_cNumeric)) {
|
|
|
|
return num_interval_step_size(b, e, INT2FIX(1), EXCL(range));
|
|
|
|
}
|
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.each {| i | block } -> rng
|
|
|
|
* rng.each -> an_enumerator
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Iterates over the elements of range, passing each in turn to the
|
|
|
|
* block.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* The +each+ method can only be used if the begin object of the range
|
|
|
|
* supports the +succ+ method. A TypeError is raised if the object
|
|
|
|
* does not have +succ+ method defined (like Float).
|
2010-05-13 09:49:55 +04:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* If no block is given, an enumerator is returned instead.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* (10..15).each {|n| print n, ' ' }
|
|
|
|
* # prints: 10 11 12 13 14 15
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* (2.5..5).each {|n| print n, ' ' }
|
|
|
|
* # raises: TypeError: can't iterate from Float
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
2002-05-01 13:41:50 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_each(VALUE range)
|
2002-05-01 13:41:50 +04:00
|
|
|
{
|
2002-05-30 10:12:29 +04:00
|
|
|
VALUE beg, end;
|
|
|
|
|
2012-11-06 21:14:46 +04:00
|
|
|
RETURN_SIZED_ENUMERATOR(range, 0, 0, range_size);
|
2005-08-30 18:49:51 +04:00
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
beg = RANGE_BEG(range);
|
|
|
|
end = RANGE_END(range);
|
2002-05-30 10:12:29 +04:00
|
|
|
|
2003-01-08 09:05:08 +03:00
|
|
|
if (FIXNUM_P(beg) && FIXNUM_P(end)) { /* fixnums are special */
|
|
|
|
long lim = FIX2LONG(end);
|
|
|
|
long i;
|
|
|
|
|
2006-12-31 18:02:22 +03:00
|
|
|
if (!EXCL(range))
|
|
|
|
lim += 1;
|
|
|
|
for (i = FIX2LONG(beg); i < lim; i++) {
|
2008-04-28 13:35:09 +04:00
|
|
|
rb_yield(LONG2FIX(i));
|
2003-01-08 09:05:08 +03:00
|
|
|
}
|
|
|
|
}
|
2009-08-17 21:00:47 +04:00
|
|
|
else if (SYMBOL_P(beg) && SYMBOL_P(end)) { /* symbols are special */
|
|
|
|
VALUE args[2];
|
|
|
|
|
|
|
|
args[0] = rb_sym_to_s(end);
|
|
|
|
args[1] = EXCL(range) ? Qtrue : Qfalse;
|
|
|
|
rb_block_call(rb_sym_to_s(beg), rb_intern("upto"), 2, args, sym_each_i, 0);
|
|
|
|
}
|
2002-05-30 10:12:29 +04:00
|
|
|
else {
|
2009-08-17 20:41:00 +04:00
|
|
|
VALUE tmp = rb_check_string_type(beg);
|
|
|
|
|
|
|
|
if (!NIL_P(tmp)) {
|
|
|
|
VALUE args[2];
|
|
|
|
|
|
|
|
args[0] = end;
|
|
|
|
args[1] = EXCL(range) ? Qtrue : Qfalse;
|
|
|
|
rb_block_call(tmp, rb_intern("upto"), 2, args, rb_yield, 0);
|
|
|
|
}
|
|
|
|
else {
|
2009-09-30 12:32:43 +04:00
|
|
|
if (!discrete_object_p(beg)) {
|
2009-08-17 20:41:00 +04:00
|
|
|
rb_raise(rb_eTypeError, "can't iterate from %s",
|
|
|
|
rb_obj_classname(beg));
|
|
|
|
}
|
|
|
|
range_each_func(range, each_i, NULL);
|
2009-02-23 18:46:02 +03:00
|
|
|
}
|
2002-05-30 10:12:29 +04:00
|
|
|
}
|
|
|
|
return range;
|
2002-05-01 13:41:50 +04:00
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.begin -> obj
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the object that defines the beginning of the range.
|
|
|
|
*
|
|
|
|
* (1..10).begin #=> 1
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
1998-01-16 15:13:05 +03:00
|
|
|
static VALUE
|
2007-10-18 10:58:35 +04:00
|
|
|
range_begin(VALUE range)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2007-09-08 19:07:18 +04:00
|
|
|
return RANGE_BEG(range);
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.end -> obj
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the object that defines the end of the range.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* (1..10).end #=> 10
|
|
|
|
* (1...10).end #=> 10
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1998-01-16 15:13:05 +03:00
|
|
|
static VALUE
|
2007-10-18 10:58:35 +04:00
|
|
|
range_end(VALUE range)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2007-09-08 19:07:18 +04:00
|
|
|
return RANGE_END(range);
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2007-10-18 10:58:35 +04:00
|
|
|
|
|
|
|
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:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.first -> obj
|
|
|
|
* rng.first(n) -> an_array
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the first object in the range, or an array of the first +n+
|
|
|
|
* elements.
|
|
|
|
*
|
|
|
|
* (10..20).first #=> 10
|
|
|
|
* (10..20).first(3) #=> [10, 11, 12]
|
2007-10-18 10:58:35 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
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));
|
2012-12-02 13:57:47 +04:00
|
|
|
rb_block_call(range, idEach, 0, 0, first_i, (VALUE)ary);
|
2007-10-18 10:58:35 +04:00
|
|
|
|
|
|
|
return ary[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.last -> obj
|
|
|
|
* rng.last(n) -> an_array
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the last object in the range,
|
|
|
|
* or an array of the last +n+ elements.
|
|
|
|
*
|
|
|
|
* Note that with no arguments +last+ will return the object that defines
|
|
|
|
* the end of the range even if #exclude_end? is +true+.
|
|
|
|
*
|
|
|
|
* (10..20).last #=> 20
|
|
|
|
* (10...20).last #=> 20
|
|
|
|
* (10..20).last(3) #=> [18, 19, 20]
|
|
|
|
* (10...20).last(3) #=> [17, 18, 19]
|
2007-10-18 10:58:35 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_last(int argc, VALUE *argv, VALUE range)
|
|
|
|
{
|
|
|
|
if (argc == 0) return RANGE_END(range);
|
2009-02-22 17:23:33 +03:00
|
|
|
return rb_ary_last(argc, argv, rb_Array(range));
|
2007-10-18 10:58:35 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-11-25 04:30:57 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.min -> obj
|
|
|
|
* rng.min {| a,b | block } -> obj
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the minimum value in the range. Returns +nil+ if the begin
|
|
|
|
* value of the range is larger than the end value.
|
|
|
|
*
|
|
|
|
* Can be given an optional block to override the default comparison
|
|
|
|
* method <code>a <=> b</code>.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* (10..20).min #=> 10
|
2005-11-25 04:30:57 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_min(VALUE range)
|
|
|
|
{
|
|
|
|
if (rb_block_given_p()) {
|
|
|
|
return rb_call_super(0, 0);
|
|
|
|
}
|
|
|
|
else {
|
2007-09-08 19:07:18 +04:00
|
|
|
VALUE b = RANGE_BEG(range);
|
|
|
|
VALUE e = RANGE_END(range);
|
2005-11-25 08:42:28 +03:00
|
|
|
int c = rb_cmpint(rb_funcall(b, id_cmp, 1, e), b, e);
|
2005-11-25 04:30:57 +03:00
|
|
|
|
2007-07-13 06:33:11 +04:00
|
|
|
if (c > 0 || (c == 0 && EXCL(range)))
|
2006-12-31 18:02:22 +03:00
|
|
|
return Qnil;
|
2005-11-25 04:30:57 +03:00
|
|
|
return b;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.max -> obj
|
|
|
|
* rng.max {| a,b | block } -> obj
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns the maximum value in the range. Returns +nil+ if the begin
|
|
|
|
* value of the range larger than the end value.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Can be given an optional block to override the default comparison
|
|
|
|
* method <code>a <=> b</code>.
|
|
|
|
*
|
|
|
|
* (10..20).max #=> 20
|
2005-11-25 04:30:57 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
range_max(VALUE range)
|
|
|
|
{
|
2007-09-08 19:07:18 +04:00
|
|
|
VALUE e = RANGE_END(range);
|
2009-01-05 01:32:40 +03:00
|
|
|
int nm = FIXNUM_P(e) || rb_obj_is_kind_of(e, rb_cNumeric);
|
2005-11-25 08:42:28 +03:00
|
|
|
|
2009-01-05 01:32:40 +03:00
|
|
|
if (rb_block_given_p() || (EXCL(range) && !nm)) {
|
2005-11-25 04:30:57 +03:00
|
|
|
return rb_call_super(0, 0);
|
|
|
|
}
|
|
|
|
else {
|
2007-09-08 19:07:18 +04:00
|
|
|
VALUE b = RANGE_BEG(range);
|
2005-11-25 08:42:28 +03:00
|
|
|
int c = rb_cmpint(rb_funcall(b, id_cmp, 1, e), b, e);
|
2005-11-25 04:30:57 +03:00
|
|
|
|
2006-12-31 18:02:22 +03:00
|
|
|
if (c > 0)
|
|
|
|
return Qnil;
|
2005-11-25 08:42:28 +03:00
|
|
|
if (EXCL(range)) {
|
2009-01-05 01:32:40 +03:00
|
|
|
if (!FIXNUM_P(e) && !rb_obj_is_kind_of(e, rb_cInteger)) {
|
|
|
|
rb_raise(rb_eTypeError, "cannot exclude non Integer end value");
|
|
|
|
}
|
2007-07-13 06:33:11 +04:00
|
|
|
if (c == 0) return Qnil;
|
2011-07-10 04:47:31 +04:00
|
|
|
if (!FIXNUM_P(b) && !rb_obj_is_kind_of(b,rb_cInteger)) {
|
|
|
|
rb_raise(rb_eTypeError, "cannot exclude end value with non Integer begin value");
|
|
|
|
}
|
2005-11-25 08:42:28 +03:00
|
|
|
if (FIXNUM_P(e)) {
|
2007-07-12 13:52:48 +04:00
|
|
|
return LONG2NUM(FIX2LONG(e) - 1);
|
2005-11-25 08:42:28 +03:00
|
|
|
}
|
|
|
|
return rb_funcall(e, '-', 1, INT2FIX(1));
|
|
|
|
}
|
2005-11-25 04:30:57 +03:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-16 10:52:29 +04:00
|
|
|
int
|
|
|
|
rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2005-08-04 08:31:33 +04:00
|
|
|
VALUE b, e;
|
2009-07-16 10:52:29 +04:00
|
|
|
int excl;
|
1998-01-16 15:13:05 +03:00
|
|
|
|
2005-08-04 08:31:33 +04:00
|
|
|
if (rb_obj_is_kind_of(range, rb_cRange)) {
|
2007-09-08 19:07:18 +04:00
|
|
|
b = RANGE_BEG(range);
|
|
|
|
e = RANGE_END(range);
|
2005-08-04 15:29:51 +04:00
|
|
|
excl = EXCL(range);
|
2005-08-04 08:31:33 +04:00
|
|
|
}
|
|
|
|
else {
|
2009-09-23 07:39:44 +04:00
|
|
|
if (!rb_respond_to(range, id_beg)) return (int)Qfalse;
|
|
|
|
if (!rb_respond_to(range, id_end)) return (int)Qfalse;
|
2008-02-15 18:21:51 +03:00
|
|
|
b = rb_funcall(range, id_beg, 0);
|
|
|
|
e = rb_funcall(range, id_end, 0);
|
2005-08-04 15:29:51 +04:00
|
|
|
excl = RTEST(rb_funcall(range, rb_intern("exclude_end?"), 0));
|
2005-08-04 08:31:33 +04:00
|
|
|
}
|
2009-07-16 10:52:29 +04:00
|
|
|
*begp = b;
|
|
|
|
*endp = e;
|
|
|
|
*exclp = excl;
|
2009-09-23 07:39:44 +04:00
|
|
|
return (int)Qtrue;
|
2009-07-16 10:52:29 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
|
|
|
|
{
|
|
|
|
long beg, end, origbeg, origend;
|
|
|
|
VALUE b, e;
|
|
|
|
int excl;
|
|
|
|
|
|
|
|
if (!rb_range_values(range, &b, &e, &excl))
|
|
|
|
return Qfalse;
|
2005-08-04 08:31:33 +04:00
|
|
|
beg = NUM2LONG(b);
|
|
|
|
end = NUM2LONG(e);
|
2009-07-16 10:52:29 +04:00
|
|
|
origbeg = beg;
|
|
|
|
origend = end;
|
1999-08-13 09:45:20 +04:00
|
|
|
if (beg < 0) {
|
|
|
|
beg += len;
|
2006-12-31 18:02:22 +03:00
|
|
|
if (beg < 0)
|
|
|
|
goto out_of_range;
|
1999-08-13 09:45:20 +04:00
|
|
|
}
|
2012-11-21 08:23:56 +04:00
|
|
|
if (end < 0)
|
|
|
|
end += len;
|
|
|
|
if (!excl)
|
|
|
|
end++; /* include end point */
|
1999-08-13 09:45:20 +04:00
|
|
|
if (err == 0 || err == 2) {
|
2006-12-31 18:02:22 +03:00
|
|
|
if (beg > len)
|
|
|
|
goto out_of_range;
|
|
|
|
if (end > len)
|
|
|
|
end = len;
|
1999-08-13 09:45:20 +04:00
|
|
|
}
|
|
|
|
len = end - beg;
|
2006-12-31 18:02:22 +03:00
|
|
|
if (len < 0)
|
|
|
|
len = 0;
|
1999-08-13 09:45:20 +04:00
|
|
|
|
|
|
|
*begp = beg;
|
|
|
|
*lenp = len;
|
1999-01-20 07:59:39 +03:00
|
|
|
return Qtrue;
|
1999-08-13 09:45:20 +04:00
|
|
|
|
|
|
|
out_of_range:
|
|
|
|
if (err) {
|
2002-05-28 22:11:07 +04:00
|
|
|
rb_raise(rb_eRangeError, "%ld..%s%ld out of range",
|
2009-07-16 10:52:29 +04:00
|
|
|
origbeg, excl ? "." : "", origend);
|
1999-08-13 09:45:20 +04:00
|
|
|
}
|
|
|
|
return Qnil;
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2003-12-30 19:38:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.to_s -> string
|
2003-12-30 19:38:32 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Convert this range object to a printable form (using #to_s to convert the
|
|
|
|
* begin and end objects).
|
2003-12-30 19:38:32 +03:00
|
|
|
*/
|
|
|
|
|
1998-01-16 15:13:05 +03:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_to_s(VALUE range)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
|
|
|
VALUE str, str2;
|
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
str = rb_obj_as_string(RANGE_BEG(range));
|
|
|
|
str2 = rb_obj_as_string(RANGE_END(range));
|
2000-04-10 09:48:43 +04:00
|
|
|
str = rb_str_dup(str);
|
2006-12-31 18:02:22 +03:00
|
|
|
rb_str_cat(str, "...", EXCL(range) ? 3 : 2);
|
2000-04-10 09:48:43 +04:00
|
|
|
rb_str_append(str, str2);
|
|
|
|
OBJ_INFECT(str, str2);
|
1998-01-16 15:13:05 +03:00
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2008-09-25 19:42:23 +04:00
|
|
|
static VALUE
|
|
|
|
inspect_range(VALUE range, VALUE dummy, int recur)
|
|
|
|
{
|
|
|
|
VALUE str, str2;
|
|
|
|
|
|
|
|
if (recur) {
|
|
|
|
return rb_str_new2(EXCL(range) ? "(... ... ...)" : "(... .. ...)");
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2003-12-30 19:38:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng.inspect -> string
|
2003-12-30 19:38:32 +03:00
|
|
|
*
|
2009-02-22 17:23:33 +03:00
|
|
|
* Convert this range object to a printable form (using
|
2011-12-06 03:36:53 +04:00
|
|
|
* <code>inspect</code> to convert the begin and end
|
2003-12-30 19:38:32 +03:00
|
|
|
* objects).
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1998-01-16 15:13:05 +03:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_inspect(VALUE range)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2008-09-25 19:42:23 +04:00
|
|
|
return rb_exec_recursive(inspect_range, range, 0);
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-18 01:07:33 +04:00
|
|
|
* rng === obj -> true or false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns <code>true</code> if +obj+ is an element of the range,
|
|
|
|
* <code>false</code> otherwise. Conveniently, <code>===</code> is the
|
|
|
|
* comparison operator used by <code>case</code> statements.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* case 79
|
|
|
|
* when 1..50 then print "low\n"
|
|
|
|
* when 51..75 then print "medium\n"
|
|
|
|
* when 76..100 then print "high\n"
|
|
|
|
* end
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* <em>produces:</em>
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* high
|
|
|
|
*/
|
|
|
|
|
2007-07-26 17:37:13 +04:00
|
|
|
static VALUE
|
|
|
|
range_eqq(VALUE range, VALUE val)
|
|
|
|
{
|
|
|
|
return rb_funcall(range, rb_intern("include?"), 1, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-12-06 03:36:53 +04:00
|
|
|
* rng.member?(obj) -> true or false
|
|
|
|
* rng.include?(obj) -> true or false
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* Returns <code>true</code> if +obj+ is an element of
|
|
|
|
* the range, <code>false</code> otherwise. If begin and end are
|
|
|
|
* numeric, comparison is done according to the magnitude of the values.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* ("a".."z").include?("g") #=> true
|
|
|
|
* ("a".."z").include?("A") #=> false
|
|
|
|
* ("a".."z").include?("cc") #=> false
|
2007-07-26 17:37:13 +04:00
|
|
|
*/
|
|
|
|
|
2002-06-11 11:02:23 +04:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
range_include(VALUE range, VALUE val)
|
2002-06-11 11:02:23 +04:00
|
|
|
{
|
2007-09-08 19:07:18 +04:00
|
|
|
VALUE beg = RANGE_BEG(range);
|
|
|
|
VALUE end = RANGE_END(range);
|
2005-12-07 11:41:59 +03:00
|
|
|
int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||
|
|
|
|
rb_obj_is_kind_of(beg, rb_cNumeric) ||
|
|
|
|
rb_obj_is_kind_of(end, rb_cNumeric);
|
|
|
|
|
2005-12-09 17:17:09 +03:00
|
|
|
if (nv ||
|
|
|
|
!NIL_P(rb_check_to_integer(beg, "to_int")) ||
|
|
|
|
!NIL_P(rb_check_to_integer(end, "to_int"))) {
|
2005-12-07 11:41:59 +03:00
|
|
|
if (r_le(beg, val)) {
|
|
|
|
if (EXCL(range)) {
|
2006-12-31 18:02:22 +03:00
|
|
|
if (r_lt(val, end))
|
|
|
|
return Qtrue;
|
2005-12-07 11:41:59 +03:00
|
|
|
}
|
|
|
|
else {
|
2006-12-31 18:02:22 +03:00
|
|
|
if (r_le(val, end))
|
|
|
|
return Qtrue;
|
2005-12-07 11:41:59 +03:00
|
|
|
}
|
2002-12-19 12:20:20 +03:00
|
|
|
}
|
2005-12-09 17:17:09 +03:00
|
|
|
return Qfalse;
|
2002-06-11 11:02:23 +04:00
|
|
|
}
|
2011-09-29 15:07:45 +04:00
|
|
|
else if (RB_TYPE_P(beg, T_STRING) && RB_TYPE_P(end, T_STRING) &&
|
2008-02-11 20:46:52 +03:00
|
|
|
RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
|
|
|
|
if (NIL_P(val)) return Qfalse;
|
2011-09-29 15:07:45 +04:00
|
|
|
if (RB_TYPE_P(val, T_STRING)) {
|
2008-02-11 20:46:52 +03:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
* call_cfunc.ci, compile.c, compile.h, debug.h, eval.c,
eval_error.h, eval_jump.h, eval_load.c, eval_thread.c, gc.c,
insnhelper.h, insns.def, iseq.c, main.c, numeric.c, parse.y,
range.c, regenc.h, ruby.h, signal.c, thread.c, thread_win32.ci,
vm.c, vm.h, vm_dump.c, vm_evalbody.ci, yarvcore.c, yarvcore.h:
fixed indents and non-C90 comments.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11620 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-02 19:26:04 +03:00
|
|
|
/* TODO: ruby_frame->this_func = rb_intern("include?"); */
|
2005-12-07 11:41:59 +03:00
|
|
|
return rb_call_super(1, &val);
|
2002-06-11 11:02:23 +04:00
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
|
2005-12-12 04:01:29 +03:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-12-06 03:36:53 +04:00
|
|
|
* rng.cover?(obj) -> true or false
|
|
|
|
*
|
|
|
|
* Returns <code>true</code> if +obj+ is between the begin and end of
|
|
|
|
* the range.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* This tests <code>begin <= obj <= end</code> when #exclude_end? is +false+
|
|
|
|
* and <code>begin <= obj < end</code> when #exclude_end? is +true+.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2005-12-12 04:01:29 +03:00
|
|
|
* ("a".."z").cover?("c") #=> true
|
|
|
|
* ("a".."z").cover?("5") #=> false
|
2011-12-06 03:36:53 +04:00
|
|
|
* ("a".."z").cover?("cc") #=> true
|
2005-12-12 04:01:29 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
* sprintf.c (rb_str_format): allow %c to print one character
string (e.g. ?x).
* lib/tempfile.rb (Tempfile::make_tmpname): put dot between
basename and pid. [ruby-talk:196272]
* parse.y (do_block): remove -> style block.
* parse.y (parser_yylex): remove tLAMBDA_ARG.
* eval.c (rb_call0): binding for the return event hook should have
consistent scope. [ruby-core:07928]
* eval.c (proc_invoke): return behavior should depend whether it
is surrounded by a lambda or a mere block.
* eval.c (formal_assign): handles post splat arguments.
* eval.c (rb_call0): ditto.
* st.c (strhash): use FNV-1a hash.
* parse.y (parser_yylex): removed experimental ';;' terminator.
* eval.c (rb_node_arity): should be aware of post splat arguments.
* eval.c (rb_proc_arity): ditto.
* parse.y (f_args): syntax rule enhanced to support arguments
after the splat.
* parse.y (block_param): ditto for block parameters.
* parse.y (f_post_arg): mandatory formal arguments after the splat
argument.
* parse.y (new_args_gen): generate nodes for mandatory formal
arguments after the splat argument.
* eval.c (rb_eval): dispatch mandatory formal arguments after the
splat argument.
* parse.y (args): allow more than one splat in the argument list.
* parse.y (method_call): allow aref [] to accept all kind of
method argument, including assocs, splat, and block argument.
* eval.c (SETUP_ARGS0): prepare block argument as well.
* lib/mathn.rb (Integer): remove Integer#gcd2. [ruby-core:07931]
* eval.c (error_line): print receivers true/false/nil specially.
* eval.c (rb_proc_yield): handles parameters in yield semantics.
* eval.c (nil_yield): gives LocalJumpError to denote no block
error.
* io.c (rb_io_getc): now takes one-character string.
* string.c (rb_str_hash): use FNV-1a hash from Fowler/Noll/Vo
hashing algorithm.
* string.c (rb_str_aref): str[0] now returns 1 character string,
instead of a fixnum. [Ruby2]
* parse.y (parser_yylex): ?c now returns 1 character string,
instead of a fixnum. [Ruby2]
* string.c (rb_str_aset): no longer support fixnum insertion.
* eval.c (umethod_bind): should not update original class.
[ruby-dev:28636]
* eval.c (ev_const_get): should support constant access from
within instance_eval(). [ruby-dev:28327]
* time.c (time_timeval): should round for usec floating
number. [ruby-core:07896]
* time.c (time_add): ditto.
* dir.c (sys_warning): should not call a vararg function
rb_sys_warning() indirectly. [ruby-core:07886]
* numeric.c (flo_divmod): the first element of Float#divmod should
be an integer. [ruby-dev:28589]
* test/ruby/test_float.rb: add tests for divmod, div, modulo and remainder.
* re.c (rb_reg_initialize): should not allow modifying literal
regexps. frozen check moved from rb_reg_initialize_m as well.
* re.c (rb_reg_initialize): should not modify untainted objects in
safe levels higher than 3.
* re.c (rb_memcmp): type change from char* to const void*.
* dir.c (dir_close): should not close untainted dir stream.
* dir.c (GetDIR): add tainted/frozen check for each dir operation.
* lib/rdoc/parsers/parse_rb.rb (RDoc::RubyParser::parse_symbol_arg):
typo fixed. a patch from Florian Gross <florg at florg.net>.
* eval.c (EXEC_EVENT_HOOK): trace_func may remove itself from
event_hooks. no guarantee for arbitrary hook deletion.
[ruby-dev:28632]
* util.c (ruby_strtod): differ addition to minimize error.
[ruby-dev:28619]
* util.c (ruby_strtod): should not raise ERANGE when the input
string does not have any digits. [ruby-dev:28629]
* eval.c (proc_invoke): should restore old ruby_frame->block.
thanks to ts <decoux at moulon.inra.fr>. [ruby-core:07833]
also fix [ruby-dev:28614] as well.
* signal.c (trap): sig should be less then NSIG. Coverity found
this bug. a patch from Kevin Tew <tewk at tewk.com>.
[ruby-core:07823]
* math.c (math_log2): add new method inspired by
[ruby-talk:191237].
* math.c (math_log): add optional base argument to Math::log().
[ruby-talk:191308]
* ext/syck/emitter.c (syck_scan_scalar): avoid accessing
uninitialized array element. a patch from Pat Eyler
<rubypate at gmail.com>. [ruby-core:07809]
* array.c (rb_ary_fill): initialize local variables first. a
patch from Pat Eyler <rubypate at gmail.com>. [ruby-core:07810]
* ext/syck/yaml2byte.c (syck_yaml2byte_handler): need to free
type_tag. a patch from Pat Eyler <rubypate at gmail.com>.
[ruby-core:07808]
* ext/socket/socket.c (make_hostent_internal): accept ai_family
check from Sam Roberts <sroberts at uniserve.com>.
[ruby-core:07691]
* util.c (ruby_strtod): should not cut off 18 digits for no
reason. [ruby-core:07796]
* array.c (rb_ary_fill): internalize local variable "beg" to
pacify Coverity. [ruby-core:07770]
* pack.c (pack_unpack): now supports CRLF newlines. a patch from
<tommy at tmtm.org>. [ruby-dev:28601]
* applied code clean-up patch from Stefan Huehner
<stefan at huehner.org>. [ruby-core:07764]
* lib/jcode.rb (String::tr_s): should have translated non
squeezing character sequence (i.e. a character) as well. thanks
to Hiroshi Ichikawa <gimite at gimite.ddo.jp> [ruby-list:42090]
* ext/socket/socket.c: document update patch from Sam Roberts
<sroberts at uniserve.com>. [ruby-core:07701]
* lib/mathn.rb (Integer): need not to remove gcd2. a patch from
NARUSE, Yui <naruse at airemix.com>. [ruby-dev:28570]
* parse.y (arg): too much NEW_LIST()
* eval.c (SETUP_ARGS0): remove unnecessary access to nd_alen.
* eval.c (rb_eval): use ARGSCAT for NODE_OP_ASGN1.
[ruby-dev:28585]
* parse.y (arg): use NODE_ARGSCAT for placeholder.
* lib/getoptlong.rb (GetoptLong::get): RDoc update patch from
mathew <meta at pobox.com>. [ruby-core:07738]
* variable.c (rb_const_set): raise error when no target klass is
supplied. [ruby-dev:28582]
* prec.c (prec_prec_f): documentation patch from
<gerardo.santana at gmail.com>. [ruby-core:07689]
* bignum.c (rb_big_pow): second operand may be too big even if
it's a Fixnum. [ruby-talk:187984]
* README.EXT: update symbol description. [ruby-talk:188104]
* COPYING: explicitly note GPLv2. [ruby-talk:187922]
* parse.y: remove some obsolete syntax rules (unparenthesized
method calls in argument list).
* eval.c (rb_call0): insecure calling should be checked for non
NODE_SCOPE method invocations too.
* eval.c (rb_alias): should preserve the current safe level as
well as method definition.
* process.c (rb_f_sleep): remove RDoc description about SIGALRM
which is not valid on the current implementation. [ruby-dev:28464]
Thu Mar 23 21:40:47 2006 K.Kosako <sndgk393 AT ybb.ne.jp>
* eval.c (method_missing): should support argument splat in
super. a bug in combination of super, splat and
method_missing. [ruby-talk:185438]
* configure.in: Solaris SunPro compiler -rapth patch from
<kuwa at labs.fujitsu.com>. [ruby-dev:28443]
* configure.in: remove enable_rpath=no for Solaris.
[ruby-dev:28440]
* ext/win32ole/win32ole.c (ole_val2olevariantdata): change behavior
of converting OLE Variant object with VT_ARRAY|VT_UI1 and Ruby
String object.
* ruby.1: a clarification patch from David Lutterkort
<dlutter at redhat.com>. [ruby-core:7508]
* lib/rdoc/ri/ri_paths.rb (RI::Paths): adding paths from rubygems
directories. a patch from Eric Hodel <drbrain at segment7.net>.
[ruby-core:07423]
* eval.c (rb_clear_cache_by_class): clearing wrong cache.
* ext/extmk.rb: use :remove_destination to install extension libraries
to avoid SEGV. [ruby-dev:28417]
* eval.c (rb_thread_fd_writable): should not re-schedule output
from KILLED thread (must be error printing).
* array.c (rb_ary_flatten_bang): allow specifying recursion
level. [ruby-talk:182170]
* array.c (rb_ary_flatten): ditto.
* gc.c (add_heap): a heap_slots may overflow. a patch from Stefan
Weil <weil at mail.berlios.de>.
* eval.c (rb_call): use separate cache for fcall/vcall
invocation.
* eval.c (rb_eval): NODE_FCALL, NODE_VCALL can call local
functions.
* eval.c (rb_mod_local): a new method to specify newly added
visibility "local".
* eval.c (search_method): search for local methods which are
visible only from the current class.
* class.c (rb_class_local_methods): a method to list local methods.
* object.c (Init_Object): add BasicObject class as a top level
BlankSlate class.
* ruby.h (SYM2ID): should not cast to signed long.
[ruby-core:07414]
* class.c (rb_include_module): allow module duplication.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@10235 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2006-06-10 01:20:17 +04:00
|
|
|
range_cover(VALUE range, VALUE val)
|
2005-12-12 04:01:29 +03:00
|
|
|
{
|
|
|
|
VALUE beg, end;
|
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
beg = RANGE_BEG(range);
|
|
|
|
end = RANGE_END(range);
|
2005-12-12 04:01:29 +03:00
|
|
|
if (r_le(beg, val)) {
|
|
|
|
if (EXCL(range)) {
|
2006-12-31 18:02:22 +03:00
|
|
|
if (r_lt(val, end))
|
|
|
|
return Qtrue;
|
2005-12-12 04:01:29 +03:00
|
|
|
}
|
|
|
|
else {
|
2006-12-31 18:02:22 +03:00
|
|
|
if (r_le(val, end))
|
|
|
|
return Qtrue;
|
2005-12-12 04:01:29 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Qfalse;
|
|
|
|
}
|
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
static VALUE
|
|
|
|
range_dumper(VALUE range)
|
|
|
|
{
|
|
|
|
VALUE v;
|
2012-10-20 10:57:51 +04:00
|
|
|
NEWOBJ_OF(m, struct RObject, rb_cObject, T_OBJECT);
|
2007-09-08 19:07:18 +04:00
|
|
|
|
|
|
|
v = (VALUE)m;
|
|
|
|
|
2007-09-10 10:50:22 +04:00
|
|
|
rb_ivar_set(v, id_excl, RANGE_EXCL(range));
|
2007-09-08 19:07:18 +04:00
|
|
|
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)
|
|
|
|
{
|
2011-09-29 15:07:45 +04:00
|
|
|
if (!RB_TYPE_P(obj, T_OBJECT) || RBASIC(obj)->klass != rb_cObject) {
|
2007-09-08 19:07:18 +04:00
|
|
|
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);
|
2007-09-10 10:50:22 +04:00
|
|
|
RSTRUCT(range)->as.ary[2] = rb_ivar_get(obj, id_excl);
|
2007-09-08 19:07:18 +04:00
|
|
|
return range;
|
|
|
|
}
|
2005-12-12 04:01:29 +03:00
|
|
|
|
2007-11-23 10:00:50 +03:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2003-12-24 07:29:32 +03:00
|
|
|
/* A <code>Range</code> represents an interval---a set of values with a
|
2011-12-06 03:36:53 +04:00
|
|
|
* beginning and an end. Ranges may be constructed using the
|
2003-12-24 07:29:32 +03:00
|
|
|
* <em>s</em><code>..</code><em>e</em> and
|
|
|
|
* <em>s</em><code>...</code><em>e</em> literals, or with
|
2011-12-06 03:36:53 +04:00
|
|
|
* Range::new. Ranges constructed using <code>..</code>
|
|
|
|
* run from the beginning to the end inclusively. Those created using
|
2003-12-24 07:29:32 +03:00
|
|
|
* <code>...</code> exclude the end value. When used as an iterator,
|
|
|
|
* ranges return each value in the sequence.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* (-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"]
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2011-12-06 03:36:53 +04:00
|
|
|
* == Custom Objects in Ranges
|
|
|
|
*
|
|
|
|
* Ranges can be constructed using any objects that can be compared
|
|
|
|
* using the <code><=></code> operator.
|
|
|
|
* Methods that treat the range as a sequence (#each and methods inherited
|
|
|
|
* from Enumerable) expect the begin object to implement a
|
|
|
|
* <code>succ</code> method to return the next object in sequence.
|
|
|
|
* The #step and #include? methods require the begin
|
|
|
|
* object to implement <code>succ</code> or to be numeric.
|
|
|
|
*
|
|
|
|
* In the <code>Xs</code> class below both <code><=></code> and
|
|
|
|
* <code>succ</code> are implemented so <code>Xs</code> can be used
|
|
|
|
* to construct ranges. Note that the Comparable module is included
|
|
|
|
* so the <code>==</code> method is defined in terms of <code><=></code>.
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* 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
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2012-03-03 07:29:01 +04:00
|
|
|
* An example of using <code>Xs</code> to construct a range:
|
2011-12-06 03:36:53 +04:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
* r = Xs.new(3)..Xs.new(6) #=> xxx..xxxxxx
|
|
|
|
* r.to_a #=> [xxx, xxxx, xxxxx, xxxxxx]
|
|
|
|
* r.member?(Xs.new(5)) #=> true
|
2009-02-22 17:23:33 +03:00
|
|
|
*
|
2003-12-24 07:29:32 +03:00
|
|
|
*/
|
|
|
|
|
1998-01-16 15:13:05 +03:00
|
|
|
void
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 14:44:21 +04:00
|
|
|
Init_Range(void)
|
1998-01-16 15:13:05 +03:00
|
|
|
{
|
2008-06-09 13:25:32 +04:00
|
|
|
#undef rb_intern
|
2008-08-16 04:20:31 +04:00
|
|
|
#define rb_intern(str) rb_intern_const(str)
|
2008-06-09 13:25:32 +04:00
|
|
|
|
2007-09-08 19:07:18 +04:00
|
|
|
id_cmp = rb_intern("<=>");
|
|
|
|
id_succ = rb_intern("succ");
|
|
|
|
id_beg = rb_intern("begin");
|
|
|
|
id_end = rb_intern("end");
|
|
|
|
id_excl = rb_intern("excl");
|
|
|
|
|
2007-11-23 10:00:50 +03:00
|
|
|
rb_cRange = rb_struct_define_without_accessor(
|
|
|
|
"Range", rb_cObject, range_alloc,
|
2007-11-23 07:35:53 +03:00
|
|
|
"begin", "end", "excl", NULL);
|
2007-09-08 19:07:18 +04:00
|
|
|
|
1999-01-20 07:59:39 +03:00
|
|
|
rb_include_module(rb_cRange, rb_mEnumerable);
|
2007-09-08 19:07:18 +04:00
|
|
|
rb_marshal_define_compat(rb_cRange, rb_cObject, range_dumper, range_loader);
|
2000-02-29 11:05:32 +03:00
|
|
|
rb_define_method(rb_cRange, "initialize", range_initialize, -1);
|
2008-08-21 01:02:54 +04:00
|
|
|
rb_define_method(rb_cRange, "initialize_copy", range_initialize_copy, 1);
|
2000-11-27 12:23:38 +03:00
|
|
|
rb_define_method(rb_cRange, "==", range_eq, 1);
|
2007-07-26 17:37:13 +04:00
|
|
|
rb_define_method(rb_cRange, "===", range_eqq, 1);
|
2001-11-08 12:21:59 +03:00
|
|
|
rb_define_method(rb_cRange, "eql?", range_eql, 1);
|
|
|
|
rb_define_method(rb_cRange, "hash", range_hash, 0);
|
1999-01-20 07:59:39 +03:00
|
|
|
rb_define_method(rb_cRange, "each", range_each, 0);
|
2001-08-14 12:13:31 +04:00
|
|
|
rb_define_method(rb_cRange, "step", range_step, -1);
|
2012-11-14 19:53:50 +04:00
|
|
|
rb_define_method(rb_cRange, "bsearch", range_bsearch, 0);
|
2007-10-18 10:58:35 +04:00
|
|
|
rb_define_method(rb_cRange, "begin", range_begin, 0);
|
2007-10-18 12:14:21 +04:00
|
|
|
rb_define_method(rb_cRange, "end", range_end, 0);
|
2007-10-18 10:58:35 +04:00
|
|
|
rb_define_method(rb_cRange, "first", range_first, -1);
|
|
|
|
rb_define_method(rb_cRange, "last", range_last, -1);
|
2005-11-25 04:30:57 +03:00
|
|
|
rb_define_method(rb_cRange, "min", range_min, 0);
|
|
|
|
rb_define_method(rb_cRange, "max", range_max, 0);
|
2012-11-06 21:14:46 +04:00
|
|
|
rb_define_method(rb_cRange, "size", range_size, 0);
|
1999-01-20 07:59:39 +03:00
|
|
|
rb_define_method(rb_cRange, "to_s", range_to_s, 0);
|
|
|
|
rb_define_method(rb_cRange, "inspect", range_inspect, 0);
|
|
|
|
|
1999-08-13 09:45:20 +04:00
|
|
|
rb_define_method(rb_cRange, "exclude_end?", range_exclude_end_p, 0);
|
|
|
|
|
2004-10-19 14:25:23 +04:00
|
|
|
rb_define_method(rb_cRange, "member?", range_include, 1);
|
2002-06-11 11:02:23 +04:00
|
|
|
rb_define_method(rb_cRange, "include?", range_include, 1);
|
2005-12-12 04:01:29 +03:00
|
|
|
rb_define_method(rb_cRange, "cover?", range_cover, 1);
|
1998-01-16 15:13:05 +03:00
|
|
|
}
|