random.h

Go to the documentation of this file.

#ifndef RUBY_RANDOM_H                                /*-*-C++-*-vi:se ft=cpp:*/
#define RUBY_RANDOM_H 1
#include "ruby/ruby.h"
 
/*
 * version
 * 0: before versioning; deprecated
 * 1: added version, flags and init_32bit function
 */
#define RUBY_RANDOM_INTERFACE_VERSION_MAJOR 1
#define RUBY_RANDOM_INTERFACE_VERSION_MINOR 0
 
#define RUBY_RANDOM_PASTE_VERSION_SUFFIX(x, y, z) x##_##y##_##z
#define RUBY_RANDOM_WITH_VERSION_SUFFIX(name, major, minor) \
    RUBY_RANDOM_PASTE_VERSION_SUFFIX(name, major, minor)
#define rb_random_data_type \
    RUBY_RANDOM_WITH_VERSION_SUFFIX(rb_random_data_type, \
                                    RUBY_RANDOM_INTERFACE_VERSION_MAJOR, \
                                    RUBY_RANDOM_INTERFACE_VERSION_MINOR)
#define RUBY_RANDOM_INTERFACE_VERSION_INITIALIZER \
    {RUBY_RANDOM_INTERFACE_VERSION_MAJOR, RUBY_RANDOM_INTERFACE_VERSION_MINOR}
#define RUBY_RANDOM_INTERFACE_VERSION_MAJOR_MAX 0xff
#define RUBY_RANDOM_INTERFACE_VERSION_MINOR_MAX 0xff
 
RBIMPL_SYMBOL_EXPORT_BEGIN()
 
 
struct rb_random_struct {
    VALUE seed;
};
typedef struct rb_random_struct rb_random_t; 
RBIMPL_ATTR_NONNULL(())
typedef void rb_random_init_func(rb_random_t *rng, const uint32_t *buf, size_t len);
 
RBIMPL_ATTR_NONNULL(())
typedef void rb_random_init_int32_func(rb_random_t *rng, uint32_t data);
 
RBIMPL_ATTR_NONNULL(())
typedef unsigned int rb_random_get_int32_func(rb_random_t *rng);
 
RBIMPL_ATTR_NONNULL(())
typedef void rb_random_get_bytes_func(rb_random_t *rng, void *buf, size_t len);
 
RBIMPL_ATTR_NONNULL(())
typedef double rb_random_get_real_func(rb_random_t *rng, int excl);
 
typedef struct {
    size_t default_seed_bits;
 
    struct {
        uint8_t major, minor;
    } version;
 
    uint16_t flags;
 
    rb_random_init_func *init;
 
    rb_random_init_int32_func *init_int32;
 
    rb_random_get_int32_func *get_int32;
 
    rb_random_get_bytes_func *get_bytes;
 
    rb_random_get_real_func *get_real;
} rb_random_interface_t;
 
#define RB_RANDOM_INTERFACE_DECLARE(prefix) \
    static void prefix##_init(rb_random_t *, const uint32_t *, size_t); \
    static void prefix##_init_int32(rb_random_t *, uint32_t); \
    static unsigned int prefix##_get_int32(rb_random_t *); \
    static void prefix##_get_bytes(rb_random_t *, void *, size_t)
 
#define RB_RANDOM_INTERFACE_DECLARE_WITH_REAL(prefix) \
    RB_RANDOM_INTERFACE_DECLARE(prefix); \
    static double prefix##_get_real(rb_random_t *, int)
 
#define RB_RANDOM_INTERFACE_DEFINE(prefix) \
    RUBY_RANDOM_INTERFACE_VERSION_INITIALIZER, 0, \
    prefix##_init, \
    prefix##_init_int32, \
    prefix##_get_int32, \
    prefix##_get_bytes
 
#define RB_RANDOM_INTERFACE_DEFINE_WITH_REAL(prefix) \
    RB_RANDOM_INTERFACE_DEFINE(prefix), \
    prefix##_get_real
 
#define RB_RANDOM_DEFINE_INIT_INT32_FUNC(prefix) \
    static void prefix##_init_int32(rb_random_t *rnd, uint32_t data) \
    { \
        prefix##_init(rnd, &data, 1); \
    }
 
#if defined _WIN32 && !defined __CYGWIN__
typedef rb_data_type_t rb_random_data_type_t;
# define RB_RANDOM_PARENT 0
#else
 
typedef const rb_data_type_t rb_random_data_type_t;
 
# define RB_RANDOM_PARENT &rb_random_data_type
#endif
 
#define RB_RANDOM_DATA_INIT_PARENT(random_data) \
    rbimpl_random_data_init_parent(&random_data)
 
void rb_random_mark(void *ptr);
 
void rb_random_base_init(rb_random_t *rnd);
 
double rb_int_pair_to_real(uint32_t a, uint32_t b, int excl);
 
void rb_rand_bytes_int32(rb_random_get_int32_func *func, rb_random_t *prng, void *buff, size_t size);
 
RUBY_EXTERN const rb_data_type_t rb_random_data_type;
 
RBIMPL_SYMBOL_EXPORT_END()
 
RBIMPL_ATTR_PURE_UNLESS_DEBUG()
/* :TODO: can this function be __attribute__((returns_nonnull)) or not? */
static inline const rb_random_interface_t *
rb_rand_if(VALUE obj)
{
    RBIMPL_ASSERT_OR_ASSUME(RTYPEDDATA_P(obj));
    const struct rb_data_type_struct *t = RTYPEDDATA_TYPE(obj);
    const void *ret = t->data;
    return RBIMPL_CAST((const rb_random_interface_t *)ret);
}
 
RBIMPL_ATTR_NOALIAS()
static inline void
rbimpl_random_data_init_parent(rb_random_data_type_t *random_data)
{
#if defined _WIN32 && !defined __CYGWIN__
    random_data->parent = &rb_random_data_type;
#endif
}
 
#endif /* RUBY_RANDOM_H */