1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
#include "ruby/random.h"
#if RUBY_RANDOM_INTERFACE_VERSION_MAJOR < RUBY_RANDOM_INTERFACE_VERSION_MAJOR_MAX
# define DEFINE_VERSION_MAX 1
#else
# define DEFINE_VERSION_MAX 0
#endif
NORETURN(static void must_not_reach(void));
static void
must_not_reach(void)
{
rb_raise(rb_eTypeError, "must not reach");
}
NORETURN(static void bad_version_init(rb_random_t *, const uint32_t *, size_t));
static void
bad_version_init(rb_random_t *rnd, const uint32_t *buf, size_t len)
{
must_not_reach();
}
NORETURN(static void bad_version_init_int32(rb_random_t *, uint32_t));
RB_RANDOM_DEFINE_INIT_INT32_FUNC(bad_version)
NORETURN(static void bad_version_get_bytes(rb_random_t *, void *, size_t));
static void
bad_version_get_bytes(rb_random_t *rnd, void *p, size_t n)
{
must_not_reach();
}
NORETURN(static uint32_t bad_version_get_int32(rb_random_t *));
static uint32_t
bad_version_get_int32(rb_random_t *rnd)
{
must_not_reach();
UNREACHABLE_RETURN(0);
}
static VALUE
bad_version_alloc(VALUE klass, const rb_data_type_t *type)
{
rb_random_t *rnd;
VALUE obj = TypedData_Make_Struct(klass, rb_random_t, type, rnd);
rb_random_base_init(rnd);
return obj;
}
/* version 0 */
static const rb_random_interface_t random_version_zero_if;
static rb_random_data_type_t version_zero_type = {
"random/version_zero",
{
rb_random_mark,
RUBY_TYPED_DEFAULT_FREE,
},
RB_RANDOM_PARENT,
(void *)&random_version_zero_if,
RUBY_TYPED_FREE_IMMEDIATELY
};
static VALUE
version_zero_alloc(VALUE klass)
{
return bad_version_alloc(klass, &version_zero_type);
}
static void
init_version_zero(VALUE mod, VALUE base)
{
VALUE c = rb_define_class_under(mod, "VersionZero", base);
rb_define_alloc_func(c, version_zero_alloc);
RB_RANDOM_DATA_INIT_PARENT(version_zero_type);
}
#if DEFINE_VERSION_MAX
/* version max */
static const rb_random_interface_t random_version_max_if;
static rb_random_data_type_t version_max_type = {
"random/version_max",
{
rb_random_mark,
RUBY_TYPED_DEFAULT_FREE,
},
RB_RANDOM_PARENT,
(void *)&random_version_max_if,
RUBY_TYPED_FREE_IMMEDIATELY
};
static VALUE
version_max_alloc(VALUE klass)
{
return bad_version_alloc(klass, &version_max_type);
}
static void
init_version_max(VALUE mod, VALUE base)
{
VALUE c = rb_define_class_under(mod, "VersionMax", base);
rb_define_alloc_func(c, version_max_alloc);
RB_RANDOM_DATA_INIT_PARENT(version_max_type);
}
#else
static void
init_version_max(mod, base)
{
}
#endif
void
Init_random_bad_version(VALUE mod, VALUE base)
{
init_version_zero(mod, base);
init_version_max(mod, base);
}
#undef RUBY_RANDOM_INTERFACE_VERSION_MAJOR
#define RUBY_RANDOM_INTERFACE_VERSION_MAJOR 0
static const rb_random_interface_t random_version_zero_if = {
0,
RB_RANDOM_INTERFACE_DEFINE(bad_version)
};
#undef RUBY_RANDOM_INTERFACE_VERSION_MAJOR
#if DEFINE_VERSION_MAX
#define RUBY_RANDOM_INTERFACE_VERSION_MAJOR RUBY_RANDOM_INTERFACE_VERSION_MAJOR_MAX
static const rb_random_interface_t random_version_max_if = {
0,
RB_RANDOM_INTERFACE_DEFINE(bad_version)
};
#undef RUBY_RANDOM_INTERFACE_VERSION_MAJOR
#endif
|
