12#include "ruby/internal/config.h"
31#if defined(HAVE_SYS_TIME_H)
37#elif defined HAVE_SYS_SYSCALL_H
38# include <sys/syscall.h>
48#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__)
50# include <sys/param.h>
53#if defined HAVE_GETRANDOM || defined HAVE_GETENTROPY
54# if defined(HAVE_SYS_RANDOM_H)
55# include <sys/random.h>
57#elif defined __linux__ && defined __NR_getrandom
58# include <linux/random.h>
62# include <AvailabilityMacros.h>
66#include "internal/array.h"
67#include "internal/compilers.h"
68#include "internal/numeric.h"
69#include "internal/random.h"
70#include "internal/sanitizers.h"
71#include "internal/variable.h"
72#include "ruby_atomic.h"
76typedef int int_must_be_32bit_at_least[
sizeof(int) * CHAR_BIT < 32 ? -1 : 1];
78#include "missing/mt19937.c"
81static double int_pair_to_real_exclusive(uint32_t a, uint32_t b);
83genrand_real(
struct MT *mt)
86 unsigned int a = genrand_int32(mt), b = genrand_int32(mt);
87 return int_pair_to_real_exclusive(a, b);
90static const double dbl_reduce_scale =
92 / (double)(DBL_MANT_DIG > 2*31 ? (1ul<<31) : 1.0)
93 / (
double)(DBL_MANT_DIG > 1*31 ? (1ul<<31) : 1.0)
94 / (double)(1ul<<(DBL_MANT_DIG%31)));
97int_pair_to_real_exclusive(uint32_t a, uint32_t b)
99 static const int a_shift = DBL_MANT_DIG < 64 ?
100 (64-DBL_MANT_DIG)/2 : 0;
101 static const int b_shift = DBL_MANT_DIG < 64 ?
102 (65-DBL_MANT_DIG)/2 : 0;
105 return (a*(
double)(1ul<<(32-b_shift))+b)*dbl_reduce_scale;
109static double int_pair_to_real_inclusive(uint32_t a, uint32_t b);
112genrand_real2(
struct MT *mt)
115 uint32_t a = genrand_int32(mt), b = genrand_int32(mt);
116 return int_pair_to_real_inclusive(a, b);
130#define DEFAULT_SEED_CNT 4
134static void fill_random_seed(uint32_t *seed,
size_t cnt);
135static VALUE make_seed_value(uint32_t *ptr,
size_t len);
139 DEFAULT_SEED_CNT * 32,
146 if (!genrand_initialized(&r->mt)) {
147 r->base.
seed = rand_init(&random_mt_if, &r->base, random_seed(
Qundef));
155 return &rand_mt_start(r)->base;
161rb_free_default_rand_key(
void)
163 xfree(default_rand_key);
167default_rand_mark(
void *ptr)
170 rb_gc_mark(rnd->base.
seed);
194 return rand_mt_start(default_rand());
200 struct MT *mt = &default_mt()->mt;
201 return genrand_int32(mt);
207 struct MT *mt = &default_mt()->mt;
208 return genrand_real(mt);
211#define SIZEOF_INT32 (31/CHAR_BIT + 1)
214int_pair_to_real_inclusive(uint32_t a, uint32_t b)
217 enum {dig = DBL_MANT_DIG};
218 enum {dig_u = dig-32, dig_r64 = 64-dig, bmask = ~(~0u<<(dig_r64))};
219#if defined HAVE_UINT128_T
220 const uint128_t m = ((uint128_t)1 << dig) | 1;
221 uint128_t x = ((uint128_t)a << 32) | b;
222 r = (double)(uint64_t)((x * m) >> 64);
223#elif defined HAVE_UINT64_T && !MSC_VERSION_BEFORE(1300)
224 uint64_t x = ((uint64_t)a << dig_u) +
225 (((uint64_t)b + (a >> dig_u)) >> dig_r64);
229 b = (b >> dig_r64) + (((a >> dig_u) + (b & bmask)) >> dig_r64);
230 r = (double)a * (1 << dig_u) + b;
232 return r * dbl_reduce_scale;
238static ID id_rand, id_bytes;
239NORETURN(
static void domain_error(
void));
242#define random_mark rb_random_mark
245random_mark(
void *ptr)
250#define random_free RUBY_TYPED_DEFAULT_FREE
253random_memsize(
const void *ptr)
265 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
268#define random_mt_mark rb_random_mark
269#define random_mt_free RUBY_TYPED_DEFAULT_FREE
272random_mt_memsize(
const void *ptr)
284 &rb_random_data_type,
285 (
void *)&random_mt_if,
286 RUBY_TYPED_FREE_IMMEDIATELY
308try_get_rnd(
VALUE obj)
311 return rand_start(default_rand());
318 rb_raise(rb_eArgError,
"uninitialized random: %s",
327 if (rnd == &default_rand()->base) {
328 return &random_mt_if;
342random_alloc(
VALUE klass)
353 VALUE seed, buf0 = 0;
357 fill_random_seed(buf,
len);
359 seed = make_seed_value(buf,
len);
360 explicit_bzero(buf,
len *
sizeof(*buf));
373 len = rb_absint_numwords(seed, 32, NULL);
376 sign = rb_integer_pack(seed, buf,
len,
sizeof(uint32_t), 0,
384 if (sign != 2 && buf[
len-1] == 1)
388 explicit_bzero(buf,
len *
sizeof(*buf));
413 unsigned int major = rng->
version.major;
414 unsigned int minor = rng->
version.minor;
415 if (major != RUBY_RANDOM_INTERFACE_VERSION_MAJOR) {
417 STRINGIZE(RUBY_RANDOM_INTERFACE_VERSION_MAJOR)
"."
418 STRINGIZE(RUBY_RANDOM_INTERFACE_VERSION_MINOR)
" "
419 "expected: %d.%d", major, minor);
424 rnd->
seed = rand_init_default(rng, rnd);
432#define DEFAULT_SEED_LEN (DEFAULT_SEED_CNT * (int)sizeof(int32_t))
434#if defined(S_ISCHR) && !defined(DOSISH)
435# define USE_DEV_URANDOM 1
437# define USE_DEV_URANDOM 0
440#ifdef HAVE_GETENTROPY
441# define MAX_SEED_LEN_PER_READ 256
443fill_random_bytes_urandom(
void *seed,
size_t size)
445 unsigned char *p = (
unsigned char *)seed;
447 size_t len = size < MAX_SEED_LEN_PER_READ ? size : MAX_SEED_LEN_PER_READ;
448 if (getentropy(p,
len) != 0) {
458fill_random_bytes_urandom(
void *seed,
size_t size)
477 if (fd < 0)
return -1;
479 if (fstat(fd, &statbuf) == 0 && S_ISCHR(statbuf.st_mode)) {
481 ret = read(fd, ((
char*)seed) + offset, size - offset);
486 offset += (size_t)ret;
487 }
while (offset < size);
493# define fill_random_bytes_urandom(seed, size) -1
496#if ! defined HAVE_GETRANDOM && defined __linux__ && defined __NR_getrandom
497# ifndef GRND_NONBLOCK
498# define GRND_NONBLOCK 0x0001
500# define getrandom(ptr, size, flags) \
501 (ssize_t)syscall(__NR_getrandom, (ptr), (size), (flags))
502# define HAVE_GETRANDOM 1
506#elif defined MAC_OS_X_VERSION_10_7 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_7
508# if defined(USE_COMMON_RANDOM)
509# elif defined MAC_OS_X_VERSION_10_10 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_10
510# define USE_COMMON_RANDOM 1
512# define USE_COMMON_RANDOM 0
514# if USE_COMMON_RANDOM
515# include <CommonCrypto/CommonCryptoError.h>
516# include <CommonCrypto/CommonRandom.h>
518# include <Security/SecRandom.h>
522fill_random_bytes_syscall(
void *seed,
size_t size,
int unused)
525 CCRNGStatus status = CCRandomGenerateBytes(seed, size);
526 int failed = status != kCCSuccess;
528 int status = SecRandomCopyBytes(kSecRandomDefault, size, seed);
529 int failed = status != errSecSuccess;
534# if USE_COMMON_RANDOM
536 fprintf(stderr,
"CCRandomGenerateBytes failed: %d\n", status);
538 CFStringRef s = SecCopyErrorMessageString(status, NULL);
539 const char *m = s ? CFStringGetCStringPtr(s, kCFStringEncodingUTF8) : NULL;
540 fprintf(stderr,
"SecRandomCopyBytes failed: %d: %s\n", status,
549#elif defined(HAVE_ARC4RANDOM_BUF)
551fill_random_bytes_syscall(
void *buf,
size_t size,
int unused)
553#if (defined(__OpenBSD__) && OpenBSD >= 201411) || \
554 (defined(__NetBSD__) && __NetBSD_Version__ >= 700000000) || \
555 (defined(__FreeBSD__) && __FreeBSD_version >= 1200079)
556 arc4random_buf(buf, size);
565# define DWORD_MAX (~(DWORD)0UL)
568# if defined(CRYPT_VERIFYCONTEXT)
569STATIC_ASSERT(sizeof_HCRYPTPROV,
sizeof(HCRYPTPROV) ==
sizeof(
size_t));
573static const HCRYPTPROV INVALID_HCRYPTPROV = (HCRYPTPROV)INVALID_HANDLE_VALUE;
576release_crypt(
void *p)
579 HCRYPTPROV prov = (HCRYPTPROV)ATOMIC_SIZE_EXCHANGE(*ptr, INVALID_HCRYPTPROV);
580 if (prov && prov != INVALID_HCRYPTPROV) {
581 CryptReleaseContext(prov, 0);
586fill_random_bytes_crypt(
void *seed,
size_t size)
588 static HCRYPTPROV perm_prov;
589 HCRYPTPROV prov = perm_prov, old_prov;
591 if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
592 prov = INVALID_HCRYPTPROV;
594 old_prov = (HCRYPTPROV)ATOMIC_SIZE_CAS(perm_prov, 0, prov);
595 if (LIKELY(!old_prov)) {
596 if (prov != INVALID_HCRYPTPROV) {
597#undef RUBY_UNTYPED_DATA_WARNING
598#define RUBY_UNTYPED_DATA_WARNING 0
599 rb_gc_register_mark_object(
Data_Wrap_Struct(0, 0, release_crypt, &perm_prov));
603 if (prov != INVALID_HCRYPTPROV) {
604 CryptReleaseContext(prov, 0);
609 if (prov == INVALID_HCRYPTPROV)
return -1;
611 DWORD n = (size > (size_t)DWORD_MAX) ? DWORD_MAX : (DWORD)size;
612 if (!CryptGenRandom(prov, n, seed))
return -1;
613 seed = (
char *)seed + n;
619# define fill_random_bytes_crypt(seed, size) -1
623fill_random_bytes_bcrypt(
void *seed,
size_t size)
626 ULONG n = (size > (size_t)ULONG_MAX) ? LONG_MAX : (ULONG)size;
627 if (BCryptGenRandom(NULL, seed, n, BCRYPT_USE_SYSTEM_PREFERRED_RNG))
629 seed = (
char *)seed + n;
636fill_random_bytes_syscall(
void *seed,
size_t size,
int unused)
638 if (fill_random_bytes_bcrypt(seed, size) == 0)
return 0;
639 return fill_random_bytes_crypt(seed, size);
641#elif defined HAVE_GETRANDOM
643fill_random_bytes_syscall(
void *seed,
size_t size,
int need_secure)
650 flags = GRND_NONBLOCK;
653 ssize_t ret = getrandom(((
char*)seed) + offset, size - offset, flags);
655 ATOMIC_SET(try_syscall, 0);
658 offset += (size_t)ret;
659 }
while (offset < size);
665# define fill_random_bytes_syscall(seed, size, need_secure) -1
669ruby_fill_random_bytes(
void *seed,
size_t size,
int need_secure)
671 int ret = fill_random_bytes_syscall(seed, size, need_secure);
672 if (ret == 0)
return ret;
673 return fill_random_bytes_urandom(seed, size);
676#define fill_random_bytes ruby_fill_random_bytes
680fill_random_seed(uint32_t *seed,
size_t cnt)
683#if defined HAVE_CLOCK_GETTIME
685#elif defined HAVE_GETTIMEOFDAY
688 size_t len = cnt *
sizeof(*seed);
690 memset(seed, 0,
len);
692 fill_random_bytes(seed,
len, FALSE);
694#if defined HAVE_CLOCK_GETTIME
695 clock_gettime(CLOCK_REALTIME, &tv);
696 seed[0] ^= tv.tv_nsec;
697#elif defined HAVE_GETTIMEOFDAY
698 gettimeofday(&tv, 0);
699 seed[0] ^= tv.tv_usec;
701 seed[1] ^= (uint32_t)tv.tv_sec;
702#if SIZEOF_TIME_T > SIZEOF_INT
703 seed[0] ^= (uint32_t)((time_t)tv.tv_sec >> SIZEOF_INT * CHAR_BIT);
705 seed[2] ^= getpid() ^ (ATOMIC_FETCH_ADD(n, 1) << 16);
706 seed[3] ^= (uint32_t)(
VALUE)&seed;
707#if SIZEOF_VOIDP > SIZEOF_INT
708 seed[2] ^= (uint32_t)((
VALUE)&seed >> SIZEOF_INT * CHAR_BIT);
713make_seed_value(uint32_t *ptr,
size_t len)
717 if (ptr[
len-1] <= 1) {
722 seed = rb_integer_unpack(ptr,
len,
sizeof(uint32_t), 0,
728#define with_random_seed(size, add) \
729 for (uint32_t seedbuf[(size)+(add)], loop = (fill_random_seed(seedbuf, (size)), 1); \
730 loop; explicit_bzero(seedbuf, (size)*sizeof(seedbuf[0])), loop = 0)
744 with_random_seed(DEFAULT_SEED_CNT, 1) {
745 v = make_seed_value(seedbuf, DEFAULT_SEED_CNT);
771 if (n == 0)
return buf;
772 if (fill_random_bytes(RSTRING_PTR(buf), n, TRUE))
792random_get_seed(
VALUE obj)
794 return get_rnd(obj)->
seed;
806 rnd1 = get_rnd_mt(obj);
807 rnd2 = get_rnd_mt(orig);
811 mt->next = mt->state + numberof(mt->state) - mt->left + 1;
816mt_state(
const struct MT *mt)
818 return rb_integer_unpack(mt->state, numberof(mt->state),
819 sizeof(*mt->state), 0,
825rand_mt_state(
VALUE obj)
828 return mt_state(&rnd->mt);
833random_s_state(
VALUE klass)
835 return mt_state(&default_rand()->mt);
840rand_mt_left(
VALUE obj)
848random_s_left(
VALUE klass)
850 return INT2FIX(default_rand()->mt.left);
855rand_mt_dump(
VALUE obj)
860 rb_ary_push(dump, mt_state(&rnd->mt));
861 rb_ary_push(dump,
INT2FIX(rnd->mt.left));
862 rb_ary_push(dump, rnd->base.
seed);
872 struct MT *mt = &rnd->mt;
887 rb_raise(rb_eArgError,
"wrong dump data");
889 rb_integer_pack(state, mt->state, numberof(mt->state),
890 sizeof(*mt->state), 0,
893 if (x > numberof(mt->state)) {
894 rb_raise(rb_eArgError,
"wrong value");
896 mt->left = (
unsigned int)x;
897 mt->next = mt->state + numberof(mt->state) - x + 1;
907 init_genrand(mt, data);
914 init_by_array(mt, buf, (
int)
len);
921 return genrand_int32(mt);
925rand_mt_get_bytes(
rb_random_t *rnd,
void *ptr,
size_t n)
960 seed = random_seed(obj);
966 rand_init(&random_mt_if, &r->base, seed);
973make_mask(
unsigned long x)
990 unsigned long val, mask;
992 if (!limit)
return 0;
993 mask = make_mask(limit);
996 if (0xffffffff < limit) {
1000 for (i = SIZEOF_LONG/SIZEOF_INT32-1; 0 <= i; i--) {
1001 if ((mask >> (i * 32)) & 0xffffffff) {
1002 val |= (
unsigned long)rng->
get_int32(rnd) << (i * 32);
1014 }
while (limit < val);
1028 uint32_t *tmp, *lim_array, *rnd_array;
1032 len = rb_absint_numwords(limit, 32, NULL);
1035 rnd_array = tmp +
len;
1036 rb_integer_pack(limit, lim_array,
len,
sizeof(uint32_t), 0,
1042 for (i =
len-1; 0 <= i; i--) {
1044 uint32_t lim = lim_array[i];
1045 mask = mask ? 0xffffffff : (uint32_t)make_mask(lim);
1057 val = rb_integer_unpack(rnd_array,
len,
sizeof(uint32_t), 0,
1074 return limited_rand(&random_mt_if, &mt->base, limit);
1078obj_random_bytes(
VALUE obj,
void *p,
long n)
1089 if (p) memcpy(p, RSTRING_PTR(v), n);
1105 obj_random_bytes(obj, &x,
sizeof(x));
1106 return (
unsigned int)x;
1108 return random_int32(try_rand_if(obj, rnd), rnd);
1117 uint32_t x[2] = {0, 0};
1118 obj_random_bytes(obj, x,
sizeof(x));
1125 a = random_int32(rng, rnd);
1126 b = random_int32(rng, rnd);
1135 return int_pair_to_real_exclusive(a, b);
1138 return int_pair_to_real_inclusive(a, b);
1147 VALUE v = rb_funcallv(obj, id_rand, 0, 0);
1152 else if (d >= 1.0) {
1157 return random_real(obj, rnd, TRUE);
1161ulong_to_num_plus_1(
unsigned long n)
1166 if (n >= ULONG_MAX) {
1176 if (!limit)
return 0;
1178 const int w =
sizeof(limit) * CHAR_BIT - nlz_long(limit);
1179 const int n = w > 32 ?
sizeof(
unsigned long) : sizeof(uint32_t);
1180 const unsigned long mask = ~(~0UL << w);
1181 const unsigned long full =
1182 (size_t)n >=
sizeof(
unsigned long) ? ~0UL :
1183 ~(~0UL << n * CHAR_BIT);
1184 unsigned long val, bits = 0, rest = 0;
1187 union {uint32_t u32;
unsigned long ul;} buf;
1188 obj_random_bytes(obj, &buf, n);
1190 bits = (n ==
sizeof(uint32_t)) ? buf.u32 : buf.ul;
1196 }
while (limit < val);
1199 return limited_rand(try_rand_if(obj, rnd), rnd, limit);
1207 VALUE lim = ulong_to_num_plus_1(limit);
1210 if (rb_num_negative_p(v)) {
1218 return limited_rand(try_rand_if(obj, rnd), rnd, limit);
1226 size_t i, nlz,
len = rb_absint_numwords(vmax, 32, &nlz);
1227 uint32_t *tmp =
ALLOCV_N(uint32_t, vtmp,
len * 2);
1228 uint32_t mask = (uint32_t)~0 >> nlz;
1229 uint32_t *lim_array = tmp;
1230 uint32_t *rnd_array = tmp +
len;
1232 rb_integer_pack(vmax, lim_array,
len,
sizeof(uint32_t), 0, flag);
1235 obj_random_bytes(obj, rnd_array,
len *
sizeof(uint32_t));
1236 rnd_array[0] &= mask;
1237 for (i = 0; i <
len; ++i) {
1238 if (lim_array[i] < rnd_array[i])
1240 if (rnd_array[i] < lim_array[i])
1243 v = rb_integer_unpack(rnd_array,
len,
sizeof(uint32_t), 0, flag);
1247 return limited_big_rand(try_rand_if(obj, rnd), rnd, vmax);
1257 ptr = RSTRING_PTR(bytes);
1283 for (; n >= SIZEOF_INT32; n -= SIZEOF_INT32) {
1305 return obj_random_bytes(obj, NULL, n);
1307 return rand_bytes(try_rand_if(obj, rnd), rnd, n);
1339random_s_seed(
VALUE obj)
1342 return rnd->base.
seed;
1351 if (begp) *begp = beg;
1353 if (endp) *endp = end;
1355 return rb_check_funcall_default(end, id_minus, 1, begp,
Qfalse);
1366 if (!max)
return Qnil;
1368 if (restrictive)
return Qnil;
1371 r = random_ulong_limited(obj, rnd, (
unsigned long)max - 1);
1376 if (rb_bigzero_p(vmax))
return Qnil;
1377 if (!BIGNUM_SIGN(vmax)) {
1378 if (restrictive)
return Qnil;
1379 vmax = rb_big_uminus(vmax);
1381 vmax = rb_big_minus(vmax,
INT2FIX(1));
1384 if (max == -1)
return Qnil;
1385 r = random_ulong_limited(obj, rnd, max);
1388 ret = random_ulong_limited_big(obj, rnd, vmax);
1401NORETURN(
static void invalid_argument(
VALUE));
1403invalid_argument(
VALUE arg0)
1405 rb_raise(rb_eArgError,
"invalid argument - %"PRIsVALUE, arg0);
1409check_random_number(
VALUE v,
const VALUE *argv)
1416 invalid_argument(argv[0]);
1437 if ((v = vmax = range_values(range, &beg, &end, &excl)) ==
Qfalse)
1439 if (
NIL_P(v)) domain_error();
1446 if ((max =
FIX2LONG(vmax) - excl) >= 0) {
1447 unsigned long r = random_ulong_limited(obj, rnd, (
unsigned long)max);
1452 vmax = excl ? rb_big_minus(vmax,
INT2FIX(1)) : rb_big_norm(vmax);
1457 v = random_ulong_limited_big(obj, rnd, vmax);
1470 else if (isnan(max)) {
1475 r = random_real(obj, rnd, excl);
1477 return rb_float_new(+(+(+(r - 0.5) * max) * scale) + mid);
1479 v = rb_float_new(r * max);
1481 else if (max == 0.0 && !excl) {
1482 v = rb_float_new(0.0);
1494 return rb_big_plus(v, beg);
1502 return rb_funcallv(beg, id_plus, 1, &v);
1543 VALUE v = rand_random(argc, argv, obj, try_get_rnd(obj));
1544 check_random_number(v, argv);
1554 return rb_float_new(random_real(obj, rnd, TRUE));
1560 if (!
NIL_P(v))
return rand_int(obj, rnd, v, 1);
1564 const double max = float_value(v);
1569 double r = random_real(obj, rnd, TRUE);
1570 if (max > 0.0) r *= max;
1571 return rb_float_new(r);
1574 return rand_range(obj, rnd, vmax);
1590rand_random_number(
int argc,
VALUE *argv,
VALUE obj)
1593 VALUE v = rand_random(argc, argv, obj, rnd);
1594 if (
NIL_P(v)) v = rand_random(0, 0, obj, rnd);
1595 else if (!v) invalid_argument(argv[0]);
1628 r1 = get_rnd_mt(self);
1629 r2 = get_rnd_mt(other);
1630 if (memcmp(r1->mt.state, r2->mt.state,
sizeof(r1->mt.state)))
return Qfalse;
1631 if ((r1->mt.next - r1->mt.state) != (r2->mt.next - r2->mt.state))
return Qfalse;
1632 if (r1->mt.left != r2->mt.left)
return Qfalse;
1633 return rb_equal(r1->base.seed, r2->base.seed);
1674 VALUE v = rand_range(obj, rnd, vmax);
1675 if (v !=
Qfalse)
return v;
1678 v = rand_int(obj, rnd, vmax, 0);
1679 if (!
NIL_P(v))
return v;
1682 return DBL2NUM(random_real(obj, rnd, TRUE));
1696random_s_rand(
int argc,
VALUE *argv,
VALUE obj)
1698 VALUE v = rand_random(argc, argv,
Qnil, rand_start(default_rand()));
1699 check_random_number(v, argv);
1703#define SIP_HASH_STREAMING 0
1704#define sip_hash13 ruby_sip_hash13
1705#if !defined _WIN32 && !defined BYTE_ORDER
1706# ifdef WORDS_BIGENDIAN
1707# define BYTE_ORDER BIG_ENDIAN
1709# define BYTE_ORDER LITTLE_ENDIAN
1711# ifndef LITTLE_ENDIAN
1712# define LITTLE_ENDIAN 1234
1715# define BIG_ENDIAN 4321
1731init_hash_salt(
struct MT *mt)
1735 for (i = 0; i < numberof(hash_salt.u32); ++i)
1736 hash_salt.u32[i] = genrand_int32(mt);
1739NO_SANITIZE(
"unsigned-integer-overflow",
extern st_index_t
rb_hash_start(st_index_t h));
1743 return st_hash_start(hash_salt.key.hash + h);
1751 return (st_index_t)h;
1753 return (st_index_t)(h.u32[0] ^ h.u32[1]);
1760Init_RandomSeedCore(
void)
1762 if (!fill_random_bytes(&hash_salt,
sizeof(hash_salt), FALSE))
return;
1773 with_random_seed(DEFAULT_SEED_CNT, 0) {
1774 init_by_array(&mt, seedbuf, DEFAULT_SEED_CNT);
1777 init_hash_salt(&mt);
1778 explicit_bzero(&mt,
sizeof(mt));
1785 uninit_genrand(&r->mt);
1883 id_rand = rb_intern(
"rand");
1884 id_bytes = rb_intern(
"bytes");
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_extend_object(VALUE obj, VALUE module)
Extend the object with the module.
VALUE rb_define_module_under(VALUE outer, const char *name)
Defines a module under the namespace of outer.
VALUE rb_define_class_id(ID id, VALUE super)
This is a very badly designed API that creates an anonymous class.
#define TYPE(_)
Old name of rb_type.
#define NUM2ULONG
Old name of RB_NUM2ULONG.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_NIL
Old name of RUBY_T_NIL.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define ULONG2NUM
Old name of RB_ULONG2NUM.
#define ZALLOC
Old name of RB_ZALLOC.
#define CLASS_OF
Old name of rb_class_of.
#define NUM2DBL
Old name of rb_num2dbl.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
#define DBL2NUM
Old name of rb_float_new.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
void rb_check_copyable(VALUE obj, VALUE orig)
Ensures that the passed object can be initialize_copy relationship.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
Identical to rb_typeddata_is_kind_of(), except it raises exceptions instead of returning false.
VALUE rb_eSystemCallError
SystemCallError exception.
VALUE rb_check_to_int(VALUE val)
Identical to rb_check_to_integer(), except it uses #to_int for conversion.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_check_to_float(VALUE val)
This is complicated.
VALUE rb_cRandom
Random class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_to_float(VALUE val)
Identical to rb_check_to_float(), except it raises on error.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it only takes public methods into account.
#define INTEGER_PACK_NATIVE_BYTE_ORDER
Means either INTEGER_PACK_MSBYTE_FIRST or INTEGER_PACK_LSBYTE_FIRST, depending on the host processor'...
#define INTEGER_PACK_MSWORD_FIRST
Stores/interprets the most significant word as the first word.
#define INTEGER_PACK_LSWORD_FIRST
Stores/interprets the least significant word as the first word.
#define rb_check_frozen
Just another name of rb_check_frozen
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_update_max_fd(int fd)
Informs the interpreter that the passed fd can be the max.
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
Opens a file that closes on exec.
unsigned long rb_genrand_ulong_limited(unsigned long i)
Generates a random number whose upper limit is i.
double rb_random_real(VALUE rnd)
Identical to rb_genrand_real(), except it generates using the passed RNG.
unsigned int rb_random_int32(VALUE rnd)
Identical to rb_genrand_int32(), except it generates using the passed RNG.
void rb_reset_random_seed(void)
Resets the RNG behind rb_genrand_int32()/rb_genrand_real().
VALUE rb_random_bytes(VALUE rnd, long n)
Generates a String of random bytes.
double rb_genrand_real(void)
Generates a double random number.
unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit)
Identical to rb_genrand_ulong_limited(), except it generates using the passed RNG.
unsigned int rb_genrand_int32(void)
Generates a 32 bit random number.
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Deconstructs a range into its components.
st_index_t rb_memhash(const void *ptr, long len)
This is a universal hash function.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
void rb_const_set(VALUE space, ID name, VALUE val)
Names a constant.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
int len
Length of the buffer.
void * rb_ractor_local_storage_ptr(rb_ractor_local_key_t key)
Identical to rb_ractor_local_storage_value() except the return type.
void rb_ractor_local_storage_ptr_set(rb_ractor_local_key_t key, void *ptr)
Identical to rb_ractor_local_storage_value_set() except the parameter type.
rb_ractor_local_key_t rb_ractor_local_storage_ptr_newkey(const struct rb_ractor_local_storage_type *type)
Extended version of rb_ractor_local_storage_value_newkey().
#define RB_RANDOM_INTERFACE_DEFINE(prefix)
This utility macro expands to the names declared using RB_RANDOM_INTERFACE_DECLARE.
struct rb_random_struct rb_random_t
#define RB_RANDOM_INTERFACE_DECLARE(prefix)
This utility macro defines 4 functions named prefix_init, prefix_init_int32, prefix_get_int32,...
void rb_rand_bytes_int32(rb_random_get_int32_func *func, rb_random_t *prng, void *buff, size_t size)
Repeatedly calls the passed function over and over again until the passed buffer is filled with rando...
unsigned int rb_random_get_int32_func(rb_random_t *rng)
This is the type of functions called from your object's #rand method.
double rb_int_pair_to_real(uint32_t a, uint32_t b, int excl)
Generates a 64 bit floating point number by concatenating two 32bit unsigned integers.
static const rb_random_interface_t * rb_rand_if(VALUE obj)
Queries the interface of the passed random object.
void rb_random_base_init(rb_random_t *rnd)
Initialises an allocated rb_random_t instance.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define RARRAY_LEN
Just another name of rb_array_len
#define RARRAY_AREF(a, i)
#define Data_Wrap_Struct(klass, mark, free, sval)
Converts sval, a pointer to your struct, into a Ruby object.
#define DATA_PTR(obj)
Convenient getter macro.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
static const struct rb_data_type_struct * RTYPEDDATA_TYPE(VALUE obj)
Queries for the type of given object.
#define errno
Ractor-aware version of errno.
#define InitVM(ext)
This macro is for internal use.
#define _(args)
This was a transition path from K&R to ANSI.
This is the struct that holds necessary info for a struct.
Type that defines a ractor-local storage.
PRNG algorithmic interface, analogous to Ruby level classes.
rb_random_init_func * init
Function to initialize from uint32_t array.
rb_random_init_int32_func * init_int32
Function to initialize from single uint32_t.
size_t default_seed_bits
Number of bits of seed numbers.
rb_random_get_int32_func * get_int32
Function to obtain a random integer.
rb_random_get_real_func * get_real
Function to obtain a random double.
rb_random_get_bytes_func * get_bytes
Function to obtain a series of random bytes.
struct rb_random_interface_t::@57 version
Major/minor versions of this interface.
Base components of the random interface.
VALUE seed
Seed, passed through e.g.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.