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; }