[macruby-changes] [3519] MacRuby/trunk
source_changes at macosforge.org
source_changes at macosforge.org
Fri Feb 12 22:26:02 PST 2010
Revision: 3519
http://trac.macosforge.org/projects/ruby/changeset/3519
Author: lsansonetti at apple.com
Date: 2010-02-12 22:25:58 -0800 (Fri, 12 Feb 2010)
Log Message:
-----------
integrate Mersenne Twister based random number generator from 1.9 upstream
Modified Paths:
--------------
MacRuby/trunk/bignum.c
MacRuby/trunk/include/ruby/intern.h
MacRuby/trunk/include/ruby/ruby.h
MacRuby/trunk/object.c
MacRuby/trunk/random.c
MacRuby/trunk/range.c
MacRuby/trunk/vm.cpp
MacRuby/trunk/vm.h
Added Paths:
-----------
MacRuby/trunk/mt.c
Modified: MacRuby/trunk/bignum.c
===================================================================
--- MacRuby/trunk/bignum.c 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/bignum.c 2010-02-13 06:25:58 UTC (rev 3519)
@@ -53,6 +53,12 @@
}
int
+rb_bigzero_p(VALUE x)
+{
+ return BIGZEROP(x);
+}
+
+int
rb_cmpint(VALUE val, VALUE a, VALUE b)
{
if (NIL_P(val)) {
@@ -696,6 +702,12 @@
return v;
}
+VALUE
+rb_big_new(long len, int sign)
+{
+ return bignew(len, sign != 0);
+}
+
const char ruby_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
static VALUE bigsqr(VALUE x);
Modified: MacRuby/trunk/include/ruby/intern.h
===================================================================
--- MacRuby/trunk/include/ruby/intern.h 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/include/ruby/intern.h 2010-02-13 06:25:58 UTC (rev 3519)
@@ -95,6 +95,8 @@
VALUE rb_str2inum(VALUE, int);
VALUE rb_big2str(VALUE, int);
VALUE rb_big2str0(VALUE, int, int);
+VALUE rb_big_new(long len, int sign);
+int rb_bigzero_p(VALUE x);
SIGNED_VALUE rb_big2long(VALUE);
#define rb_big2int(x) rb_big2long(x)
VALUE rb_big2ulong(VALUE);
@@ -453,6 +455,7 @@
VALUE rb_Array(VALUE);
double rb_cstr_to_dbl(const char*, int);
double rb_str_to_dbl(VALUE, int);
+VALUE rb_check_to_float(VALUE val);
/* parse.y */
RUBY_EXTERN int ruby_sourceline;
RUBY_EXTERN char *ruby_sourcefile;
@@ -497,8 +500,9 @@
void rb_range_extract(VALUE range, VALUE *begp, VALUE *endp, bool *exclude);
VALUE rb_range_new(VALUE, VALUE, int);
VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
+int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp);
/* random.c */
-unsigned long rb_genrand_int32(void);
+unsigned int rb_genrand_int32(void);
double rb_genrand_real(void);
/* re.c */
#define rb_memcmp memcmp
Modified: MacRuby/trunk/include/ruby/ruby.h
===================================================================
--- MacRuby/trunk/include/ruby/ruby.h 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/include/ruby/ruby.h 2010-02-13 06:25:58 UTC (rev 3519)
@@ -580,6 +580,7 @@
}
#define RFLOAT_VALUE(v) (__rb_float_value((VALUE)v))
#define DOUBLE2NUM(dbl) rb_float_new(dbl)
+#define DBL2NUM DOUBLE2NUM
#if WITH_OBJC
struct RFixnum {
@@ -1130,6 +1131,7 @@
RUBY_EXTERN VALUE rb_cISeq;
RUBY_EXTERN VALUE rb_cVM;
RUBY_EXTERN VALUE rb_cEnv;
+RUBY_EXTERN VALUE rb_cRandom;
#if WITH_OBJC
RUBY_EXTERN VALUE rb_cCFString;
Added: MacRuby/trunk/mt.c
===================================================================
--- MacRuby/trunk/mt.c (rev 0)
+++ MacRuby/trunk/mt.c 2010-02-13 06:25:58 UTC (rev 3519)
@@ -0,0 +1,178 @@
+/*
+ * This is based on trimmed version of MT19937. To get the original version,
+ * contact <http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html>.
+ *
+ * The original copyright notice follows.
+ *
+ * A C-program for MT19937, with initialization improved 2002/2/10.
+ * Coded by Takuji Nishimura and Makoto Matsumoto.
+ * This is a faster version by taking Shawn Cokus's optimization,
+ * Matthe Bellew's simplification, Isaku Wada's real version.
+ *
+ * Before using, initialize the state by using init_genrand(mt, seed)
+ * or init_by_array(mt, init_key, key_length).
+ *
+ * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. The names of its contributors may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *
+ * Any feedback is very welcome.
+ * http://www.math.keio.ac.jp/matumoto/emt.html
+ * email: matumoto at math.keio.ac.jp
+ */
+
+#include <limits.h>
+typedef int int_must_be_32bit_at_least[sizeof(int) * CHAR_BIT < 32 ? -1 : 1];
+
+/* Period parameters */
+#define N 624
+#define M 397
+#define MATRIX_A 0x9908b0dfU /* constant vector a */
+#define UMASK 0x80000000U /* most significant w-r bits */
+#define LMASK 0x7fffffffU /* least significant r bits */
+#define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) )
+#define TWIST(u,v) ((MIXBITS(u,v) >> 1) ^ ((v)&1U ? MATRIX_A : 0U))
+
+enum {MT_MAX_STATE = N};
+
+struct MT {
+ /* assume int is enough to store 32bits */
+ unsigned int state[N]; /* the array for the state vector */
+ unsigned int *next;
+ int left;
+};
+
+#define genrand_initialized(mt) ((mt)->next != 0)
+#define uninit_genrand(mt) ((mt)->next = 0)
+
+/* initializes state[N] with a seed */
+static void
+init_genrand(struct MT *mt, unsigned int s)
+{
+ int j;
+ mt->state[0] = s & 0xffffffffU;
+ for (j=1; j<N; j++) {
+ mt->state[j] = (1812433253U * (mt->state[j-1] ^ (mt->state[j-1] >> 30)) + j);
+ /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+ /* In the previous versions, MSBs of the seed affect */
+ /* only MSBs of the array state[]. */
+ /* 2002/01/09 modified by Makoto Matsumoto */
+ mt->state[j] &= 0xffffffff; /* for >32 bit machines */
+ }
+ mt->left = 1;
+ mt->next = mt->state + N;
+}
+
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+static void
+init_by_array(struct MT *mt, unsigned int init_key[], int key_length)
+{
+ int i, j, k;
+ init_genrand(mt, 19650218U);
+ i=1; j=0;
+ k = (N>key_length ? N : key_length);
+ for (; k; k--) {
+ mt->state[i] = (mt->state[i] ^ ((mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1664525U))
+ + init_key[j] + j; /* non linear */
+ mt->state[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
+ i++; j++;
+ if (i>=N) { mt->state[0] = mt->state[N-1]; i=1; }
+ if (j>=key_length) j=0;
+ }
+ for (k=N-1; k; k--) {
+ mt->state[i] = (mt->state[i] ^ ((mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1566083941U))
+ - i; /* non linear */
+ mt->state[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
+ i++;
+ if (i>=N) { mt->state[0] = mt->state[N-1]; i=1; }
+ }
+
+ mt->state[0] = 0x80000000U; /* MSB is 1; assuring non-zero initial array */
+}
+
+static void
+next_state(struct MT *mt)
+{
+ unsigned int *p = mt->state;
+ int j;
+
+ /* if init_genrand() has not been called, */
+ /* a default initial seed is used */
+ if (!genrand_initialized(mt)) init_genrand(mt, 5489U);
+
+ mt->left = N;
+ mt->next = mt->state;
+
+ for (j=N-M+1; --j; p++)
+ *p = p[M] ^ TWIST(p[0], p[1]);
+
+ for (j=M; --j; p++)
+ *p = p[M-N] ^ TWIST(p[0], p[1]);
+
+ *p = p[M-N] ^ TWIST(p[0], mt->state[0]);
+}
+
+/* generates a random number on [0,0xffffffff]-interval */
+static unsigned int
+genrand_int32(struct MT *mt)
+{
+ unsigned int y;
+
+ if (--mt->left <= 0) next_state(mt);
+ y = *mt->next++;
+
+ /* Tempering */
+ y ^= (y >> 11);
+ y ^= (y << 7) & 0x9d2c5680;
+ y ^= (y << 15) & 0xefc60000;
+ y ^= (y >> 18);
+
+ return y;
+}
+
+/* generates a random number on [0,1) with 53-bit resolution*/
+static double
+genrand_real(struct MT *mt)
+{
+ unsigned int a = genrand_int32(mt)>>5, b = genrand_int32(mt)>>6;
+ return(a*67108864.0+b)*(1.0/9007199254740992.0);
+}
+
+/* generates a random number on [0,1] with 53-bit resolution*/
+// TODO
+#define genrand_real2 genrand_real
+
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
+
+#undef N
+#undef M
Modified: MacRuby/trunk/object.c
===================================================================
--- MacRuby/trunk/object.c 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/object.c 2010-02-13 06:25:58 UTC (rev 3519)
@@ -2778,6 +2778,18 @@
return rb_Float(arg);
}
+VALUE
+rb_check_to_float(VALUE val)
+{
+ if (TYPE(val) == T_FLOAT) {
+ return val;
+ }
+ if (!rb_obj_is_kind_of(val, rb_cNumeric)) {
+ return Qnil;
+ }
+ return rb_check_convert_type(val, T_FLOAT, "Float", "to_f");
+}
+
double
rb_num2dbl(VALUE val)
{
Modified: MacRuby/trunk/random.c
===================================================================
--- MacRuby/trunk/random.c 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/random.c 2010-02-13 06:25:58 UTC (rev 3519)
@@ -1,119 +1,412 @@
-/**********************************************************************
+/*
+ * Random Numbers.
+ *
+ * This file is covered by the Ruby license. See COPYING for more details.
+ *
+ * Copyright (C) 2007-2010, Apple Inc. All rights reserved.
+ * Copyright (C) 1993-2007 Yukihiro Matsumoto
+ */
- random.c -
-
- $Author: matz $
- created at: Fri Dec 24 16:39:21 JST 1993
-
- Copyright (C) 1993-2007 Yukihiro Matsumoto
-
-**********************************************************************/
-
#include "ruby/ruby.h"
+#include "ruby/node.h"
+#include "vm.h"
+#include "id.h"
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
-#include <limits.h>
-#include <math.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
-#ifdef HAVE_FCNTL_H
#include <fcntl.h>
-#endif
+#include <math.h>
+#include <errno.h>
-#include "ruby/node.h"
-#include "vm.h"
+#include "mt.c"
+VALUE rb_cRandom;
-static void
-init_random(void)
+typedef struct {
+ VALUE seed;
+ struct MT mt;
+} rb_random_t;
+
+#define get_rnd(obj) ((rb_random_t *)DATA_PTR(obj))
+#define default_rnd() (get_rnd(rb_vm_default_random()))
+
+unsigned int
+rb_genrand_int32(void)
{
- srandomdev();
+ return genrand_int32(&default_rnd()->mt);
}
+double
+rb_genrand_real(void)
+{
+ return genrand_real(&default_rnd()->mt);
+}
+
+#define BDIGITS(x) (RBIGNUM_DIGITS(x))
+#define BITSPERDIG (SIZEOF_BDIGITS*CHAR_BIT)
+#define BIGRAD ((BDIGIT_DBL)1 << BITSPERDIG)
+#define DIGSPERINT (SIZEOF_INT/SIZEOF_BDIGITS)
+#define BIGUP(x) ((BDIGIT_DBL)(x) << BITSPERDIG)
+#define BIGDN(x) RSHIFT(x,BITSPERDIG)
+#define BIGLO(x) ((BDIGIT)((x) & (BIGRAD-1)))
+#define BDIGMAX ((BDIGIT)-1)
+
+#define roomof(n, m) (int)(((n)+(m)-1) / (m))
+#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
+#define SIZEOF_INT32 (31/CHAR_BIT + 1)
+
+static VALUE random_seed(VALUE, SEL);
+
+/* :nodoc: */
static VALUE
-random_number_with_limit(long limit)
+random_alloc(VALUE klass, SEL sel)
{
- long val;
+ rb_random_t *r = (rb_random_t *)xmalloc(sizeof(rb_random_t));
+ r->seed = INT2FIX(0);
+ return Data_Wrap_Struct(rb_cRandom, NULL, NULL, r);
+}
- if (limit == 0) {
- /*
- * #rand(0) needs to generate a float x, such as 0.0 <= x <= 1.0. However,
- * srandom() returns a long. We want to convert that long by divide by RAND_MAX
- */
- val = random();
- return DOUBLE2NUM((double)val / ((unsigned long)RAND_MAX+1));
+static VALUE
+rand_init(struct MT *mt, VALUE vseed)
+{
+ VALUE seed;
+ long blen = 0;
+ int i, j, len;
+ unsigned int buf0[SIZEOF_LONG / SIZEOF_INT32 * 4], *buf = buf0;
+
+ seed = rb_to_int(vseed);
+ switch (TYPE(seed)) {
+ case T_FIXNUM:
+ len = 1;
+ buf[0] = (unsigned int)(FIX2ULONG(seed) & 0xffffffff);
+#if SIZEOF_LONG > SIZEOF_INT32
+ if ((buf[1] = (unsigned int)(FIX2ULONG(seed) >> 32)) != 0) ++len;
+#endif
+ break;
+ case T_BIGNUM:
+ blen = RBIGNUM_LEN(seed);
+ if (blen == 0) {
+ len = 1;
+ }
+ else {
+ if (blen > MT_MAX_STATE * SIZEOF_INT32 / SIZEOF_BDIGITS)
+ blen = (len = MT_MAX_STATE) * SIZEOF_INT32 / SIZEOF_BDIGITS;
+ len = roomof((int)blen * SIZEOF_BDIGITS, SIZEOF_INT32);
+ }
+ /* allocate ints for init_by_array */
+ if (len > numberof(buf0)) buf = ALLOC_N(unsigned int, len);
+ memset(buf, 0, len * sizeof(*buf));
+ len = 0;
+ for (i = (int)(blen-1); 0 <= i; i--) {
+ j = i * SIZEOF_BDIGITS / SIZEOF_INT32;
+#if SIZEOF_BDIGITS < SIZEOF_INT32
+ buf[j] <<= BITSPERDIG;
+#endif
+ buf[j] |= RBIGNUM_DIGITS(seed)[i];
+ if (!len && buf[j]) len = j;
+ }
+ ++len;
+ break;
+ default:
+ rb_raise(rb_eTypeError, "failed to convert %s into Integer",
+ rb_obj_classname(vseed));
}
+ if (len <= 1) {
+ init_genrand(mt, buf[0]);
+ }
else {
- if (limit < 0) {
- /* -LONG_MIN = LONG_MIN, let's avoid that */
- if (limit == LONG_MIN) {
- limit += 1;
- }
- limit = -limit;
- }
- val = random() % limit;
- return LONG2NUM(val);
+ if (buf[len-1] == 1) /* remove leading-zero-guard */
+ len--;
+ init_by_array(mt, buf, len);
}
- return Qnil;
+ return seed;
}
-unsigned long rb_genrand_int32(void);
-
+/*
+ * call-seq: Random.new([seed]) -> prng
+ *
+ * Creates new Mersenne Twister based pseudorandom number generator with
+ * seed. When the argument seed is omitted, the generator is initialized
+ * with Random.seed.
+ *
+ * The argument seed is used to ensure repeatable sequences of random numbers
+ * between different runs of the program.
+ *
+ * prng = Random.new(1234)
+ * [ prng.rand, prng.rand ] #=> [0.191519450378892, 0.622108771039832]
+ * [ prng.integer(10), prng.integer(1000) ] #=> [4, 664]
+ * prng = Random.new(1234)
+ * [ prng.rand, prng.rand ] #=> [0.191519450378892, 0.622108771039832]
+ */
static VALUE
-random_number_with_bignum_limit(struct RBignum *bignum_limit)
+random_init(VALUE obj, SEL sel, int argc, VALUE *argv)
{
- long nb_long_in_bignum;
- long nb_loops;
- struct RBignum *div_result;
- struct RBignum *result;
- int idx;
+ VALUE vseed;
+ rb_random_t *rnd = get_rnd(obj);
- div_result = RBIGNUM(rb_big_div((VALUE)bignum_limit, LONG2NUM(LONG_MAX)));
- // FIXME: Shouldn't use !, what value should I check?
- if (!FIXNUM_P((VALUE)div_result)) {
- rb_raise(rb_eArgError, "max is too huge");
+ if (argc == 0) {
+ vseed = random_seed(0, 0);
}
+ else {
+ rb_scan_args(argc, argv, "01", &vseed);
+ }
+ GC_WB(&rnd->seed, rand_init(&rnd->mt, vseed));
+ return obj;
+}
- nb_long_in_bignum = FIX2LONG((VALUE)div_result);
- nb_loops = 1 + FIX2LONG(random_number_with_limit(nb_long_in_bignum));
- result = RBIGNUM(rb_int2big(0));
- for (idx = 0; idx < nb_loops; idx++) {
- // This creates a bignum on each iteration... Not really good :-/
- result = RBIGNUM(rb_big_plus((VALUE)result, random_number_with_limit(LONG_MAX)));
+#define DEFAULT_SEED_CNT 4
+#define DEFAULT_SEED_LEN (DEFAULT_SEED_CNT * sizeof(int))
+
+static void
+fill_random_seed(unsigned int seed[DEFAULT_SEED_CNT])
+{
+ static int n = 0;
+ struct timeval tv;
+ int fd;
+ struct stat statbuf;
+
+ memset(seed, 0, DEFAULT_SEED_LEN);
+
+ if ((fd = open("/dev/urandom", O_RDONLY
+#ifdef O_NONBLOCK
+ |O_NONBLOCK
+#endif
+#ifdef O_NOCTTY
+ |O_NOCTTY
+#endif
+#ifdef O_NOFOLLOW
+ |O_NOFOLLOW
+#endif
+ )) >= 0) {
+ if (fstat(fd, &statbuf) == 0 && S_ISCHR(statbuf.st_mode)) {
+ (void)read(fd, seed, DEFAULT_SEED_LEN);
+ }
+ close(fd);
}
- return ((VALUE)result);
+
+ gettimeofday(&tv, 0);
+ seed[0] ^= tv.tv_usec;
+ seed[1] ^= (unsigned int)tv.tv_sec;
+#if SIZEOF_TIME_T > SIZEOF_INT
+ seed[0] ^= (unsigned int)((time_t)tv.tv_sec >> SIZEOF_INT * CHAR_BIT);
+#endif
+ seed[2] ^= getpid() ^ (n++ << 16);
+ seed[3] ^= (unsigned int)(VALUE)&seed;
+#if SIZEOF_VOIDP > SIZEOF_INT
+ seed[2] ^= (unsigned int)((VALUE)&seed >> SIZEOF_INT * CHAR_BIT);
+#endif
}
-unsigned long
-rb_genrand_int32(void)
+static VALUE
+make_seed_value(const void *ptr)
{
- unsigned long result;
- short nb_loops;
- int idx;
+ BDIGIT *digits;
+ NEWOBJ(big, struct RBignum);
+ OBJSETUP(big, rb_cBignum, T_BIGNUM);
- result = 0;
- nb_loops = 1 + (random() % 2);
- for (idx = 0; idx < nb_loops; idx++) {
- result += random();
+ RBIGNUM_SET_SIGN(big, 1);
+ rb_big_resize((VALUE)big, DEFAULT_SEED_LEN / SIZEOF_BDIGITS + 1);
+ digits = RBIGNUM_DIGITS(big);
+
+ MEMCPY(digits, ptr, char, DEFAULT_SEED_LEN);
+
+ /* set leading-zero-guard if need. */
+ digits[RBIGNUM_LEN(big)-1] = digits[RBIGNUM_LEN(big)-2] <= 1 ? 1 : 0;
+
+ return rb_big_norm((VALUE)big);
+}
+
+/*
+ * call-seq: Random.seed -> integer
+ *
+ * Returns arbitrary value for seed.
+ */
+static VALUE
+random_seed(VALUE rcv, SEL sel)
+{
+ unsigned int buf[DEFAULT_SEED_CNT];
+ fill_random_seed(buf);
+ return make_seed_value(buf);
+}
+
+/*
+ * call-seq: prng.seed -> integer
+ *
+ * Returns the seed of the generator.
+ */
+static VALUE
+random_get_seed(VALUE obj, SEL sel)
+{
+ return get_rnd(obj)->seed;
+}
+
+/* :nodoc: */
+static VALUE
+random_copy(VALUE obj, SEL sel, VALUE orig)
+{
+ rb_random_t *rnd1 = get_rnd(obj);
+ rb_random_t *rnd2 = get_rnd(orig);
+ struct MT *mt = &rnd1->mt;
+
+ *rnd1 = *rnd2;
+ GC_WB(&rnd1->seed, rnd2->seed);
+ mt->next = mt->state + numberof(mt->state) - mt->left + 1;
+ return obj;
+}
+
+static VALUE
+mt_state(const struct MT *mt)
+{
+ const int n = numberof(mt->state);
+ VALUE bigo = rb_big_new(n, 1);
+ BDIGIT *d = RBIGNUM_DIGITS(bigo);
+ for (int i = 0; i < n; i++) {
+ unsigned int x = mt->state[i];
+ *d++ = (BDIGIT)x;
}
- return result;
+ return rb_big_norm(bigo);
}
-double
-rb_genrand_real(void)
+/* :nodoc: */
+static VALUE
+random_state(VALUE obj, SEL sel)
{
- return NUM2DBL(random_number_with_limit(0));
+ rb_random_t *rnd = get_rnd(obj);
+ return mt_state(&rnd->mt);
}
+/* :nodoc: */
+static VALUE
+random_s_state(VALUE klass, SEL sel)
+{
+ return mt_state(&default_rnd()->mt);
+}
+
+/* :nodoc: */
+static VALUE
+random_left(VALUE obj, SEL sel)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ return INT2FIX(rnd->mt.left);
+}
+
+/* :nodoc: */
+static VALUE
+random_s_left(VALUE klass, SEL sel)
+{
+ return INT2FIX(default_rnd()->mt.left);
+}
+
+/* :nodoc: */
+static VALUE
+random_dump(VALUE obj, SEL sel)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ VALUE dump = rb_ary_new2(3);
+
+ rb_ary_push(dump, mt_state(&rnd->mt));
+ rb_ary_push(dump, INT2FIX(rnd->mt.left));
+ rb_ary_push(dump, rnd->seed);
+
+ return dump;
+}
+
+/* :nodoc: */
+static VALUE
+random_load(VALUE obj, SEL sel, VALUE dump)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ struct MT *mt = &rnd->mt;
+ VALUE state, left = INT2FIX(1), seed = INT2FIX(0);
+ unsigned long x;
+
+ Check_Type(dump, T_ARRAY);
+ switch (RARRAY_LEN(dump)) {
+ case 3:
+ seed = RARRAY_AT(dump, 2);
+ case 2:
+ left = RARRAY_AT(dump, 1);
+ case 1:
+ state = RARRAY_AT(dump, 0);
+ break;
+ default:
+ rb_raise(rb_eArgError, "wrong dump data");
+ }
+ memset(mt->state, 0, sizeof(mt->state));
+#if 0
+ if (FIXNUM_P(state)) {
+ x = FIX2ULONG(state);
+ mt->state[0] = (unsigned int)x;
+#if SIZEOF_LONG / SIZEOF_INT >= 2
+ mt->state[1] = (unsigned int)(x >> BITSPERDIG);
+#endif
+#if SIZEOF_LONG / SIZEOF_INT >= 3
+ mt->state[2] = (unsigned int)(x >> 2 * BITSPERDIG);
+#endif
+#if SIZEOF_LONG / SIZEOF_INT >= 4
+ mt->state[3] = (unsigned int)(x >> 3 * BITSPERDIG);
+#endif
+ }
+ else {
+ BDIGIT *d;
+ long len;
+ Check_Type(state, T_BIGNUM);
+ len = RBIGNUM_LEN(state);
+ if (len > roomof(sizeof(mt->state), SIZEOF_BDIGITS)) {
+ len = roomof(sizeof(mt->state), SIZEOF_BDIGITS);
+ }
+#if SIZEOF_BDIGITS < SIZEOF_INT
+ else if (len % DIGSPERINT) {
+ d = RBIGNUM_DIGITS(state) + len;
+# if DIGSPERINT == 2
+ --len;
+ x = *--d;
+# else
+ x = 0;
+ do {
+ x = (x << BITSPERDIG) | *--d;
+ } while (--len % DIGSPERINT);
+# endif
+ mt->state[len / DIGSPERINT] = (unsigned int)x;
+ }
+#endif
+ if (len > 0) {
+ d = BDIGITS(state) + len;
+ do {
+ --len;
+ x = *--d;
+# if DIGSPERINT == 2
+ --len;
+ x = (x << BITSPERDIG) | *--d;
+# elif SIZEOF_BDIGITS < SIZEOF_INT
+ do {
+ x = (x << BITSPERDIG) | *--d;
+ } while (--len % DIGSPERINT);
+# endif
+ mt->state[len / DIGSPERINT] = (unsigned int)x;
+ } while (len > 0);
+ }
+ }
+#endif
+ x = NUM2ULONG(left);
+ if (x > numberof(mt->state)) {
+ rb_raise(rb_eArgError, "wrong value");
+ }
+ mt->left = (unsigned int)x;
+ mt->next = mt->state + numberof(mt->state) - x + 1;
+ GC_WB(&rnd->seed, rb_to_int(seed));
+
+ return obj;
+}
+
/*
* call-seq:
* srand(number=0) => old_seed
- *
+ *
* Seeds the pseudorandom number generator to the value of
- * <i>number</i>.<code>to_i.abs</code>. If <i>number</i> is omitted
+ * <i>number</i>. If <i>number</i> is omitted
* or zero, seeds the generator using a combination of the time, the
* process id, and a sequence number. (This is also the behavior if
* <code>Kernel::rand</code> is called without previously calling
@@ -125,55 +418,378 @@
static VALUE
rb_f_srand(VALUE obj, SEL sel, int argc, VALUE *argv)
{
- VALUE old_seed;
- VALUE seed_param;
- VALUE seed_int;
- unsigned seed = 0;
+ VALUE seed, old;
+ rb_random_t *r = default_rnd();
+ rb_secure(4);
if (argc == 0) {
- srandomdev();
- seed = (unsigned)random();
- seed_int = UINT2NUM(seed);
+ seed = random_seed(0, 0);
}
else {
- rb_scan_args(argc, argv, "01", &seed_param);
- seed_int = rb_to_int(seed_param);
- switch (TYPE(seed_int)) {
- case T_BIGNUM:
- // In case we need to keep 'seed.to_i.abs'
- /*
- if (RBIGNUM_NEGATIVE_P(seed_int)) {
- seed_int = rb_big_uminus(seed_int);
+ rb_scan_args(argc, argv, "01", &seed);
+ }
+ old = r->seed;
+ GC_WB(&r->seed, rand_init(&r->mt, seed));
+
+ return old;
+}
+
+static unsigned long
+make_mask(unsigned long x)
+{
+ x = x | x >> 1;
+ x = x | x >> 2;
+ x = x | x >> 4;
+ x = x | x >> 8;
+ x = x | x >> 16;
+#if 4 < SIZEOF_LONG
+ x = x | x >> 32;
+#endif
+ return x;
+}
+
+static unsigned long
+limited_rand(struct MT *mt, unsigned long limit)
+{
+ if (limit == 0) {
+ return 0;
+ }
+ unsigned long val, mask = make_mask(limit);
+retry:
+ val = 0;
+ for (int i = SIZEOF_LONG / SIZEOF_INT32 - 1; 0 <= i; i--) {
+ if ((mask >> (i * 32)) & 0xffffffff) {
+ val |= (unsigned long)genrand_int32(mt) << (i * 32);
+ val &= mask;
+ if (limit < val) {
+ goto retry;
}
- */
- for (int i = 0; i < RBIGNUM_LEN(seed_int); i++) {
- seed += (unsigned int)RBIGNUM_DIGITS(seed_int)[i];
+ }
+ }
+ return val;
+}
+
+static VALUE
+limited_big_rand(struct MT *mt, struct RBignum *limit)
+{
+ const long len = (RBIGNUM_LEN(limit) * SIZEOF_BDIGITS + 3) / 4;
+ struct RBignum *val = (struct RBignum *)rb_big_clone((VALUE)limit);
+ RBIGNUM_SET_SIGN(val, 1);
+#if SIZEOF_BDIGITS == 2
+# define BIG_GET32(big,i) \
+ (RBIGNUM_DIGITS(big)[(i)*2] | \
+ ((i)*2+1 < RBIGNUM_LEN(big) ? \
+ (RBIGNUM_DIGITS(big)[(i)*2+1] << 16) : \
+ 0))
+# define BIG_SET32(big,i,d) \
+ ((RBIGNUM_DIGITS(big)[(i)*2] = (d) & 0xffff), \
+ ((i)*2+1 < RBIGNUM_LEN(big) ? \
+ (RBIGNUM_DIGITS(big)[(i)*2+1] = (d) >> 16) : \
+ 0))
+#else
+ /* SIZEOF_BDIGITS == 4 */
+# define BIG_GET32(big,i) (RBIGNUM_DIGITS(big)[i])
+# define BIG_SET32(big,i,d) (RBIGNUM_DIGITS(big)[i] = (d))
+#endif
+ unsigned long mask;
+ int boundary;
+retry:
+ mask = 0;
+ boundary = 1;
+ for (long i = len - 1; 0 <= i; i--) {
+ const unsigned long lim = BIG_GET32(limit, i);
+ unsigned long rnd;
+ mask = mask != 0 ? 0xffffffff : make_mask(lim);
+ if (mask != 0) {
+ rnd = genrand_int32(mt) & mask;
+ if (boundary) {
+ if (lim < rnd) {
+ goto retry;
+ }
+ if (rnd < lim) {
+ boundary = 0;
+ }
+ }
+ }
+ else {
+ rnd = 0;
+ }
+ BIG_SET32(val, i, (BDIGIT)rnd);
+ }
+ return rb_big_norm((VALUE)val);
+}
+
+unsigned long
+rb_rand_internal(unsigned long i)
+{
+ struct MT *mt = &default_rnd()->mt;
+ if (!genrand_initialized(mt)) {
+ rand_init(mt, random_seed(0, 0));
+ }
+ return limited_rand(mt, i);
+}
+
+unsigned int
+rb_random_int32(VALUE obj)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ return genrand_int32(&rnd->mt);
+}
+
+double
+rb_random_real(VALUE obj)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ return genrand_real(&rnd->mt);
+}
+
+/*
+ * call-seq: prng.bytes(size) -> prng
+ *
+ * Returns a random binary string. The argument size specified the length of
+ * the result string.
+ */
+static VALUE
+random_bytes(VALUE obj, SEL sel, VALUE len)
+{
+ long n = NUM2LONG(rb_to_int(len));
+ if (n <= 0) {
+ return rb_str_new2("");
+ }
+ rb_random_t *rnd = get_rnd(obj);
+ UInt8 *ptr = (UInt8 *)malloc(n);
+ unsigned int r = genrand_int32(&rnd->mt);
+ for (long i = 0; i < n; i++) {
+ ptr[i] = (char)r;
+ r >>= CHAR_BIT;
+ }
+ VALUE bytes = rb_bytestring_new_with_data(ptr, n);
+ free(ptr);
+ return bytes;
+}
+
+static VALUE
+range_values(VALUE vmax, VALUE *begp, int *exclp)
+{
+ VALUE end;
+ if (!rb_range_values(vmax, begp, &end, exclp)) {
+ return Qfalse;
+ }
+ if (!rb_vm_respond_to(end, selMINUS, false)) {
+ return Qfalse;
+ }
+ VALUE r = rb_vm_call(end, selMINUS, 1, begp, false);
+ if (NIL_P(r)) {
+ return Qfalse;
+ }
+ return r;
+}
+
+static VALUE
+rand_int(struct MT *mt, VALUE vmax, int restrictive)
+{
+ long max;
+ unsigned long r;
+
+ if (FIXNUM_P(vmax)) {
+ max = FIX2LONG(vmax);
+ if (!max) return Qnil;
+ if (max < 0) {
+ if (restrictive) return Qnil;
+ max = -max;
+ }
+ r = limited_rand(mt, (unsigned long)max - 1);
+ return ULONG2NUM(r);
+ }
+ else {
+ VALUE ret;
+ if (rb_bigzero_p(vmax)) return Qnil;
+ if (!RBIGNUM_SIGN(vmax)) {
+ if (restrictive) return Qnil;
+ vmax = rb_big_clone(vmax);
+ RBIGNUM_SET_SIGN(vmax, 1);
+ }
+ vmax = rb_big_minus(vmax, INT2FIX(1));
+ if (FIXNUM_P(vmax)) {
+ max = FIX2LONG(vmax);
+ if (max == -1) return Qnil;
+ r = limited_rand(mt, max);
+ return LONG2NUM(r);
+ }
+ ret = limited_big_rand(mt, RBIGNUM(vmax));
+ return ret;
+ }
+}
+
+static inline double
+float_value(VALUE v)
+{
+ double x = RFLOAT_VALUE(v);
+ if (isinf(x) || isnan(x)) {
+ VALUE error = INT2FIX(EDOM);
+ rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
+ }
+ return x;
+}
+
+/*
+ * call-seq:
+ * prng.rand -> float
+ * prng.rand(limit) -> number
+ *
+ * When the argument is an +Integer+ or a +Bignum+, it returns a
+ * random integer greater than or equal to zero and less than the
+ * argument. Unlike Random.rand, when the argument is a negative
+ * integer or zero, it raises an ArgumentError.
+ *
+ * When the argument is a +Float+, it returns a random floating point
+ * number between 0.0 and _max_, including 0.0 and excluding _max_.
+ *
+ * When the argument _limit_ is a +Range+, it returns a random
+ * number where range.member?(number) == true.
+ * prng.rand(5..9) # => one of [5, 6, 7, 8, 9]
+ * prng.rand(5...9) # => one of [5, 6, 7, 8]
+ * prng.rand(5.0..9.0) # => between 5.0 and 9.0, including 9.0
+ * prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
+ *
+ * +begin+/+end+ of the range have to have subtract and add methods.
+ *
+ * Otherwise, it raises an ArgumentError.
+ */
+static VALUE
+random_rand(VALUE obj, SEL sel, int argc, VALUE *argv)
+{
+ rb_random_t *rnd = get_rnd(obj);
+ VALUE beg = Qundef, v;
+ int excl = 0;
+
+ if (argc == 0) {
+zero_arg:
+ return rb_float_new(genrand_real(&rnd->mt));
+ }
+ else if (argc != 1) {
+ rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
+ }
+ VALUE vmax = argv[0];
+ if (NIL_P(vmax)) {
+ goto zero_arg;
+ }
+ else if (TYPE(vmax) != T_FLOAT
+ && (v = rb_check_to_integer(vmax, "to_int"), !NIL_P(v))) {
+ v = rand_int(&rnd->mt, vmax = v, 1);
+ }
+ else if (v = rb_check_to_float(vmax), !NIL_P(v)) {
+ const double max = float_value(v);
+ if (max > 0.0) {
+ v = rb_float_new(max * genrand_real(&rnd->mt));
+ }
+ else {
+ v = Qnil;
+ }
+ }
+ else if ((v = range_values(vmax, &beg, &excl)) != Qfalse) {
+ vmax = v;
+ if (TYPE(vmax) != T_FLOAT
+ && (v = rb_check_to_integer(vmax, "to_int"), !NIL_P(v))) {
+ long max;
+ vmax = v;
+ v = Qnil;
+ if (FIXNUM_P(vmax)) {
+fixnum:
+ if ((max = FIX2LONG(vmax) - excl) >= 0) {
+ unsigned long r = limited_rand(&rnd->mt, (unsigned long)max);
+ v = ULONG2NUM(r);
+ }
}
- break ;
- case T_FIXNUM:
- // In case we need to keep 'seed.to_i.abs'
- /*
- if (FIX2LONG(seed_int) < 0) {
- seed_int = rb_fix_uminus(seed_int);
+ else if (BUILTIN_TYPE(vmax) == T_BIGNUM && RBIGNUM_SIGN(vmax)
+ && !rb_bigzero_p(vmax)) {
+ vmax = excl ? rb_big_minus(vmax, INT2FIX(1)) : rb_big_norm(vmax);
+ if (FIXNUM_P(vmax)) {
+ excl = 0;
+ goto fixnum;
+ }
+ v = limited_big_rand(&rnd->mt, RBIGNUM(vmax));
}
- */
- seed = (unsigned int)FIX2LONG(seed_int);
- break ;
}
+ else if (v = rb_check_to_float(vmax), !NIL_P(v)) {
+ double max = float_value(v), r;
+ v = Qnil;
+ if (max > 0.0) {
+ if (excl) {
+ r = genrand_real(&rnd->mt);
+ }
+ else {
+ r = genrand_real2(&rnd->mt);
+ }
+ v = rb_float_new(r * max);
+ }
+ else if (max == 0.0 && !excl) {
+ v = rb_float_new(0.0);
+ }
+ }
}
- srandom(seed);
+ else {
+ v = Qnil;
+ NUM2LONG(vmax);
+ }
+ if (NIL_P(v)) {
+ VALUE mesg = rb_str_new2("invalid argument - ");
+ rb_str_append(mesg, rb_obj_as_string(argv[0]));
+ rb_exc_raise(rb_exc_new3(rb_eArgError, mesg));
+ }
+ if (beg == Qundef) {
+ return v;
+ }
+ if (FIXNUM_P(beg) && FIXNUM_P(v)) {
+ long x = FIX2LONG(beg) + FIX2LONG(v);
+ return LONG2NUM(x);
+ }
+ switch (TYPE(v)) {
+ case T_BIGNUM:
+ return rb_big_plus(v, beg);
+ case T_FLOAT:
+ {
+ double d = RFLOAT_VALUE(v) + RFLOAT_VALUE(rb_check_to_float(beg));
+ return DOUBLE2NUM(d);
+ }
+ default:
+ return rb_vm_call(v, selPLUS, 1, &beg, false);
+ }
+}
- old_seed = rb_vm_rand_seed();
- // Ruby's behaviour is weird. It stores the 'seed.to_i' value, instead of
- // the 'seed.to_i.abs' value, or just 'seed'. Which one should we use?
- rb_vm_set_rand_seed(seed_int);
- return old_seed;
+/*
+ * call-seq:
+ * prng1 == prng2 -> true or false
+ *
+ * Returns true if the generators' states equal.
+ */
+static VALUE
+random_equal(VALUE self, SEL sel, VALUE other)
+{
+ if (rb_obj_class(self) != rb_obj_class(other)) {
+ return Qfalse;
+ }
+ rb_random_t *r1 = get_rnd(self);
+ rb_random_t *r2 = get_rnd(other);
+ if (rb_equal(r1->seed, r2->seed) != Qtrue) {
+ return Qfalse;
+ }
+ if (memcmp(r1->mt.state, r2->mt.state, sizeof(r1->mt.state))) {
+ return Qfalse;
+ }
+ if ((r1->mt.next - r1->mt.state) != (r2->mt.next - r2->mt.state)) {
+ return Qfalse;
+ }
+ if (r1->mt.left != r2->mt.left) {
+ return Qfalse;
+ }
+ return Qtrue;
}
/*
* call-seq:
* rand(max=0) => number
- *
+ *
* Converts <i>max</i> to an integer using max1 =
* max<code>.to_i.abs</code>. If the result is zero, returns a
* pseudorandom floating point number greater than or equal to 0.0 and
@@ -182,7 +798,7 @@
* may be used to ensure repeatable sequences of random numbers between
* different runs of the program. Ruby currently uses a modified
* Mersenne Twister with a period of 2**19937-1.
- *
+ *
* srand 1234 #=> 0
* [ rand, rand ] #=> [0.191519450163469, 0.49766366626136]
* [ rand(10), rand(1000) ] #=> [6, 817]
@@ -193,54 +809,68 @@
static VALUE
rb_f_rand(VALUE obj, SEL sel, int argc, VALUE *argv)
{
- VALUE arg_max;
- long max;
+ struct MT *mt = &default_rnd()->mt;
- rb_scan_args(argc, argv, "01", &arg_max);
- switch (TYPE(arg_max)) {
- case T_FLOAT:
- if (RFLOAT_VALUE(arg_max) <= LONG_MAX && RFLOAT_VALUE(arg_max) >= LONG_MIN) {
- max = (long)RFLOAT_VALUE(arg_max);
- break;
- }
- if (RFLOAT_VALUE(arg_max) < 0)
- arg_max = rb_dbl2big(-RFLOAT_VALUE(arg_max));
- else
- arg_max = rb_dbl2big(RFLOAT_VALUE(arg_max));
- /* fall through */
- case T_BIGNUM:
- bignum:
- {
- struct RBignum *limit = (struct RBignum *)arg_max;
- if (!RBIGNUM_SIGN(limit)) {
- limit = (struct RBignum *)rb_big_clone(arg_max);
- RBIGNUM_SET_SIGN(limit, 1);
- }
- limit = (struct RBignum *)rb_big_minus((VALUE)limit, INT2FIX(1));
- if (FIXNUM_P((VALUE)limit)) {
- max = FIX2LONG((VALUE)limit) + 1;
- break;
- }
- return random_number_with_bignum_limit(limit);
- }
- case T_NIL:
- max = 0;
- break;
- default:
- arg_max = rb_Integer(arg_max);
- if (TYPE(arg_max) == T_BIGNUM) goto bignum;
- case T_FIXNUM:
- max = FIX2LONG(arg_max);
- break;
+ if (!genrand_initialized(mt)) {
+ rand_init(mt, random_seed(0, 0));
}
+ if (argc == 0) {
+ goto zero_arg;
+ }
+ VALUE vmax;
+ rb_scan_args(argc, argv, "01", &vmax);
+ if (NIL_P(vmax)) {
+ goto zero_arg;
+ }
+ vmax = rb_to_int(vmax);
+ VALUE r;
+ if (vmax == INT2FIX(0) || NIL_P(r = rand_int(mt, vmax, 0))) {
+zero_arg:
+ return DBL2NUM(genrand_real(mt));
+ }
+ return r;
+}
- return random_number_with_limit(max);
+static void
+Init_RandomSeed(void)
+{
+ VALUE random = random_alloc(0, 0);
+ unsigned int initial[DEFAULT_SEED_CNT];
+ GC_WB(&get_rnd(random)->seed, make_seed_value(initial));
+ rb_vm_set_default_random(random);
}
void
+rb_reset_random_seed(void)
+{
+ rb_random_t *r = default_rnd();
+ uninit_genrand(&r->mt);
+ r->seed = INT2FIX(0);
+}
+
+void
Init_Random(void)
{
- init_random();
+ Init_RandomSeed();
rb_objc_define_module_function(rb_mKernel, "srand", rb_f_srand, -1);
rb_objc_define_module_function(rb_mKernel, "rand", rb_f_rand, -1);
+
+ rb_cRandom = rb_define_class("Random", rb_cObject);
+ rb_objc_define_method(*(VALUE *)rb_cRandom, "alloc", random_alloc, 0);
+ rb_objc_define_method(rb_cRandom, "initialize", random_init, -1);
+ rb_objc_define_method(rb_cRandom, "rand", random_rand, -1);
+ rb_objc_define_method(rb_cRandom, "bytes", random_bytes, 1);
+ rb_objc_define_method(rb_cRandom, "seed", random_get_seed, 0);
+ rb_objc_define_method(rb_cRandom, "initialize_copy", random_copy, 1);
+ rb_objc_define_method(rb_cRandom, "marshal_dump", random_dump, 0);
+ rb_objc_define_method(rb_cRandom, "marshal_load", random_load, 1);
+ rb_objc_define_private_method(rb_cRandom, "state", random_state, 0);
+ rb_objc_define_private_method(rb_cRandom, "left", random_left, 0);
+ rb_objc_define_method(rb_cRandom, "==", random_equal, 1);
+
+ rb_objc_define_method(*(VALUE *)rb_cRandom, "srand", rb_f_srand, -1);
+ rb_objc_define_method(*(VALUE *)rb_cRandom, "rand", rb_f_rand, -1);
+ rb_objc_define_method(*(VALUE *)rb_cRandom, "new_seed", random_seed, 0);
+ rb_objc_define_private_method(*(VALUE *)rb_cRandom, "state", random_s_state, 0);
+ rb_objc_define_private_method(*(VALUE *)rb_cRandom, "left", random_s_left, 0);
}
Modified: MacRuby/trunk/range.c
===================================================================
--- MacRuby/trunk/range.c 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/range.c 2010-02-13 06:25:58 UTC (rev 3519)
@@ -624,6 +624,34 @@
*exclude = EXCL(range);
}
+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_vm_respond_to(range, selBeg, false)) {
+ return Qfalse;
+ }
+ if (!rb_vm_respond_to(range, selEnd, false)) {
+ return Qfalse;
+ }
+ b = rb_vm_call(range, selBeg, 0, NULL, false);
+ e = rb_vm_call(range, selEnd, 0, NULL, false);
+ excl = RTEST(rb_vm_call(range, selExcludeEnd, 0, NULL, false));
+ }
+ *begp = b;
+ *endp = e;
+ *exclp = excl;
+ return 1;
+}
+
VALUE
rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
{
Modified: MacRuby/trunk/vm.cpp
===================================================================
--- MacRuby/trunk/vm.cpp 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/vm.cpp 2010-02-13 06:25:58 UTC (rev 3519)
@@ -266,8 +266,8 @@
pthread_assert(pthread_mutex_init(&gl, 0));
- // Fixnum is an immediate type, no need to retain
- rand_seed = INT2FIX(0);
+ // Will be set later.
+ default_random = Qnil;
load_path = rb_ary_new();
rb_objc_retain((void *)load_path);
@@ -1087,29 +1087,22 @@
extern "C"
VALUE
-rb_vm_rand_seed(void)
+rb_vm_default_random(void)
{
- VALUE rand_seed;
- RoxorCore *core = GET_CORE();
-
- core->lock();
- rand_seed = core->get_rand_seed();
- core->unlock();
-
- return rand_seed;
+ return GET_CORE()->get_default_random();
}
extern "C"
void
-rb_vm_set_rand_seed(VALUE rand_seed)
+rb_vm_set_default_random(VALUE random)
{
RoxorCore *core = GET_CORE();
core->lock();
- if (core->get_rand_seed() != rand_seed) {
- GC_RELEASE(core->get_rand_seed());
- GC_RETAIN(rand_seed);
- core->set_rand_seed(rand_seed);
+ if (core->get_default_random() != random) {
+ GC_RELEASE(core->get_default_random());
+ GC_RETAIN(random);
+ core->set_default_random(random);
}
core->unlock();
}
@@ -1117,12 +1110,9 @@
VALUE
RoxorCore::trap_cmd_for_signal(int signal)
{
- VALUE trap;
-
- this->lock();
- trap = this->trap_cmd[signal];
- this->unlock();
-
+ lock();
+ VALUE trap = trap_cmd[signal];
+ unlock();
return trap;
}
@@ -1136,12 +1126,9 @@
int
RoxorCore::trap_level_for_signal(int signal)
{
- VALUE trap;
-
- this->lock();
- trap = this->trap_level[signal];
- this->unlock();
-
+ lock();
+ VALUE trap = trap_level[signal];
+ unlock();
return trap;
}
@@ -1155,17 +1142,15 @@
void
RoxorCore::set_trap_for_signal(VALUE trap, int level, int signal)
{
- VALUE oldtrap;
-
- this->lock();
- oldtrap = this->trap_cmd[signal];
+ lock();
+ VALUE oldtrap = trap_cmd[signal];
if (oldtrap != trap) {
GC_RELEASE(oldtrap);
GC_RETAIN(trap);
- this->trap_cmd[signal] = trap;
- this->trap_level[signal] = level;
+ trap_cmd[signal] = trap;
+ trap_level[signal] = level;
}
- this->unlock();
+ unlock();
}
extern "C"
Modified: MacRuby/trunk/vm.h
===================================================================
--- MacRuby/trunk/vm.h 2010-02-12 22:15:21 UTC (rev 3518)
+++ MacRuby/trunk/vm.h 2010-02-13 06:25:58 UTC (rev 3519)
@@ -266,8 +266,8 @@
void rb_vm_init_compiler(void);
bool rb_vm_running(void);
void rb_vm_set_running(bool flag);
-VALUE rb_vm_rand_seed(void);
-void rb_vm_set_rand_seed(VALUE rand_seed);
+VALUE rb_vm_default_random(void);
+void rb_vm_set_default_random(VALUE rand);
bool rb_vm_parse_in_eval(void);
void rb_vm_set_parse_in_eval(bool flag);
VALUE rb_vm_load_path(void);
@@ -609,7 +609,7 @@
bool abort_on_exception;
VALUE loaded_features;
VALUE load_path;
- VALUE rand_seed;
+ VALUE default_random;
// Signals
std::map<int, VALUE> trap_cmd;
@@ -674,7 +674,7 @@
ACCESSOR(running, bool);
ACCESSOR(multithreaded, bool);
ACCESSOR(abort_on_exception, bool);
- ACCESSOR(rand_seed, VALUE);
+ ACCESSOR(default_random, VALUE);
READER(loaded_features, VALUE);
READER(load_path, VALUE);
READER(threads, VALUE);
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.macosforge.org/pipermail/macruby-changes/attachments/20100212/48afaba0/attachment-0001.html>
More information about the macruby-changes
mailing list