static mrb_value
mrb_random_init(mrb_state *mrb, mrb_value self)
{
mrb_value seed;
mt_state *t;
/* avoid memory leaks */
t = (mt_state*)DATA_PTR(self);
if (t) {
mrb_free(mrb, t);
}
mrb_data_init(self, NULL, &mt_state_type);
t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
t->mti = N + 1;
seed = get_opt(mrb);
seed = mrb_random_mt_srand(mrb, t, seed);
if (mrb_nil_p(seed)) {
t->has_seed = FALSE;
}
else {
mrb_assert(mrb_fixnum_p(seed));
t->has_seed = TRUE;
t->seed = mrb_fixnum(seed);
}
mrb_data_init(self, t, &mt_state_type);
return self;
}
/* Initializes a time by setting the amount of milliseconds since the epoch.*/
static mrb_value
mrb_time_initialize(mrb_state *mrb, mrb_value self)
{
mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0,
amin = 0, asec = 0, ausec = 0;
int n;
struct mrb_time *tm;
tm = (struct mrb_time*)DATA_PTR(self);
if (tm) {
mrb_free(mrb, tm);
}
mrb_data_init(self, NULL, &mrb_time_type);
n = mrb_get_args(mrb, "|iiiiiii",
&ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
if (n == 0) {
tm = current_mrb_time(mrb);
}
else {
tm = time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL);
}
mrb_data_init(self, tm, &mrb_time_type);
return self;
}
void
mrb_cp_constraint_init_bind(mrb_state *mrb, mrb_value self, cpConstraint *constraint)
{
mrb_cp_constraint_user_data *user_data;
user_data = mrb_cp_constraint_user_data_new(mrb);
user_data->constraint = self;
cpConstraintSetUserData(constraint, user_data);
mrb_data_init(self, constraint, &mrb_cp_constraint_type);
}
mrb_value mrb_simple_init(mrb_state *mrb, mrb_value self) {
mrb_int val_i;
mrb_float val_f;
simple_context *simple;
simple = calloc(1, sizeof(simple));
mrb_get_args(mrb, "if", &val_i, &val_f);
simple->i = (int)val_i;
simple->f = val_f;
mrb_data_init(self, simple, &mrb_simple_ctx_type);
return self;
}
static mrb_value
hdb_initialize(mrb_state *mrb, mrb_value self)
{
hdb_context *context = mrb_malloc(mrb, sizeof(struct hdb_context));
memset(context, 0, sizeof(*context));
context->type.struct_name = "HDB";
context->type.dfree = hdb_free;
context->hdb = tchdbnew();
mrb_data_init(self, context, &context->type);
return self;
}
/* Initializes a copy of this time object. */
static mrb_value
mrb_time_initialize_copy(mrb_state *mrb, mrb_value copy)
{
mrb_value src;
mrb_get_args(mrb, "o", &src);
if (mrb_obj_equal(mrb, copy, src)) return copy;
if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
}
if (!DATA_PTR(copy)) {
mrb_data_init(copy, mrb_malloc(mrb, sizeof(struct mrb_time)), &mrb_time_type);
}
*(struct mrb_time *)DATA_PTR(copy) = *(struct mrb_time *)DATA_PTR(src);
return copy;
}
static mrb_value
mrb_wslay_event_context_client_init(mrb_state *mrb, mrb_value self)
{
mrb_value callbacks_obj;
mrb_get_args(mrb, "o", &callbacks_obj);
mrb_value recv_callback, send_callback, on_msg_recv_callback;
recv_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@recv_callback"));
if (mrb_type(recv_callback) != MRB_TT_PROC) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "recv_callback missing");
}
send_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@send_callback"));
if (mrb_type(send_callback) != MRB_TT_PROC) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "send_callback missing");
}
on_msg_recv_callback = mrb_iv_get(mrb, callbacks_obj, mrb_intern_lit(mrb, "@on_msg_recv_callback"));
if (mrb_type(on_msg_recv_callback) != MRB_TT_PROC) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "on_msg_recv_callback missing");
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "callbacks"), callbacks_obj);
mrb_wslay_user_data *data = (mrb_wslay_user_data *) mrb_malloc(mrb, sizeof(mrb_wslay_user_data));
mrb_data_init(self, data, &mrb_wslay_user_data_type);
data->mrb = mrb;
data->recv_callback = recv_callback;
data->send_callback = send_callback;
data->on_msg_recv_callback = on_msg_recv_callback;
struct wslay_event_callbacks client_callbacks = {
mrb_wslay_event_recv_callback,
mrb_wslay_event_send_callback,
mrb_wslay_event_genmask_callback,
NULL,
NULL,
NULL,
mrb_wslay_event_on_msg_recv_callback
};
int err = wslay_event_context_client_init(&data->ctx, &client_callbacks, data);
if (err == WSLAY_ERR_NOMEM) {
mrb_sys_fail(mrb, "wslay_event_context_client_init");
}
else if (err != 0) {
return MRB_WSLAY_ERROR(mrb_fixnum_value(err));
}
return self;
}
/*
* Chipmunk2d::Mat2x2#initialize(a, b, c, d)
* @param [Float] a
* @param [Float] b
* @param [Float] c
* @param [Float] d
* @return [self]
*/
static mrb_value
mat2x2_initialize(mrb_state *mrb, mrb_value self)
{
mrb_float a;
mrb_float b;
mrb_float c;
mrb_float d;
cpMat2x2 *mat2x2;
mrb_get_args(mrb, "ffff", &a, &b, &c, &d);
mat2x2 = (cpMat2x2*)DATA_PTR(self);
if (mat2x2) {
mrb_cp_mat2x2_free(mrb, mat2x2);
}
mat2x2 = mrb_malloc(mrb, sizeof(cpMat2x2));
*mat2x2 = cpMat2x2New(a, b, c, d);
mrb_data_init(self, mat2x2, &mrb_cp_mat2x2_type);
return self;
}
MRB_API mrb_value mrb_sample_buffer_new_uninitialized(mrb_state *mrb, mrb_int len, mrb_int offset)
{
mrb_value buf;
mrb_sample_buffer *b = 0;
if (len <= 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Length must be positive");
if (offset < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Offset can not be negative");
buf = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, mrb_class_get(mrb, "SampleBuffer")));
b = mrb_sample_buffer_alloc(mrb);
b->shared = mrb_shared_sample_buffer_alloc(mrb, len);
b->shared->offset = offset;
b->len = len;
b->offset = 0;
mrb_data_init(buf, b, &mrb_sample_buffer_type);
return buf;
}
static mrb_value mrb_sample_buffer_initialize(mrb_state *mrb, mrb_value self)
{
mrb_sample_buffer *b = 0;
mrb_int len, offset = 0, i;
mrb_get_args(mrb, "i|i", &len, &offset);
if (len <= 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Length must be positive");
if (offset < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Offset can not be negative");
b = mrb_sample_buffer_alloc(mrb);
b->shared = mrb_shared_sample_buffer_alloc(mrb, len);
b->shared->offset = offset;
b->len = len;
b->offset = 0;
for (i = 0; i < len; ++i) {
b->shared->buffer[i] = 0;
}
mrb_data_init(self, b, &mrb_sample_buffer_type);
return self;
}
/*
* Chipmunk2d::Transform#initialize(a, b, c, d, tx, ty)
* @param [Float] a
* @param [Float] b
* @param [Float] c
* @param [Float] d
* @param [Float] tx
* @param [Float] ty
* @return [self]
*/
static mrb_value
transform_initialize(mrb_state* mrb, mrb_value self)
{
mrb_float a;
mrb_float b;
mrb_float c;
mrb_float d;
mrb_float tx;
mrb_float ty;
cpTransform* transform;
mrb_get_args(mrb, "ffffff", &a, &b, &c, &d, &tx, &ty);
transform = (cpTransform*)DATA_PTR(self);
if (transform) {
mrb_cp_transform_free(mrb, transform);
}
transform = (cpTransform*)mrb_malloc(mrb, sizeof(cpTransform));
*transform = cpTransformNew(a, b, c, d, tx, ty);
mrb_data_init(self, transform, &mrb_cp_transform_type);
return self;
}
MRB_API mrb_value mrb_sample_buffer_slice(mrb_state *mrb, mrb_value sample_buffer, mrb_int len, mrb_int offset)
{
mrb_value buf;
mrb_sample_buffer *b = 0, *other = 0;
if (len <= 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Length must be positive");
if (offset < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "Offset can not be negative");
other = mrb_sample_buffer_check(mrb, sample_buffer);
if (len > other->len - offset) mrb_raise(mrb, E_ARGUMENT_ERROR, "Slice must be completely inside the buffer");
buf = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, mrb_class_get(mrb, "SampleBuffer")));
b = mrb_sample_buffer_alloc(mrb);
b->shared = other->shared;
mrb_shared_sample_buffer_ref(mrb, other->shared);
b->len = len;
b->offset = offset;
mrb_data_init(buf, b, &mrb_sample_buffer_type);
return buf;
}
mrb_value mrb_mraa_uart_init(mrb_state *mrb, mrb_value self) {
mrb_int dev, baud, nargs;
mraa_uart_context uart;
nargs = mrb_get_args(mrb, "i|i", &dev, &baud);
if (nargs < 2)
baud = UART_DEFAULT_BAUDRATE;
uart = mraa_uart_init(dev);
if (uart == NULL) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "Failed to initialize DEV:%S.",
mrb_fixnum_value(dev));
}
mrb_data_init(self, uart, &mrb_mraa_uart_ctx_type);
// DATA_TYPE(self) = &mrb_mraa_uart_ctx_type;
// DATA_PTR(self) = uart;
IV_SET("@read_bufsize", mrb_fixnum_value(UART_DEFAULT_BUFSIZE));
IV_SET("@timeout", mrb_fixnum_value(UART_DEFAULT_TIMEOUT));
IV_SET("@prompt", mrb_str_new_cstr(mrb, UART_DEFAULT_PROMPT));
mrb_funcall(mrb, self, "baudrate=", 1, mrb_fixnum_value(baud));
return self;
}
static mrb_value mrb_ipvs_service_init(mrb_state *mrb, mrb_value self) {
int parse;
mrb_value arg_opt = mrb_nil_value(), addr = mrb_nil_value(),
proto = mrb_nil_value(), sched_name = mrb_nil_value(),
obj = mrb_nil_value();
// mrb_value arg_opt = mrb_nil_value(), addr = mrb_nil_value(),
// proto = mrb_nil_value(), sched_name = mrb_nil_value(),
// ops = mrb_nil_value(), obj = mrb_nil_value();
mrb_int port;
// mrb_int port, timeout, netmask;
struct mrb_ipvs_service *ie;
ie = (struct mrb_ipvs_service *)mrb_malloc(mrb, sizeof(*ie));
memset(ie, 0, sizeof(struct mrb_ipvs_service));
mrb_get_args(mrb, "H", &arg_opt);
if (mrb_nil_p(arg_opt)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
addr = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "addr"));
if (mrb_nil_p(addr)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "port"));
port = mrb_nil_p(obj) ? 0 : mrb_fixnum(obj);
if (port < 0 || port > 65535) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid port value specified");
}
proto = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "protocol"));
if (mrb_nil_p(proto)) {
proto = mrb_str_new_cstr(mrb, DEF_PROTO);
}
sched_name = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "sched_name"));
if (mrb_nil_p(sched_name)) {
sched_name = mrb_str_new_cstr(mrb, DEF_SCHED);
}
// ops = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "ops"));
// timeout =
// mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb,
// "timeout")));
// netmask =
// mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb,
// "netmask")));
ie->svc.protocol = parse_proto((char *)RSTRING_PTR(proto));
parse = parse_service((char *)RSTRING_PTR(addr), &ie->svc);
if (strrchr((char *)RSTRING_PTR(addr), ':') == NULL) {
ie->svc.port = htons(port);
}
if (!(parse & SERVICE_ADDR)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
strncpy(ie->svc.sched_name, (char *)RSTRING_PTR(sched_name),
IP_VS_SCHEDNAME_MAXLEN);
mrb_data_init(self, ie, &mrb_ipvs_service_type);
return self;
}
