Skip to content

Commit 55d94e9

Browse files
masuidrivemasuidrive
committed
Change malloc to mrb_malloc
1 parent f0b0f13 commit 55d94e9

File tree

6 files changed

+60
-60
lines changed

6 files changed

+60
-60
lines changed

‎src/cfunc_call.c

+12-12
Original file line numberDiff line numberDiff line change
@@ -79,8 +79,8 @@ cfunc_call(mrb_state *mrb, mrb_value self)
7979
}
8080
}
8181

82-
args = malloc(sizeof(ffi_type*) * margc);
83-
values = malloc(sizeof(void*) * margc);
82+
args = mrb_malloc(mrb, sizeof(ffi_type*) * margc);
83+
values = mrb_malloc(mrb, sizeof(void*) * margc);
8484
mrb_sym sym_to_ffi_value = mrb_intern(mrb, "to_ffi_value");
8585

8686
mrb_value nil_ary[1];
@@ -108,10 +108,10 @@ cfunc_call(mrb_state *mrb, mrb_value self)
108108
if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, margc, result_type, args) == FFI_OK) {
109109
void *result;
110110
if(result_type->size > sizeof(long)) {
111-
result = malloc(result_type->size);
111+
result = mrb_malloc(mrb, result_type->size);
112112
}
113113
else if(result_type->size) {
114-
result = malloc(sizeof(long));
114+
result = mrb_malloc(mrb, sizeof(long));
115115
}
116116
else {
117117
result = NULL;
@@ -129,8 +129,8 @@ cfunc_call(mrb_state *mrb, mrb_value self)
129129
}
130130

131131
cfunc_call_exit:
132-
free(values);
133-
free(args);
132+
mrb_free(mrb, values);
133+
mrb_free(mrb, args);
134134
return mresult;
135135
}
136136

@@ -164,8 +164,8 @@ cfunc_libcall(mrb_state *mrb, mrb_value self)
164164
}
165165
}
166166

167-
args = malloc(sizeof(ffi_type*) * margc);
168-
values = malloc(sizeof(void*) * margc);
167+
args = mrb_malloc(mrb, sizeof(ffi_type*) * margc);
168+
values = mrb_malloc(mrb, sizeof(void*) * margc);
169169
mrb_sym sym_to_ffi_value = mrb_intern(mrb, "to_ffi_value");
170170

171171
mrb_value nil_ary[1];
@@ -193,10 +193,10 @@ cfunc_libcall(mrb_state *mrb, mrb_value self)
193193
if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, margc, result_type, args) == FFI_OK) {
194194
void *result;
195195
if(result_type->size > sizeof(long)) {
196-
result = malloc(result_type->size);
196+
result = mrb_malloc(mrb, result_type->size);
197197
}
198198
else if(result_type->size) {
199-
result = malloc(sizeof(long));
199+
result = mrb_malloc(mrb, sizeof(long));
200200
}
201201
else {
202202
result = NULL;
@@ -214,8 +214,8 @@ cfunc_libcall(mrb_state *mrb, mrb_value self)
214214
}
215215

216216
cfunc_call_exit:
217-
free(values);
218-
free(args);
217+
mrb_free(mrb, values);
218+
mrb_free(mrb, args);
219219
return mresult;
220220
}
221221

‎src/cfunc_closure.c

+11-11
Original file line numberDiff line numberDiff line change
@@ -29,10 +29,10 @@ cfunc_closure_destructor(mrb_state *mrb, void *p_)
2929
if (p->closure) {
3030
ffi_closure_free(p->closure);
3131
}
32-
free(p->arg_types);
33-
free(p->arg_ffi_types);
34-
free(p->cif);
35-
free(p);
32+
mrb_free(mrb, p->arg_types);
33+
mrb_free(mrb, p->arg_ffi_types);
34+
mrb_free(mrb, p->cif);
35+
mrb_free(mrb, p);
3636
}
3737

3838
static void
@@ -57,7 +57,7 @@ cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
5757
struct cfunc_closure_data *data;
5858
data = mrb_get_datatype(mrb, self, &cfunc_closure_data_type);
5959
if (!data) {
60-
data = malloc(sizeof(struct cfunc_closure_data));
60+
data = mrb_malloc(mrb, sizeof(struct cfunc_closure_data));
6161
}
6262
data->refer = 0;
6363
data->autofree = 0;
@@ -75,8 +75,8 @@ cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
7575
ffi_type *return_ffi_type = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(rettype_mrb))->ffi_type_value;
7676
data->return_type = rettype_mrb;
7777

78-
data->arg_ffi_types = malloc(sizeof(ffi_type*) * data->argc);
79-
data->arg_types = malloc(sizeof(mrb_value) * data->argc);
78+
data->arg_ffi_types = mrb_malloc(mrb, sizeof(ffi_type*) * data->argc);
79+
data->arg_types = mrb_malloc(mrb, sizeof(mrb_value) * data->argc);
8080
int i;
8181
for (i = 0; i < data->argc; ++i) {
8282
data->arg_types[i] = mrb_ary_ref(mrb, args_mrb, i);
@@ -87,7 +87,7 @@ cfunc_closure_initialize(mrb_state *mrb, mrb_value self)
8787

8888
void *closure_pointer = NULL;
8989
data->closure = ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), &closure_pointer);
90-
data->cif = malloc(sizeof(ffi_cif));
90+
data->cif = mrb_malloc(mrb, sizeof(ffi_cif));
9191

9292
if (data->closure) {
9393
if (ffi_prep_cif(data->cif, FFI_DEFAULT_ABI, data->argc, return_ffi_type, data->arg_ffi_types) == FFI_OK) {
@@ -111,19 +111,19 @@ cfunc_closure_call_binding(ffi_cif *cif, void *ret, void **args, void *self_)
111111

112112
int ai = mrb_gc_arena_save(data->mrb);
113113

114-
mrb_value *ary = malloc(sizeof(mrb_value) * data->argc);
114+
mrb_value *ary = mrb_malloc(data->mrb, sizeof(mrb_value) * data->argc);
115115
int i;
116116
for (i = 0; i < data->argc; ++i) {
117117
// TODO: I felt too much consume memory
118-
void *p = malloc(data->arg_ffi_types[i]->size);
118+
void *p = mrb_malloc(data->mrb, data->arg_ffi_types[i]->size);
119119
memcpy(p, args[i], data->arg_ffi_types[i]->size);
120120
mrb_value pointer = cfunc_pointer_new_with_pointer(data->mrb, p, true);
121121
ary[i] = mrb_funcall(data->mrb, data->arg_types[i], "refer", 1, pointer);
122122
}
123123

124124
mrb_value block = mrb_iv_get(data->mrb, self, mrb_intern(data->mrb, "@block"));
125125
mrb_value result = mrb_funcall_argv(data->mrb, block, mrb_intern(data->mrb, "call"), data->argc, ary);
126-
free(ary);
126+
mrb_free(data->mrb, ary);
127127

128128
mrb_value ret_pointer = cfunc_pointer_new_with_pointer(data->mrb, ret, false);
129129
mrb_funcall(data->mrb, data->return_type, "set", 2, ret_pointer, result);

‎src/cfunc_pointer.c

+9-9
Original file line numberDiff line numberDiff line change
@@ -26,9 +26,9 @@ cfunc_pointer_destructor(mrb_state *mrb, void *p)
2626
{
2727
struct cfunc_type_data *data = (struct cfunc_type_data *)p;
2828
if(data->autofree) {
29-
free(get_cfunc_pointer_data(data));
29+
mrb_free(mrb, get_cfunc_pointer_data(data));
3030
}
31-
free(p);
31+
mrb_free(mrb, p);
3232
}
3333

3434

@@ -62,14 +62,14 @@ void set_cfunc_pointer_data(struct cfunc_type_data *data, void *p)
6262
mrb_value
6363
cfunc_pointer_class_malloc(mrb_state *mrb, mrb_value klass)
6464
{
65-
struct cfunc_type_data *data = malloc(sizeof(struct cfunc_type_data));
65+
struct cfunc_type_data *data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
6666
data->refer = false;
6767
data->autofree = false;
6868

6969
mrb_int alloc_size;
7070
mrb_get_args(mrb, "i", &alloc_size);
7171

72-
set_cfunc_pointer_data(data, malloc(alloc_size));
72+
set_cfunc_pointer_data(data, mrb_malloc(mrb, alloc_size));
7373

7474
return mrb_obj_value(Data_Wrap_Struct(mrb, mrb_class_ptr(klass), &cfunc_pointer_data_type, data));
7575
}
@@ -78,7 +78,7 @@ cfunc_pointer_class_malloc(mrb_state *mrb, mrb_value klass)
7878
mrb_value
7979
cfunc_pointer_new_with_pointer(mrb_state *mrb, void *p, bool autofree)
8080
{
81-
struct cfunc_type_data *data = malloc(sizeof(struct cfunc_type_data));
81+
struct cfunc_type_data *data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
8282
data->refer = false;
8383
data->autofree = autofree;
8484

@@ -93,7 +93,7 @@ mrb_value
9393
cfunc_pointer_refer(mrb_state *mrb, mrb_value klass)
9494
{
9595
struct RClass *c = mrb_class_ptr(klass);
96-
struct cfunc_type_data *data = malloc(sizeof(struct cfunc_type_data));
96+
struct cfunc_type_data *data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
9797
data->refer = true;
9898
data->autofree = false;
9999

@@ -114,7 +114,7 @@ cfunc_pointer_initialize(mrb_state *mrb, mrb_value self)
114114
struct cfunc_type_data *data;
115115
data = mrb_get_datatype(mrb, self, &cfunc_pointer_data_type);
116116
if (!data) {
117-
data = malloc(sizeof(struct cfunc_type_data));
117+
data = mrb_malloc(mrb, sizeof(struct cfunc_type_data));
118118
DATA_PTR(self) = data;
119119
DATA_TYPE(self) = &cfunc_pointer_data_type;
120120
}
@@ -141,7 +141,7 @@ cfunc_pointer_realloc(mrb_state *mrb, mrb_value self)
141141

142142
mrb_int alloc_size;
143143
mrb_get_args(mrb, "i", &alloc_size);
144-
set_cfunc_pointer_data(data, realloc(get_cfunc_pointer_data(data), alloc_size));
144+
set_cfunc_pointer_data(data, mrb_realloc(mrb, get_cfunc_pointer_data(data), alloc_size));
145145

146146
return self;
147147
}
@@ -152,7 +152,7 @@ cfunc_pointer_free(mrb_state *mrb, mrb_value self)
152152
{
153153
struct cfunc_type_data *data = DATA_PTR(self);
154154

155-
free(get_cfunc_pointer_data(data));
155+
mrb_free(mrb, get_cfunc_pointer_data(data));
156156
data->autofree = false;
157157
set_cfunc_pointer_data(data, NULL);
158158

‎src/cfunc_rubyvm.c

+22-22
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ struct queue_task {
6363

6464
struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
6565
{
66-
struct task_arg *arg = malloc(sizeof(struct task_arg));
66+
struct task_arg *arg = mrb_malloc(mrb, sizeof(struct task_arg));
6767

6868
arg->tt = mrb_type(v);
6969
switch (mrb_type(v)) {
@@ -80,7 +80,7 @@ struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
8080
case MRB_TT_SYMBOL:
8181
{
8282
const char* name = mrb_sym2name_len(mrb, v.value.sym, &arg->value.string.len);
83-
arg->value.string.ptr = malloc(arg->value.string.len+1);
83+
arg->value.string.ptr = mrb_malloc(mrb, arg->value.string.len+1);
8484
memcpy(arg->value.string.ptr, name, arg->value.string.len+1);
8585
}
8686
break;
@@ -89,7 +89,7 @@ struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
8989
{
9090
struct RString *str = mrb_str_ptr(v);
9191
arg->value.string.len = str->len;
92-
arg->value.string.ptr = malloc(arg->value.string.len+1);
92+
arg->value.string.ptr = mrb_malloc(mrb, arg->value.string.len+1);
9393
memcpy(arg->value.string.ptr, str->ptr, arg->value.string.len+1);
9494
}
9595
break;
@@ -99,7 +99,7 @@ struct task_arg* mrb_value_to_task_arg(mrb_state *mrb, mrb_value v)
9999
struct RArray *ary = mrb_ary_ptr(v);
100100

101101
arg->value.array.len = ary->len;
102-
arg->value.array.ptr = malloc(ary->len * sizeof(struct task_arg));
102+
arg->value.array.ptr = mrb_malloc(mrb, ary->len * sizeof(struct task_arg));
103103

104104
int i;
105105
for(i=0; i<ary->len; i++) {
@@ -162,24 +162,24 @@ mrb_value task_arg_to_mrb_value(mrb_state *mrb, struct task_arg* arg)
162162
}
163163

164164
void
165-
free_task_arg(struct task_arg* arg)
165+
free_task_arg(mrb_state *mrb, struct task_arg* arg)
166166
{
167167
if(!arg) {
168168
return;
169169
}
170170
switch (arg->tt) {
171171
case MRB_TT_SYMBOL:
172172
case MRB_TT_STRING:
173-
free(arg->value.string.ptr);
173+
mrb_free(mrb, arg->value.string.ptr);
174174
break;
175175

176176
case MRB_TT_ARRAY:
177177
{
178178
int i;
179179
for(i=0; i<arg->value.array.len; i++) {
180-
free_task_arg(arg->value.array.ptr[i]);
180+
free_task_arg(mrb, arg->value.array.ptr[i]);
181181
}
182-
free(arg->value.array.ptr);
182+
mrb_free(mrb, arg->value.array.ptr);
183183
}
184184
break;
185185

@@ -190,18 +190,18 @@ free_task_arg(struct task_arg* arg)
190190

191191

192192
void
193-
free_queue_task(struct queue_task* task)
193+
free_queue_task(mrb_state *mrb, struct queue_task* task)
194194
{
195195
task->refcount--;
196196
if(task->refcount < 1) {
197197
int i;
198198
for(i=0; i<task->args_len; ++i) {
199-
free_task_arg(task->args[i]);
199+
free_task_arg(mrb, task->args[i]);
200200
}
201-
free(task->args);
202-
free(task->result);
203-
free(task->name);
204-
free(task);
201+
mrb_free(mrb, task->args);
202+
mrb_free(mrb, task->result);
203+
mrb_free(mrb, task->name);
204+
mrb_free(mrb, task);
205205
}
206206
}
207207

@@ -224,7 +224,7 @@ const struct mrb_data_type cfunc_rubyvm_data_type = {
224224
static void
225225
cfunc_rubyvm_task_data_destructor(mrb_state *mrb, void *p)
226226
{
227-
free_queue_task((struct queue_task*)p);
227+
free_queue_task(mrb, (struct queue_task*)p);
228228
};
229229

230230

@@ -264,7 +264,7 @@ cfunc_rubyvm_open(void *args)
264264
mrb_sym taskname = mrb_intern(mrb, task->name);
265265

266266
int args_len = task->args_len;
267-
mrb_value *args = malloc(sizeof(struct task_arg) * task->args_len);
267+
mrb_value *args = mrb_malloc(mrb, sizeof(struct task_arg) * task->args_len);
268268
int i;
269269
for(i=0; i<task->args_len; ++i) {
270270
args[i] = task_arg_to_mrb_value(data->state, task->args[i]);
@@ -277,8 +277,8 @@ cfunc_rubyvm_open(void *args)
277277
task->status = queue_task_finished;
278278
pthread_cond_signal(&task->sync_cond);
279279

280-
free(args);
281-
free_queue_task(task);
280+
mrb_free(mrb, args);
281+
free_queue_task(mrb, task);
282282
}
283283

284284
return NULL;
@@ -294,7 +294,7 @@ cfunc_rubyvm_dispatch(mrb_state *mrb, mrb_value self)
294294
int args_len;
295295
mrb_get_args(mrb, "o*", &name_obj, &args, &args_len);
296296

297-
struct queue_task *task = malloc(sizeof(struct queue_task));
297+
struct queue_task *task = mrb_malloc(mrb, sizeof(struct queue_task));
298298
task->refcount = 2;
299299
task->result = NULL;
300300
task->status = queue_task_queued;
@@ -304,11 +304,11 @@ cfunc_rubyvm_dispatch(mrb_state *mrb, mrb_value self)
304304

305305
const char* name = mrb_string_value_ptr(mrb, name_obj);
306306
int name_len = strlen(name);
307-
task->name = malloc(name_len+1);
307+
task->name = mrb_malloc(mrb, name_len+1);
308308
strncpy(task->name, name, name_len+1);
309309

310310
task->args_len = args_len;
311-
task->args = malloc(sizeof(struct task_arg) * task->args_len);
311+
task->args = mrb_malloc(mrb, sizeof(struct task_arg) * task->args_len);
312312
int i;
313313
for(i=0; i<args_len; ++i) {
314314
task->args[i] = mrb_value_to_task_arg(mrb, args[i]);
@@ -359,7 +359,7 @@ cfunc_rubyvm_class_thread(mrb_state *mrb, mrb_value klass)
359359
{
360360
// init bindle data with RubyVM object
361361
struct RClass *c = mrb_class_ptr(klass);
362-
struct cfunc_rubyvm_data *data = malloc(sizeof(struct cfunc_rubyvm_data));
362+
struct cfunc_rubyvm_data *data = mrb_malloc(mrb, sizeof(struct cfunc_rubyvm_data));
363363
mrb_value self = mrb_obj_value((struct RObject *)Data_Wrap_Struct(mrb, c, &cfunc_rubyvm_data_type, data));
364364

365365
// load script

‎src/cfunc_struct.c

+3-3
Original file line numberDiff line numberDiff line change
@@ -53,19 +53,19 @@ cfunc_struct_define_struct(mrb_state *mrb, mrb_value klass)
5353
mrb_get_args(mrb, "A", &elements_mrb);
5454
struct RArray *elements = mrb_ary_ptr(elements_mrb);
5555

56-
ffi_type *tm_type = malloc(sizeof(ffi_type));
56+
ffi_type *tm_type = mrb_malloc(mrb, sizeof(ffi_type));
5757
tm_type->type = FFI_TYPE_STRUCT;
5858
tm_type->size = tm_type->alignment = 0;
5959

60-
ffi_type **tm_type_elements = malloc(sizeof(ffi_type*) * (elements->len + 1));
60+
ffi_type **tm_type_elements = mrb_malloc(mrb, sizeof(ffi_type*) * (elements->len + 1));
6161
int i;
6262
for(i = 0; i < elements->len; ++i) {
6363
tm_type_elements[i] = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(elements->ptr[i]))->ffi_type_value;
6464
}
6565
tm_type_elements[i] = NULL;
6666
tm_type->elements = tm_type_elements;
6767

68-
struct mrb_ffi_type *mft = malloc(sizeof(struct mrb_ffi_type));
68+
struct mrb_ffi_type *mft = mrb_malloc(mrb, sizeof(struct mrb_ffi_type));
6969
mft->name = mrb_class_name(mrb, mrb_class_ptr(klass));
7070
mft->ffi_type_value = tm_type;
7171
mft->mrb_to_c = &cfunc_type_ffi_struct_mrb_to_c;

0 commit comments

Comments
 (0)