ruby/range.c

1420 строки
34 KiB
C
Исходник Обычный вид История

/**********************************************************************
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
**********************************************************************/
#include "ruby/ruby.h"
#include "ruby/encoding.h"
#include "internal.h"
#include "id.h"
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
#include <math.h>
VALUE rb_cRange;
static ID id_cmp, id_succ, id_beg, id_end, id_excl;
#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(begin, end, exclude_end=false) -> rng
*
* 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
* 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(idInitialize, "`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 the range excludes its end value.
*
* (1..5).exclude_end? #=> false
* (1...5).exclude_end? #=> true
*/
static VALUE
range_exclude_end_p(VALUE range)
{
return EXCL(range) ? Qtrue : Qfalse;
}
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;
}
/*
* call-seq:
* rng == obj -> true or false
*
* 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.
*
* (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_kind_of(obj, rb_cRange))
return Qfalse;
return rb_exec_recursive_paired(recursive_equal, range, obj, obj);
}
static int
r_lt(VALUE a, VALUE b)
{
VALUE r = rb_funcall(a, id_cmp, 1, b);
if (NIL_P(r))
return (int)Qfalse;
if (rb_cmpint(r, a, b) < 0)
return (int)Qtrue;
return (int)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 (int)Qfalse;
c = rb_cmpint(r, a, b);
if (c == 0)
return (int)INT2FIX(0);
if (c < 0)
return (int)Qtrue;
return (int)Qfalse;
}
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;
}
/*
* call-seq:
* rng.eql?(obj) -> true or false
*
* 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.
*
* (0..2).eql?(0..2) #=> true
* (0..2).eql?(Range.new(0,2)) #=> true
* (0..2).eql?(0...2) #=> false
*
*/
static VALUE
range_eql(VALUE range, VALUE obj)
{
if (range == obj)
return Qtrue;
if (!rb_obj_is_kind_of(obj, rb_cRange))
return Qfalse;
return rb_exec_recursive_paired(recursive_eql, range, obj, obj);
}
static VALUE
recursive_hash(VALUE range, VALUE dummy, int recur)
{
st_index_t hash = EXCL(range);
VALUE v;
hash = rb_hash_start(hash);
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));
}
hash = rb_hash_uint(hash, EXCL(range) << 24);
hash = rb_hash_end(hash);
return LONG2FIX(hash);
}
/*
* call-seq:
* rng.hash -> fixnum
*
* 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.
*/
static VALUE
range_hash(VALUE range)
{
return rb_exec_recursive_outer(recursive_hash, range, 0);
}
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 ((c = r_le(v, e)) != Qfalse) {
(*func) (v, arg);
if (c == (int)INT2FIX(0))
break;
v = rb_funcall(v, id_succ, 0, 0);
}
}
}
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;
}
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;
}
static int
discrete_object_p(VALUE obj)
{
if (rb_obj_is_kind_of(obj, rb_cTime)) return FALSE; /* until Time#succ removed */
return rb_respond_to(obj, id_succ);
}
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;
}
/*
* call-seq:
* rng.step(n=1) {| obj | block } -> rng
* rng.step(n=1) -> an_enumerator
*
* 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.
*
* If no block is given, an enumerator is returned instead.
*
* range = Xs.new(1)..Xs.new(10)
* range.step(2) {|x| puts x}
* puts
* 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
*
* See Range for the definition of class Xs.
*/
static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
VALUE b, e, step, tmp;
RETURN_SIZED_ENUMERATOR(range, argc, argv, range_step_size);
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 (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);
}
else if (ruby_float_step(b, e, step, EXCL(range))) {
/* done */
}
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) ? '<' : idLE;
VALUE v = b;
int i = 0;
while (RTEST(rb_funcall(v, op, 1, e))) {
rb_yield(v);
i++;
v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 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 (!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",
rb_obj_classname(b));
}
args[0] = INT2FIX(1);
args[1] = step;
range_each_func(range, step_i, args);
}
}
return range;
}
/*
* call-seq:
* rng.bsearch {|obj| block } -> value
*
* By using binary search, finds a value in range which meets the given
* condition in O(log n) where n is the size of the array.
*
* 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.
*
* If x is within the range, this method returns the value x.
* 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]
* (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
*
* 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)) { \
int cmp = rb_cmpint(rb_funcall(v, id_cmp, 1, INT2FIX(0)), v, INT2FIX(0)); \
if (!cmp) return val; \
smaller = cmp < 0; \
} \
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;
org_high = high;
#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) */
volatile double nlow = -1.0, dec;
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;
}
static VALUE
each_i(VALUE v, void *arg)
{
rb_yield(v);
return Qnil;
}
static VALUE
sym_each_i(VALUE v, void *arg)
{
rb_yield(rb_str_intern(v));
return Qnil;
}
/*
* 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;
}
/*
* call-seq:
* rng.each {| i | block } -> rng
* rng.each -> an_enumerator
*
* Iterates over the elements of range, passing each in turn to the
* block.
*
* 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).
*
* If no block is given, an enumerator is returned instead.
*
* (10..15).each {|n| print n, ' ' }
* # prints: 10 11 12 13 14 15
*
* (2.5..5).each {|n| print n, ' ' }
* # raises: TypeError: can't iterate from Float
*/
static VALUE
range_each(VALUE range)
{
VALUE beg, end;
RETURN_SIZED_ENUMERATOR(range, 0, 0, range_size);
beg = RANGE_BEG(range);
end = RANGE_END(range);
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 (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);
}
else {
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 {
if (!discrete_object_p(beg)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(beg));
}
range_each_func(range, each_i, NULL);
}
}
return range;
}
/*
* call-seq:
* rng.begin -> obj
*
* Returns the object that defines the beginning of the range.
*
* (1..10).begin #=> 1
*/
static VALUE
range_begin(VALUE range)
{
return RANGE_BEG(range);
}
/*
* call-seq:
* rng.end -> obj
*
* Returns the object that defines the end of the range.
*
* (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 the range, or an array of the first +n+
* elements.
*
* (10..20).first #=> 10
* (10..20).first(3) #=> [10, 11, 12]
*/
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, idEach, 0, 0, first_i, (VALUE)ary);
return ary[1];
}
/*
* call-seq:
* rng.last -> obj
* rng.last(n) -> an_array
*
* 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]
*/
static VALUE
range_last(int argc, VALUE *argv, VALUE range)
{
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 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>.
*
* (10..20).min #=> 10
*/
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 the range. Returns +nil+ if the begin
* value of the range larger than the end value.
*
* Can be given an optional block to override the default comparison
* method <code>a <=> b</code>.
*
* (10..20).max #=> 20
*/
static VALUE
range_max(VALUE range)
{
VALUE e = RANGE_END(range);
int nm = FIXNUM_P(e) || rb_obj_is_kind_of(e, rb_cNumeric);
if (rb_block_given_p() || (EXCL(range) && !nm)) {
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 (!FIXNUM_P(e) && !rb_obj_is_kind_of(e, rb_cInteger)) {
rb_raise(rb_eTypeError, "cannot exclude non Integer end value");
}
if (c == 0) return Qnil;
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");
}
if (FIXNUM_P(e)) {
return LONG2NUM(FIX2LONG(e) - 1);
}
return rb_funcall(e, '-', 1, INT2FIX(1));
}
return e;
}
}
int
rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
{
VALUE b, e;
int 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 (int)Qfalse;
if (!rb_respond_to(range, id_end)) return (int)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));
}
*begp = b;
*endp = e;
*exclp = excl;
return (int)Qtrue;
}
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;
beg = NUM2LONG(b);
end = NUM2LONG(e);
origbeg = beg;
origend = end;
if (beg < 0) {
beg += len;
if (beg < 0)
goto out_of_range;
}
if (end < 0)
end += len;
if (!excl)
end++; /* include end point */
if (err == 0 || err == 2) {
if (beg > len)
goto out_of_range;
if (end > len)
end = len;
}
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",
origbeg, excl ? "." : "", origend);
}
return Qnil;
}
/*
* call-seq:
* rng.to_s -> string
*
* Convert this range object to a printable form (using #to_s to convert the
* begin and end objects).
*/
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;
}
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;
}
/*
* call-seq:
* rng.inspect -> string
*
* Convert this range object to a printable form (using
* <code>inspect</code> to convert the begin and end
* objects).
*/
static VALUE
range_inspect(VALUE range)
{
return rb_exec_recursive(inspect_range, range, 0);
}
/*
* call-seq:
* rng === obj -> true or false
*
* 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.
*
* 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?(obj) -> true or false
* rng.include?(obj) -> true or false
*
* 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.
*
* ("a".."z").include?("g") #=> true
* ("a".."z").include?("A") #=> false
* ("a".."z").include?("cc") #=> 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 (RB_TYPE_P(beg, T_STRING) && RB_TYPE_P(end, T_STRING) &&
RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
if (NIL_P(val)) return Qfalse;
if (RB_TYPE_P(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?(obj) -> true or false
*
* Returns <code>true</code> if +obj+ is between the begin and end of
* the range.
*
* This tests <code>begin <= obj <= end</code> when #exclude_end? is +false+
* and <code>begin <= obj < end</code> when #exclude_end? is +true+.
*
* ("a".."z").cover?("c") #=> true
* ("a".."z").cover?("5") #=> false
* ("a".."z").cover?("cc") #=> true
*/
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)
{
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_OF(m, struct RObject, 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 (!RB_TYPE_P(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
* beginning 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
* Range::new. Ranges constructed using <code>..</code>
* run from the beginning 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"]
*
* == 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>.
*
* 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
*
* An example of using <code>Xs</code> to construct a range:
*
* r = Xs.new(3)..Xs.new(6) #=> xxx..xxxxxx
* r.to_a #=> [xxx, xxxx, xxxxx, xxxxxx]
* r.member?(Xs.new(5)) #=> true
*
*/
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, "bsearch", range_bsearch, 0);
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, "size", range_size, 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);
}