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(),
ops = mrb_nil_value(),
obj = mrb_nil_value();
mrb_int port,
timeout,
netmask;
struct mrb_ipvs_entry *ie;
ie = (struct mrb_ipvs_entry*)mrb_malloc(mrb, sizeof(*ie));
memset(ie, 0, sizeof(struct mrb_ipvs_entry));
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");
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);
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 argument");
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);
DATA_TYPE(self) = &mrb_ipvs_service_type;
DATA_PTR(self) = ie;
return self;
}
static mrb_value ngx_stream_mrb_connection_init(mrb_state *mrb, mrb_value self)
{
ngx_uint_t i;
mrb_value upstream;
ngx_stream_mruby_upstream_context *ctx;
ngx_stream_upstream_main_conf_t *umcf;
ngx_stream_upstream_srv_conf_t **usp;
ngx_stream_mruby_internal_ctx_t *ictx = mrb->ud;
ngx_stream_session_t *s = ictx->s;
mrb_get_args(mrb, "o", &upstream);
ctx = (ngx_stream_mruby_upstream_context *)DATA_PTR(self);
if (ctx) {
mrb_free(mrb, ctx);
}
DATA_TYPE(self) = &ngx_stream_mrb_upstream_context_type;
DATA_PTR(self) = NULL;
ctx = (ngx_stream_mruby_upstream_context *)mrb_malloc(mrb, sizeof(ngx_stream_mruby_upstream_context));
ctx->upstream = upstream;
ctx->target = NULL;
ctx->peers = NULL;
ctx->us = NULL;
umcf = ngx_stream_get_module_main_conf(s, ngx_stream_upstream_module);
usp = umcf->upstreams.elts;
for (i = 0; i < umcf->upstreams.nelts; i++) {
if (ngx_strncasecmp(usp[i]->host.data, (u_char *)RSTRING_PTR(upstream), RSTRING_LEN(upstream)) == 0) {
ctx->us = usp[i];
ctx->peers = usp[i]->peer.data;
if (ctx->peers->number > 1) {
mrb_raise(mrb, E_RUNTIME_ERROR, "don't support multiple server config");
}
ctx->target = ctx->peers->peer;
break;
}
}
DATA_PTR(self) = ctx;
if (ctx->us == NULL || ctx->peers == NULL) {
mrb_raisef(mrb, E_RUNTIME_ERROR, "%S not found upstream config", upstream);
}
if (ctx->target == NULL) {
mrb_raise(mrb, E_RUNTIME_ERROR, "not found server config in upstream");
}
return self;
}
static mrb_value
mrb_uv_sem_init(mrb_state *mrb, mrb_value self)
{
mrb_int v;
uv_sem_t* s;
mrb_get_args(mrb, "i", &v);
s = (uv_sem_t*)mrb_malloc(mrb, sizeof(uv_sem_t));
mrb_uv_check_error(mrb, uv_sem_init(s, v));
DATA_TYPE(self) = &sem_type;
DATA_PTR(self) = s;
return self;
}
static mrb_value mrb_fuse_init(mrb_state *mrb, mrb_value self)
{
mrb_fuse_data *data;
data = (mrb_fuse_data *)DATA_PTR(self);
if (data) {
mrb_free(mrb, data);
}
DATA_TYPE(self) = &mrb_fuse_data_type;
DATA_PTR(self) = NULL;
return self;
}
static mrb_value
color_initialize(mrb_state *mrb, mrb_value self)
{
int argc;
ALLEGRO_COLOR *oc;
ALLEGRO_COLOR *c;
argc = mrb_get_args(mrb, "|d", &oc, &mrbal_color_data_type);
c = mrb_malloc(mrb, sizeof(*c));
*c = argc == 0 ? black : *oc;
DATA_TYPE(self) = &mrbal_color_data_type;
DATA_PTR(self) = c;
return self;
}
// Clears all data associated with cells of one row (string, blob and guid)
void CValueTable::DeleteRowData(int RowIdx)
{
for (int ColIdx = 0; ColIdx < GetNumColumns(); ColIdx++)
{
const CType* Type = GetColumnID(ColIdx)->GetType();
if (Type == TString)
DATA_TYPE_NV(nString)::Delete(GetValuePtr(ColIdx, RowIdx));
else if (Type == DATA_TYPE(CBuffer))
DATA_TYPE_NV(CBuffer)::Delete(GetValuePtr(ColIdx, RowIdx));
else if (!Type)
((CData*)GetValuePtr(ColIdx, RowIdx))->Clear();
}
}
mrb_value
mrb_io_bless(mrb_state *mrb, mrb_value io)
{
if (mrb_type(io) != MRB_TT_DATA) {
mrb_raise(mrb, E_TYPE_ERROR, "expected IO object");
return mrb_nil_value();
}
DATA_TYPE(io) = &mrb_io_type;
DATA_PTR(io) = NULL;
DATA_PTR(io) = mrb_io_alloc(mrb);
return io;
}
static mrb_value
mrb_sdl2_mixer_music_initialize(mrb_state *mrb, mrb_value self)
{
Mix_Music *music = NULL;
mrb_sdl2_mixer_music_data_t *data =
(mrb_sdl2_mixer_music_data_t*)DATA_PTR(self);
if (NULL == data) {
data = (mrb_sdl2_mixer_music_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_mixer_music_data_t));
if (NULL == data) {
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
data->music = NULL;
}
if (1 == mrb->c->ci->argc) {
mrb_value obj;
SDL_RWops *rwops;
mrb_get_args(mrb, "o", &obj);
if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get_under(mrb, mrb->object_class, "String"))) {
music = Mix_LoadMUS(RSTRING_PTR(obj));
} else if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get_under(mrb, mod_SDL2, "RWops"))) {
rwops = mrb_sdl2_rwops_get_ptr(mrb, obj);
music = Mix_LoadMUS_RW(rwops, 0);
} else {
mrb_free(mrb, data);
mrb_raise(mrb, E_RUNTIME_ERROR, "unexpected type.");
}
} else if (2 == mrb->c->ci->argc) {
mrb_value rw;
mrb_int type;
SDL_RWops *rwops;
mrb_get_args(mrb, "oi", &rw, &type);
rwops = mrb_sdl2_rwops_get_ptr(mrb, rw);
music = Mix_LoadMUSType_RW(rwops, (Mix_MusicType) type, 0);
} else {
mrb_free(mrb, data);
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments.");
}
if (NULL == music) {
mrb_free(mrb, data);
mruby_sdl2_raise_error(mrb);
}
data->music = music;
DATA_PTR(self) = data;
DATA_TYPE(self) = &mrb_sdl2_mixer_music_data_type;
return self;
}
mrb_value mrb_digital_out_initialize(mrb_state* mrb, mrb_value self) {
DigitalOut* obj;
int pin;
int value;
int n_args = mrb_get_args(mrb, "i", &pin, &value);
if (n_args == 2) {
obj = new DigitalOut((PinName)pin, value);
} else {
obj = new DigitalOut((PinName)pin);
}
DATA_TYPE(self) = &mrb_digital_out_type;
DATA_PTR(self) = obj;
return self;
}
mrb_value
cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
{
struct cfunc_closure_data *data;
data = mrb_data_check_get_ptr(mrb, self, &cfunc_closure_data_type);
if (!data) {
data = mrb_malloc(mrb, sizeof(struct cfunc_closure_data));
}
data->refer = 0;
data->autofree = 0;
DATA_PTR(self) = data;
DATA_TYPE(self) = &cfunc_closure_data_type;
data->mrb = mrb;
data->closure = NULL;
data->arg_types = NULL;
mrb_value rettype_mrb, block, args_mrb;
mrb_get_args(mrb, "&oo", &block, &rettype_mrb, &args_mrb);
data->argc = RARRAY_LEN(args_mrb);
ffi_type *return_ffi_type = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(rettype_mrb))->ffi_type_value;
data->return_type = rettype_mrb;
data->arg_ffi_types = mrb_malloc(mrb, sizeof(ffi_type*) * data->argc);
data->arg_types = mrb_malloc(mrb, sizeof(mrb_value) * data->argc);
int i;
for (i = 0; i < data->argc; ++i) {
data->arg_types[i] = mrb_ary_ref(mrb, args_mrb, i);
data->arg_ffi_types[i] = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(data->arg_types[i]))->ffi_type_value;
}
mrb_iv_set(mrb, self, mrb_intern_cstr(data->mrb, "@block"), block);
void *closure_pointer = NULL;
data->closure = ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), &closure_pointer);
data->cif = mrb_malloc(mrb, sizeof(ffi_cif));
if (data->closure) {
if (ffi_prep_cif(data->cif, FFI_DEFAULT_ABI, data->argc, return_ffi_type, data->arg_ffi_types) == FFI_OK) {
if (ffi_prep_closure_loc(data->closure, data->cif, cfunc_closure_call_binding, mrb_object(self), closure_pointer) == FFI_OK) {
set_cfunc_pointer_data((struct cfunc_type_data *)data, closure_pointer);
return self;
}
}
}
mrb_raise(mrb, E_SCRIPT_ERROR, "Internal FFI call error");
return mrb_nil_value();
}
Number& Number::operator <<= (size_t bits)
{
if (data.back() != 0)
{
for (size_t s = 0 ; s < bits; ++s)
{
auto i = data.begin();
auto e = data.end();
bool setFirstBit = false;
for (; i != e; ++i)
{
(*i) = (*i) << 1;
if (setFirstBit)
{
(*i) |= DATA_TYPE(1);
}
//check overload
if (((*i) & (DATA_TYPE(1) << last_bit_num)) != 0)
{
setFirstBit = true;
//reset overload bit
(*i) ^= (DATA_TYPE(1) << last_bit_num);
}
else
{
setFirstBit = false;
}
}
if (setFirstBit)
{
data.emplace_back(DATA_TYPE(1));
}
}
}
return *this;
}
static mrb_value
mrb_uv_barrier_init(mrb_state *mrb, mrb_value self)
{
mrb_int arg_count;
uv_barrier_t* context = NULL;
mrb_get_args(mrb, "i", &arg_count);
context = (uv_barrier_t*)mrb_malloc(mrb, sizeof(uv_barrier_t));
mrb_uv_check_error(mrb, uv_barrier_init(context, arg_count));
DATA_PTR(self) = context;
DATA_TYPE(self) = &barrier_type;
return self;
}
static mrb_value
mrb_queue_set_queue(mrb_value self, dispatch_queue_t q)
{
dispatch_queue_t old_q;
old_q = (dispatch_queue_t)DATA_PTR(self);
if (old_q) {
dispatch_release(old_q);
}
DATA_TYPE(self) = &mrb_dispatch_object_type;
DATA_PTR(self) = q;
return self;
}
static mrb_value
mrb_queue_init(mrb_state* mrb, mrb_value self) {
mrb_queue_context* context = (mrb_queue_context*) malloc(sizeof(mrb_queue_context));
pthread_mutex_init(&context->mutex, NULL);
pthread_mutex_init(&context->queue_lock, NULL);
if (pthread_mutex_lock(&context->queue_lock) != 0) {
mrb_raise(mrb, E_RUNTIME_ERROR, "cannot lock");
}
context->mrb = mrb;
context->queue = mrb_ary_new(mrb);
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "queue"), context->queue);
DATA_PTR(self) = context;
DATA_TYPE(self) = &mrb_queue_context_type;
return self;
}
mrb_value
mrb_io_initialize_copy(mrb_state *mrb, mrb_value copy)
{
mrb_value orig;
mrb_value buf;
struct mrb_io *fptr_copy;
struct mrb_io *fptr_orig;
mrb_bool failed = TRUE;
mrb_get_args(mrb, "o", &orig);
fptr_orig = io_get_open_fptr(mrb, orig);
fptr_copy = (struct mrb_io *)DATA_PTR(copy);
if (fptr_orig == fptr_copy) return copy;
if (fptr_copy != NULL) {
fptr_finalize(mrb, fptr_copy, FALSE);
mrb_free(mrb, fptr_copy);
}
fptr_copy = (struct mrb_io *)mrb_io_alloc(mrb);
DATA_TYPE(copy) = &mrb_io_type;
DATA_PTR(copy) = fptr_copy;
buf = mrb_iv_get(mrb, orig, mrb_intern_cstr(mrb, "@buf"));
mrb_iv_set(mrb, copy, mrb_intern_cstr(mrb, "@buf"), buf);
fptr_copy->fd = mrb_dup(mrb, fptr_orig->fd, &failed);
if (failed) {
mrb_sys_fail(mrb, 0);
}
mrb_fd_cloexec(mrb, fptr_copy->fd);
if (fptr_orig->fd2 != -1) {
fptr_copy->fd2 = mrb_dup(mrb, fptr_orig->fd2, &failed);
if (failed) {
close(fptr_copy->fd);
mrb_sys_fail(mrb, 0);
}
mrb_fd_cloexec(mrb, fptr_copy->fd2);
}
fptr_copy->pid = fptr_orig->pid;
fptr_copy->readable = fptr_orig->readable;
fptr_copy->writable = fptr_orig->writable;
fptr_copy->sync = fptr_orig->sync;
fptr_copy->is_socket = fptr_orig->is_socket;
return copy;
}
static mrb_value
mrb_ev3_initialize(mrb_state *mrb, mrb_value self)
{
struct ev3_state *state = mrb_malloc(mrb, sizeof(struct ev3_state));
DATA_TYPE(self) = &ev3_type;
DATA_PTR(self) = state;
state->lms_ui = open("/dev/lms_ui", O_RDWR|O_SYNC);
state->keypad = MAP_FAILED;
if(state->lms_ui > 0) {
state->keypad = mmap(NULL, 6, PROT_READ|PROT_WRITE, MAP_SHARED, state->lms_ui, 0);
}
return mrb_nil_value();
}
mrb_value
mrb_uv_dlopen(mrb_state *mrb, char const *name)
{
mrb_value ret = mrb_obj_value(mrb_obj_alloc(mrb, MRB_TT_DATA, mrb_class_get_under(mrb, mrb_module_get(mrb, "UV"), "DL")));
uv_lib_t *lib = (uv_lib_t*)mrb_malloc(mrb, sizeof(uv_lib_t));
int err;
DATA_TYPE(ret) = &dl_type;
DATA_PTR(ret) = lib;
err = uv_dlopen(name, lib);
if (err == -1) {
mrb_raise(mrb, E_UV_ERROR, uv_dlerror(lib));
}
return ret;
}
static mrb_value
mrb_uv_rwlock_init(mrb_state *mrb, mrb_value self)
{
int err;
uv_rwlock_t *rwlock;
rwlock = (uv_rwlock_t*)mrb_malloc(mrb, sizeof(uv_rwlock_t));
err = uv_rwlock_init(rwlock);
if (err < 0) {
mrb_free(mrb, rwlock);
mrb_uv_check_error(mrb, err);
}
DATA_PTR(self) = rwlock;
DATA_TYPE(self) = &mrb_uv_rwlock_type;
return self;
}
mrb_value
regexp_pcre_initialize(mrb_state *mrb, mrb_value self)
{
int erroff = 0, coptions;
const char *errstr = NULL;
struct mrb_regexp_pcre *reg = NULL;
mrb_value source, opt = mrb_nil_value();
reg = (struct mrb_regexp_pcre *)DATA_PTR(self);
if (reg) {
mrb_regexp_free(mrb, reg);
}
DATA_TYPE(self) = &mrb_regexp_type;
DATA_PTR(self) = NULL;
mrb_get_args(mrb, "S|o", &source, &opt);
reg = mrb_malloc(mrb, sizeof(struct mrb_regexp_pcre));
reg->re = NULL;
DATA_PTR(self) = reg;
coptions = mrb_mruby_to_pcre_options(opt);
source = mrb_str_new(mrb, RSTRING_PTR(source), RSTRING_LEN(source));
reg->re = pcre_compile(RSTRING_PTR(source), coptions, &errstr, &erroff, NULL);
if (reg->re == NULL) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid regular expression");
}
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@source"), source);
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@options"), mrb_fixnum_value(mrb_pcre_to_mruby_options(coptions)));
unsigned char *name_table;
int i, namecount, name_entry_size;
pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMECOUNT, &namecount);
if (namecount > 0) {
pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMETABLE, &name_table);
pcre_fullinfo(reg->re, NULL, PCRE_INFO_NAMEENTRYSIZE, &name_entry_size);
unsigned char *tabptr = name_table;
for (i = 0; i < namecount; i++) {
int n = (tabptr[0] << 8) | tabptr[1];
mrb_funcall(mrb, self, "name_push", 2, mrb_str_new(mrb, (const char *)(tabptr + 2), strlen((const char *)tabptr + 2)), mrb_fixnum_value(n));
tabptr += name_entry_size;
}
}
return self;
}
static mrb_value
sha512_initialize(mrb_state *mrb, mrb_value self)
{
char *str;
int len;
SHA512_CTX *ctx = (SHA512_CTX*)mrb_malloc(mrb, sizeof(SHA512_CTX));
SHA512_Init(ctx);
DATA_TYPE(self) = &sha512_type;
DATA_PTR(self) = ctx;
if (mrb_get_args(mrb, "|s", &str, &len) == 1) {
SHA512_Update(ctx, (const u_int8_t *)str, len);
}
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)) {
DATA_PTR(copy) = mrb_malloc(mrb, sizeof(struct mrb_time));
DATA_TYPE(copy) = &mrb_time_type;
}
memcpy(DATA_PTR(copy), DATA_PTR(src), sizeof(struct mrb_time));
return copy;
}
static mrb_value mrb_thumbnail_initialize(mrb_state *mrb, mrb_value self)
{
mrb_int arg_id;
mrb_thumbnail *thumbnail;
mrb_get_args(mrb, "i", &arg_id);
thumbnail = mrb_thumbnail_wrap(mrb, arg_id);
if (thumbnail == NULL) {
return self;
}
DATA_PTR(self) = thumbnail;
DATA_TYPE(self) = &mrb_thumbnail_type;
return self;
}
static mrb_value
mrb_ipvs_service_init_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)) {
DATA_PTR(copy) = (struct mrb_ipvs_entry*)mrb_malloc(mrb, sizeof(struct mrb_ipvs_entry));
DATA_TYPE(copy) = &mrb_ipvs_service_type;
}
*(struct mrb_ipvs_entry*)DATA_PTR(copy) = *(struct mrb_ipvs_entry*)DATA_PTR(src);
return copy;
}
static mrb_value mrb_entropy_initialize(mrb_state *mrb, mrb_value self) {
entropy_context *entropy;
entropy = (entropy_context *)DATA_PTR(self);
if (entropy) {
mrb_free(mrb, entropy);
}
DATA_TYPE(self) = &mrb_entropy_type;
DATA_PTR(self) = NULL;
entropy = (entropy_context *)mrb_malloc(mrb, sizeof(entropy_context));
DATA_PTR(self) = entropy;
entropy_init(entropy);
return self;
}
static mrb_value
mrb_uv_cond_init(mrb_state *mrb, mrb_value self)
{
int err;
uv_cond_t *cond;
cond = (uv_cond_t*)mrb_malloc(mrb, sizeof(uv_cond_t));
err = uv_cond_init(cond);
if (err < 0) {
mrb_free(mrb, cond);
mrb_uv_check_error(mrb, err);
}
DATA_PTR(self) = cond;
DATA_TYPE(self) = &mrb_uv_cond_type;
return self;
}
static mrb_value
mrb_sdl2_mixer_chunk_initialize(mrb_state *mrb, mrb_value self)
{
Mix_Chunk *chunk = NULL;
mrb_sdl2_mixer_chunk_data_t *data =
(mrb_sdl2_mixer_chunk_data_t*)DATA_PTR(self);
if (NULL == data) {
data = (mrb_sdl2_mixer_chunk_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_mixer_chunk_data_t));
if (NULL == data) {
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
data->chunk = NULL;
}
SDL_RWops *rwops;
bool str = false;
if (1 == mrb->c->ci->argc) {
mrb_value v;
mrb_get_args(mrb, "o", &v);
if (mrb_type(v) == MRB_TT_STRING) {
rwops = SDL_RWFromFile(RSTRING_PTR(v), "r");
str = true;
}
else if (mrb_type(v) == MRB_TT_OBJECT)
rwops = mrb_sdl2_rwops_get_ptr(mrb, v);
chunk = Mix_LoadWAV_RW(rwops, 0);
} else {
mrb_free(mrb, data);
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments.");
}
if (NULL == chunk) {
mrb_free(mrb, data);
if (str)
SDL_FreeRW(rwops);
mruby_sdl2_raise_error(mrb);
}
if (str)
SDL_FreeRW(rwops);
data->chunk = chunk;
DATA_PTR(self) = data;
DATA_TYPE(self) = &mrb_sdl2_mixer_chunk_data_type;
return self;
}
static mrb_value mrb_ecdsa_alloc(mrb_state *mrb, mrb_value self) {
ecdsa_context *ecdsa;
ecdsa = (ecdsa_context *)DATA_PTR(self);
if (ecdsa) {
mrb_ecdsa_free(mrb, ecdsa);
}
DATA_TYPE(self) = &mrb_ecdsa_type;
DATA_PTR(self) = NULL;
ecdsa = (ecdsa_context *)mrb_malloc(mrb, sizeof(ecdsa_context));
DATA_PTR(self) = ecdsa;
ecdsa_init(ecdsa);
return self;
}
static mrb_value
mrb_uv_key_init(mrb_state *mrb, mrb_value self)
{
uv_key_t *key;
int err;
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "values"), mrb_ary_new(mrb));
key = (uv_key_t*)mrb_malloc(mrb, sizeof(uv_key_t));
err = uv_key_create(key);
if (err < 0) {
mrb_free(mrb, key);
mrb_uv_check_error(mrb, err);
}
DATA_PTR(self) = key;
DATA_TYPE(self) = &mrb_uv_key_type;
return self;
}
mrb_value ofRuby3DPrimitive::init(mrb_state *mrb, mrb_value self) {
struct Primitive *primitive;
primitive = (struct Primitive*) DATA_PTR(self);
// Initialize Object, clear possiable exists data
if(primitive) {
free(mrb, primitive);
}
DATA_TYPE(self) = &ofRuby3DPrimitiveType;
DATA_PTR(self) = NULL;
primitive = alloc(mrb);
primitive->instance = new of3dPrimitive();
DATA_PTR(self) = primitive;
return self;
}
static mrb_value mrb_curses_init(mrb_state *mrb, mrb_value self)
{
mrb_curses_data *data;
data = (mrb_curses_data *)DATA_PTR(self);
if (data) {
mrb_free(mrb, data);
}
DATA_TYPE(self) = &mrb_curses_data_type;
DATA_PTR(self) = NULL;
data = (mrb_curses_data *)mrb_malloc(mrb, sizeof(mrb_curses_data));
data->str = "dummy";
data->len = 5;
DATA_PTR(self) = data;
return self;
}
