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;
}
static void
ary_make_shared(mrb_state *mrb, struct RArray *a)
{
if (!ARY_SHARED_P(a)) {
mrb_shared_array *shared = (mrb_shared_array *)mrb_malloc(mrb, sizeof(mrb_shared_array));
shared->refcnt = 1;
if (a->aux.capa > a->len) {
a->ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
}
else {
shared->ptr = a->ptr;
}
shared->len = a->len;
a->aux.shared = shared;
ARY_SET_SHARED_FLAG(a);
}
}
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_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;
}
static mrb_sym
mrb_id_attrset(mrb_state *mrb, mrb_sym id)
{
const char *name;
char *buf;
mrb_int len;
mrb_sym mid;
name = mrb_sym2name_len(mrb, id, &len);
buf = (char *)mrb_malloc(mrb, (size_t)len+2);
memcpy(buf, name, (size_t)len);
buf[len] = '=';
buf[len+1] = '\0';
mid = mrb_intern(mrb, buf, len+1);
mrb_free(mrb, buf);
return mid;
}
static void
ary_make_shared(mrb_state *mrb, struct RArray *a)
{
if (!(a->flags & MRB_ARY_SHARED)) {
struct mrb_shared_array *shared = (struct mrb_shared_array *)mrb_malloc(mrb, sizeof(struct mrb_shared_array));
shared->refcnt = 1;
if (a->aux.capa > a->len) {
a->ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, a->ptr, sizeof(mrb_value)*a->len+1);
}
else {
shared->ptr = a->ptr;
}
shared->len = a->len;
a->aux.shared = shared;
a->flags |= MRB_ARY_SHARED;
}
}
static mrb_value ngx_http_mruby_base64_encode(mrb_state *mrb, mrb_value self)
{
mrb_value mrb_src;
ngx_str_t src, dst;
mrb_get_args(mrb, "o", &mrb_src);
mrb_src = mrb_obj_as_string(mrb, mrb_src);
src.data = (u_char *)RSTRING_PTR(mrb_src);
src.len = RSTRING_LEN(mrb_src);
dst.len = ngx_base64_encoded_length(src.len);
dst.data = mrb_malloc(mrb, dst.len + 1);
ngx_encode_base64(&dst, &src);
return mrb_str_new(mrb, (char *)dst.data, dst.len);
}
/*
* 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 void*
mrb_calloc(mrb_state *mrb, size_t nelem, size_t len)
{
void *p;
if (nelem > 0 && len > 0 &&
nelem <= SIZE_MAX / len) {
size_t size;
size = nelem * len;
p = mrb_malloc(mrb, size);
memset(p, 0, size);
}
else {
p = NULL;
}
return p;
}
static int
read_section_lv(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, uint8_t flags)
{
const uint8_t *bin;
ptrdiff_t diff;
struct rite_section_lv_header const *header;
uint32_t i;
size_t len = 0;
int result;
uint32_t syms_len;
mrb_sym *syms;
mrb_sym (*intern_func)(mrb_state*, const char*, size_t) =
(flags & FLAG_SRC_MALLOC)? mrb_intern : mrb_intern_static;
bin = start;
header = (struct rite_section_lv_header const*)bin;
bin += sizeof(struct rite_section_lv_header);
syms_len = bin_to_uint32(bin);
bin += sizeof(uint32_t);
syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)syms_len);
for (i = 0; i < syms_len; ++i) {
uint16_t const str_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
syms[i] = intern_func(mrb, (const char*)bin, str_len);
bin += str_len;
}
result = read_lv_record(mrb, bin, irep, &len, syms, syms_len);
if (result != MRB_DUMP_OK) goto lv_exit;
bin += len;
diff = bin - start;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
result = MRB_DUMP_GENERAL_FAILURE;
}
lv_exit:
mrb_free(mrb, syms);
return result;
}
static int
read_rite_section_debug(mrb_state *mrb, const uint8_t *start, size_t sirep)
{
const uint8_t *bin;
struct rite_section_debug_header *header;
uint16_t i;
int result;
uint16_t nirep;
size_t filenames_len;
mrb_sym *filenames;
bin = start;
header = (struct rite_section_debug_header *)bin;
bin += sizeof(struct rite_section_debug_header);
nirep = bin_to_uint16(header->nirep);
filenames_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym*) * filenames_len);
for(i = 0; i < filenames_len; ++i) {
uint16_t f_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
filenames[i] = mrb_intern2(mrb, (const char *)bin, f_len);
bin += f_len;
}
for(i = sirep; i < (sirep + nirep); ++i) {
uint32_t len = 0;
result = read_rite_debug_record(mrb, bin, i, &len, filenames, filenames_len);
if (result != MRB_DUMP_OK) { goto debug_exit; }
bin += len;
}
if ((bin - start) != bin_to_uint32(header->section_size)) {
return MRB_DUMP_GENERAL_FAILURE;
}
result = sirep + bin_to_uint16(header->sirep);
debug_exit:
mrb_free(mrb, filenames);
return result;
}
mrb_value
mrb_matchdata_init(mrb_state *mrb, mrb_value self)
{
struct mrb_matchdata *mrb_md;
mrb_md = (struct mrb_matchdata *)DATA_PTR(self);
if (mrb_md) {
mrb_matchdata_free(mrb, mrb_md);
}
DATA_TYPE(self) = &mrb_matchdata_type;
DATA_PTR(self) = NULL;
mrb_md = (struct mrb_matchdata *)mrb_malloc(mrb, sizeof(*mrb_md));
mrb_md->ovector = NULL;
mrb_md->length = -1;
DATA_PTR(self) = mrb_md;
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_service *)mrb_malloc(
mrb, sizeof(struct mrb_ipvs_service));
DATA_TYPE(copy) = &mrb_ipvs_service_type;
}
*(struct mrb_ipvs_service *)DATA_PTR(copy) =
*(struct mrb_ipvs_service *)DATA_PTR(src);
return copy;
}
static int
write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
{
int sym_no;
char *buf_top = buf;
char *char_buf;
uint16_t buf_size =0;
buf_size = MRB_DUMP_DEFAULT_STR_LEN;
if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
goto error_exit;
buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */
for (sym_no = 0; sym_no < irep->slen; sym_no++) {
const char * name;
uint16_t nlen =0;
if (irep->syms[sym_no] != 0) {
name = mrb_sym2name(mrb, irep->syms[sym_no]);
nlen = str_dump_len((char*)name, strlen(name), type);
if ( nlen > buf_size - 1) {
buf_size = nlen + 1;
if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
goto error_exit;
}
memset(char_buf, 0, buf_size);
str_dump((char*)name, char_buf, strlen(name), type);
buf += uint16_dump(nlen, buf, type); /* length of symbol name */
memcpy(buf, char_buf, nlen); /* symbol name */
buf += nlen;
}
else {
buf += uint16_dump(MRB_DUMP_NULL_SYM_LEN, buf, type); /* length of symbol name */
}
}
error_exit:
if (char_buf)
mrb_free(mrb, char_buf);
return (int)(buf - buf_top);
}
mrb_value mrb_directfb_surface_wrap(mrb_state* mrb, struct RClass* c, IDirectFBSurface* surface)
{
struct mrb_directfb_surface_data* data = NULL;
int width = 0;
int height = 0;
surface->GetSize(surface, &width, &height);
data = mrb_malloc(mrb, sizeof(struct mrb_directfb_surface_data));
data->surface = surface;
data->width = width;
data->height = height;
{
mrb_value obj = mrb_obj_value(Data_Wrap_Struct(mrb, c, &mrb_directfb_surface_type, data));
mrb_iv_set(mrb, obj, mrb_intern_lit(mrb, "font"), mrb_nil_value());
return obj;
}
}
static void
add_heap(mrb_state *mrb)
{
struct heap_page *page = mrb_malloc(mrb, sizeof(struct heap_page));
RVALUE *p, *e;
struct RBasic *prev = NULL;
memset(page, 0, sizeof(struct heap_page));
for (p = page->objects, e=p+HEAP_PAGE_SIZE; p<e; p++) {
p->as.free.tt = MRB_TT_FREE;
p->as.free.next = prev;
prev = &p->as.basic;
}
page->freelist = prev;
link_heap_page(mrb, page);
link_free_heap_page(mrb, page);
}
static void
ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len)
{
mrb_int capa = ARY_CAPA(a);
if (len > ARY_MAX_SIZE || len < 0) {
size_error:
mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
}
if (capa < ARY_DEFAULT_LEN) {
capa = ARY_DEFAULT_LEN;
}
while (capa < len) {
if (capa <= ARY_MAX_SIZE / 2) {
capa *= 2;
}
else {
capa = len;
}
}
if (capa < len || capa > ARY_MAX_SIZE) {
goto size_error;
}
if (ARY_EMBED_P(a)) {
mrb_value *ptr = ARY_EMBED_PTR(a);
mrb_int len = ARY_EMBED_LEN(a);
mrb_value *expanded_ptr = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*capa);
ARY_UNSET_EMBED_FLAG(a);
array_copy(expanded_ptr, ptr, len);
a->as.heap.len = len;
a->as.heap.aux.capa = capa;
a->as.heap.ptr = expanded_ptr;
}
else if (capa > a->as.heap.aux.capa) {
mrb_value *expanded_ptr = (mrb_value *)mrb_realloc(mrb, a->as.heap.ptr, sizeof(mrb_value)*capa);
a->as.heap.aux.capa = capa;
a->as.heap.ptr = expanded_ptr;
}
}
static mrb_sym
sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name *sname = mrb->symtbl; /* symtbl[0] for working memory */
khiter_t k;
mrb_sym sym;
char *p;
sym_validate_len(mrb, len);
if (sname) {
sname->lit = lit;
sname->len = (uint16_t)len;
sname->name = name;
k = kh_get(n2s, mrb, h, 0);
if (k != kh_end(h))
return kh_key(h, k);
}
/* registering a new symbol */
sym = ++mrb->symidx;
if (mrb->symcapa < sym) {
if (mrb->symcapa == 0) mrb->symcapa = 100;
else mrb->symcapa = (size_t)(mrb->symcapa * 1.2);
mrb->symtbl = (symbol_name*)mrb_realloc(mrb, mrb->symtbl, sizeof(symbol_name)*(mrb->symcapa+1));
}
sname = &mrb->symtbl[sym];
sname->len = (uint16_t)len;
if (lit || mrb_ro_data_p(name)) {
sname->name = name;
sname->lit = TRUE;
}
else {
p = (char *)mrb_malloc(mrb, len+1);
memcpy(p, name, len);
p[len] = 0;
sname->name = (const char*)p;
sname->lit = FALSE;
}
kh_put(n2s, mrb, h, sym);
return sym;
}
static int
read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len)
{
const uint8_t *bin = start;
ptrdiff_t diff;
int i;
irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
for (i = 0; i + 1< irep->nlocals; ++i) {
uint16_t const sym_idx = bin_to_uint16(bin);
bin += sizeof(uint16_t);
if (sym_idx == RITE_LV_NULL_MARK) {
irep->lv[i].name = 0;
irep->lv[i].r = 0;
}
else {
if (sym_idx >= syms_len) {
return MRB_DUMP_GENERAL_FAILURE;
}
irep->lv[i].name = syms[sym_idx];
irep->lv[i].r = bin_to_uint16(bin);
}
bin += sizeof(uint16_t);
}
for (i = 0; i < irep->rlen; ++i) {
size_t len;
int ret;
ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len);
if (ret != MRB_DUMP_OK) return ret;
bin += len;
}
diff = bin - start;
mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
*record_len = (size_t)diff;
return MRB_DUMP_OK;
}
void
mrb_init_proc(mrb_state *mrb)
{
struct RProc *m;
mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
static const mrb_irep mrb_irep_zero = { 0 };
mrbjit_code_info *cinfo;
int i;
if (call_irep == NULL)
return;
*call_irep = mrb_irep_zero;
call_irep->flags = MRB_ISEQ_NO_FREE;
call_irep->iseq = call_iseq;
call_irep->ilen = 2;
call_irep->jit_entry_tab = (mrbjit_codetab *)mrb_calloc(mrb, 2, sizeof(mrbjit_codetab));
for (i = 0; i < 2; i++) {
call_irep->jit_entry_tab[i].size = 16;
cinfo = (mrbjit_code_info *)mrb_calloc(mrb, 16, sizeof(mrbjit_code_info));
call_irep->jit_entry_tab[i].body = cinfo;
}
call_irep->prof_info = (int *)mrb_calloc(mrb, 2, sizeof(int));
call_irep->method_kind = NORMAL;
call_irep->jit_top_entry = NULL;
call_irep->simple_lambda = 1;
call_irep->proc_obj = NULL;
mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class);
MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
mrb_define_method(mrb, mrb->proc_class, "initialize", mrb_proc_initialize, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE());
m = mrb_proc_new(mrb, call_irep);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m);
mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6 */
mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */
}
static mrb_value
mrb_ipvs_dest_init(mrb_state *mrb, mrb_value self){
int parse;
mrb_value arg_opt = mrb_nil_value(),
addr = mrb_nil_value(),
obj = mrb_nil_value();
mrb_int port,
weight;
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");
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");
weight = mrb_fixnum(mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "weight")));
obj = mrb_hash_get(mrb, arg_opt, mrb_str_new_cstr(mrb, "weight"));
weight = mrb_nil_p(obj) ? DEF_WEIGHT : mrb_fixnum(obj);
if (weight < 0 || weight > INT_MAX) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid weight value specified");
if (strrchr((char *) RSTRING_PTR(addr), ':') == NULL) ie->svc.port = htons(port);
parse = parse_service((char *) RSTRING_PTR(addr), &ie->svc);
if (!(parse & SERVICE_ADDR))
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@service"), mrb_nil_value());
ie->dest.af = ie->svc.af;
ie->dest.addr = ie->svc.addr;
ie->dest.port = ie->svc.port;
ie->dest.weight = weight;
DATA_TYPE(self) = &mrb_ipvs_dest_type;
DATA_PTR(self) = ie;
return self;
}
static int
read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_bool alloc)
{
const uint8_t *bin;
struct rite_section_debug_header *header;
uint16_t i;
uint32_t len = 0;
int result;
size_t filenames_len;
mrb_sym *filenames;
bin = start;
header = (struct rite_section_debug_header *)bin;
bin += sizeof(struct rite_section_debug_header);
filenames_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * filenames_len);
for(i = 0; i < filenames_len; ++i) {
uint16_t f_len = bin_to_uint16(bin);
bin += sizeof(uint16_t);
if (alloc) {
filenames[i] = mrb_intern(mrb, (const char *)bin, f_len);
}
else {
filenames[i] = mrb_intern_static(mrb, (const char *)bin, f_len);
}
bin += f_len;
}
result = read_debug_record(mrb, bin, irep, &len, filenames, filenames_len);
if (result != MRB_DUMP_OK) goto debug_exit;
bin += len;
if ((bin - start) != bin_to_uint32(header->section_size)) {
result = MRB_DUMP_GENERAL_FAILURE;
}
debug_exit:
mrb_free(mrb, filenames);
return result;
}
static char *
get_outfilename(mrb_state *mrb, char *infile, const char *ext)
{
size_t infilelen;
size_t extlen;
char *outfile;
char *p;
infilelen = strlen(infile);
extlen = strlen(ext);
outfile = (char*)mrb_malloc(mrb, infilelen + extlen + 1);
memcpy(outfile, infile, infilelen + 1);
if (*ext) {
if ((p = strrchr(outfile, '.')) == NULL)
p = outfile + infilelen;
memcpy(p, ext, extlen + 1);
}
return outfile;
}
static void
cipop(mrb_state *mrb)
{
struct mrb_context *c = mrb->c;
if (c->ci->env) {
struct REnv *e = c->ci->env;
size_t len = (size_t)MRB_ENV_STACK_LEN(e);
mrb_value *p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len);
MRB_ENV_UNSHARE_STACK(e);
if (len > 0) {
stack_copy(p, e->stack, len);
}
e->stack = p;
mrb_write_barrier(mrb, (struct RBasic *)e);
}
c->ci--;
}
static mrb_value
mrb_sdl2_cond_initialize(mrb_state *mrb, mrb_value self)
{
mrb_sdl2_cond_data_t *data =
(mrb_sdl2_cond_data_t*)DATA_PTR(self);
if (NULL == data) {
data = (mrb_sdl2_cond_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_cond_data_t));
if (NULL == data) {
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
}
data->cond = SDL_CreateCond();
if (NULL == data->cond) {
mrb_free(mrb, data);
mruby_sdl2_raise_error(mrb);
}
DATA_PTR(self) = data;
DATA_TYPE(self) = &mrb_sdl2_cond_data_type;
return self;
}
static mrb_value
mrb_uv_once_init(mrb_state *mrb, mrb_value self)
{
uv_once_t *once;
mrb_value b;
static uv_once_t const initial_once = UV_ONCE_INIT;
mrb_get_args(mrb, "&", &b);
if (mrb_nil_p(b)) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "block not passed to UV::Once initialization");
}
once = (uv_once_t*)mrb_malloc(mrb, sizeof(uv_once_t));
*once = initial_once;
DATA_PTR(self) = once;
DATA_TYPE(self) = &mrb_uv_once_type;
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "once_cb"), b);
return self;
}
static char*
dirname(mrb_state *mrb, const char *path)
{
size_t len;
const char *p;
char *dir;
if (path == NULL) {
return NULL;
}
p = strrchr(path, '/');
len = p != NULL ? (size_t)(p - path) : strlen(path);
dir = (char*)mrb_malloc(mrb, len + 1);
strncpy(dir, path, len);
dir[len] = '\0';
return dir;
}
static void
ary_make_shared(mrb_state *mrb, struct RArray *a)
{
if (!ARY_SHARED_P(a) && !ARY_EMBED_P(a)) {
mrb_shared_array *shared = (mrb_shared_array *)mrb_malloc(mrb, sizeof(mrb_shared_array));
mrb_value *ptr = a->as.heap.ptr;
mrb_int len = a->as.heap.len;
shared->refcnt = 1;
if (a->as.heap.aux.capa > len) {
a->as.heap.ptr = shared->ptr = (mrb_value *)mrb_realloc(mrb, ptr, sizeof(mrb_value)*len+1);
}
else {
shared->ptr = ptr;
}
shared->len = len;
a->as.heap.aux.shared = shared;
ARY_SET_SHARED_FLAG(a);
}
}
void
mrb_state_atexit(mrb_state *mrb, mrb_atexit_func f)
{
#ifdef MRB_FIXED_STATE_ATEXIT_STACK
if (mrb->atexit_stack_len + 1 > MRB_FIXED_STATE_ATEXIT_STACK_SIZE) {
mrb_raise(mrb, E_RUNTIME_ERROR, "exceeded fixed state atexit stack limit");
}
#else
size_t stack_size;
stack_size = sizeof(mrb_atexit_func) * (mrb->atexit_stack_len + 1);
if (mrb->atexit_stack_len == 0) {
mrb->atexit_stack = (mrb_atexit_func*)mrb_malloc(mrb, stack_size);
} else {
mrb->atexit_stack = (mrb_atexit_func*)mrb_realloc(mrb, mrb->atexit_stack, stack_size);
}
#endif
mrb->atexit_stack[mrb->atexit_stack_len++] = f;
}
static mrb_value
mrb_digest_init_copy(mrb_state *mrb, mrb_value copy)
{
struct mrb_md *m1, *m2;
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_md));
DATA_TYPE(copy) = &mrb_md_type;
}
m1 = DATA_PTR(src);
m2 = DATA_PTR(copy);
lib_md_init_copy(mrb, m2, m1);
return copy;
}
