:art: Improve mp_alloc

diff --git a/include/import.h b/include/import.h
index 56a363301df5f67f91a83adf34fdcdf3e538cd07..efed97519dc15c7a4d05466ea862ac8a2baea457 100644 (file)
--- a/include/import.h
+++ b/include/import.h
@@ -19,7 +19,7 @@ typedef struct Gwi_* Gwi;
 #else
 #define GWION_IMPORT(a) ANN m_bool import(const Gwi gwi)
 #endif
-#define ALLOC_PTR(p, a, b, c) b* a = (b*)_mp_alloc(p, sizeof(b)); *a = (b)c
+#define ALLOC_PTR(p, a, b, c) b* a = (b*)_mp_calloc(p, sizeof(b)); *a = (b)c
 #define _CHECK_OP(op, check, func)\
     CHECK_BB(gwi_oper_add(gwi, opck_##check))\
     CHECK_BB(gwi_oper_end(gwi, op_##op, func))

diff --git a/include/nspc.h b/include/nspc.h
index f0cd52fa6dbccbac2ba36c1dc8169e8c886a9326..2814097d12227efc39ade16f0b529e92ba6fb360 100644 (file)
--- a/include/nspc.h
+++ b/include/nspc.h
@@ -58,8 +58,9 @@ describe_nspc_func(Func, func)
 ANN void did_you_mean_nspc(const Nspc, const char*);
 ANN void did_you_mean_type(const Type, const char*);
 
-ANN static inline void nspc_allocdata(const Nspc nspc) {
+ANN static inline void nspc_allocdata(MemPool mp, const Nspc nspc) {
   if(nspc->info->class_data_size)
-    nspc->info->class_data = (m_bit*)xcalloc(1, nspc->info->class_data_size);
+//    nspc->info->class_data = (m_bit*)xcalloc(1, nspc->info->class_data_size);
+    nspc->info->class_data = (m_bit*)mp_calloc2(mp, nspc->info->class_data_size);
 }
 #endif

diff --git a/include/oo.h b/include/oo.h
index 6ca6a63b0ab1f813368c5bf598dbfcf6c166f88f..9b44c4145661ea9107f5bbe48be0113830a5eb77 100644 (file)
--- a/include/oo.h
+++ b/include/oo.h
@@ -13,7 +13,7 @@ typedef struct RefCount_ {
 
 #define HAS_OBJ RefCount* ref;
 ANN static inline RefCount* new_refcount(MemPool mp, void(*free)(void*,void*)) {
-  RefCount *ref = mp_alloc(mp, RefCount);
+  RefCount *ref = mp_calloc(mp, RefCount);
   ref->count = 1;
   ref->free= free;
   return ref;

diff --git a/src/emit/emit.c b/src/emit/emit.c
index d24779cabf1fbb38642f4358c45bd5601c4f0d7e..7926d6feea3a63a235d76afcb0821b878aab9940 100644 (file)
--- a/src/emit/emit.c
+++ b/src/emit/emit.c
@@ -51,7 +51,7 @@ static inline m_uint emit_push_global(const Emitter emit) {
 }
 
 ANEW static Frame* new_frame(MemPool p) {
-  Frame* frame = mp_alloc(p, Frame);
+  Frame* frame = mp_calloc(p, Frame);
   vector_init(&frame->stack);
   vector_add(&frame->stack, (vtype)NULL);
   return frame;
@@ -67,7 +67,7 @@ ANN static void free_frame(MemPool p, Frame* a) {
 }
 
 ANN static Local* new_local(MemPool p, const m_uint size, const m_bool is_obj) {
-  Local* local  = mp_alloc(p, Local);
+  Local* local  = mp_calloc(p, Local);
   local->size   = size;
   local->is_obj = is_obj;
   return local;
@@ -99,7 +99,7 @@ ANN static m_bool emit_exp_dot(const Emitter emit, const Exp_Dot* member);
 ANN static m_bool emit_func_def(const Emitter emit, const Func_Def func_def);
 
 ANEW static Code* new_code(const Emitter emit, const m_str name) {
-  Code* code = mp_alloc(emit->gwion->mp, Code);
+  Code* code = mp_calloc(emit->gwion->mp, Code);
   code->name = code_name_set(name, emit->env->name);
   vector_init(&code->instr);
   vector_init(&code->stack_break);
@@ -191,7 +191,7 @@ ANN static void emit_pre_constructor_array(const Emitter emit, const Type type)
 ANN ArrayInfo* emit_array_extend_inner(const Emitter emit, const Type t, const Exp e) {
   CHECK_BO(emit_exp(emit, e, 0))
   const Type base = array_base(t);
-  ArrayInfo* info = mp_alloc(emit->gwion->mp, ArrayInfo);
+  ArrayInfo* info = mp_calloc(emit->gwion->mp, ArrayInfo);
   vector_init(&info->type);
   for(m_uint i = 1; i < t->array_depth; ++i)
     vector_add(&info->type, (vtype)array_type(emit->env, base, i));
@@ -589,7 +589,7 @@ ANN static m_bool emit_exp_decl_global(const Emitter emit, const Var_Decl var_de
   if(is_obj && (is_array || !is_ref))
     CHECK_BB(emit_instantiate_object(emit, type, array, is_ref))
   const Instr instr = emit_kind(emit, v->type->size, emit_addr, dotstatic);
-  v->d.ptr = mp_alloc2(emit->gwion->mp, v->type->size);
+  v->d.ptr = mp_calloc2(emit->gwion->mp, v->type->size);
   SET_FLAG(v, union);
   instr->m_val = (m_uint)v->d.ptr;
   instr->m_val2 = v->type->size;
@@ -766,7 +766,7 @@ static inline m_bool push_func_code(const Emitter emit, const Func f) {
     char c[sz + 1];
     memcpy(c, f->name, sz);
     c[sz] = '\0';
-    struct dottmpl_ *dt = mp_alloc(emit->gwion->mp, dottmpl);
+    struct dottmpl_ *dt = mp_calloc(emit->gwion->mp, dottmpl);
     dt->name = s_name(insert_symbol(c));
     dt->overload = f->def->tmpl->base;
     dt->tl = tmpl_tl(emit->env, c);
@@ -1367,9 +1367,9 @@ ANN void emit_union_offset(Decl_List l, const m_uint o) {
   } while((l = l->next));
 }
 
-ANN static inline void union_allocdata(const Stmt_Union stmt) {
+ANN static inline void union_allocdata(MemPool mp, const Stmt_Union stmt) {
   const Nspc nspc = (stmt->xid ? stmt->value->type : stmt->type)->nspc;
-  nspc_allocdata(nspc);
+  nspc_allocdata(mp, nspc);
   nspc->info->offset = stmt->s;
 }
 
@@ -1378,7 +1378,7 @@ ANN static m_bool emit_stmt_union(const Emitter emit, const Stmt_Union stmt) {
   m_uint scope = emit->env->scope->depth;
   const m_bool global = GET_FLAG(stmt, global);
   if(stmt->xid) {
-    union_allocdata(stmt);
+    union_allocdata(emit->gwion->mp, stmt);
     Type_Decl *type_decl = new_type_decl(emit->gwion->mp,
         new_id_list(emit->gwion->mp, stmt->xid, loc_cpy(emit->gwion->mp, stmt_self(stmt)->pos)),
         stmt->flag);
@@ -1397,7 +1397,7 @@ ANN static m_bool emit_stmt_union(const Emitter emit, const Stmt_Union stmt) {
     }
     scope = emit_push_type(emit, stmt->value->type);
   } else if(stmt->type_xid) {
-    union_allocdata(stmt);
+    union_allocdata(emit->gwion->mp, stmt);
     scope = emit_push_type(emit, stmt->type);
   } else if(emit->env->class_def) {
     if(!GET_FLAG(l->self->d.exp_decl.list->self->value, member))
@@ -1726,7 +1726,7 @@ ANN static m_bool emit_class_def(const Emitter emit, const Class_Def cdef) {
     if(!base->nspc->pre_ctor)
       CHECK_BB(emit_class_def(emit, base->e->def))
   }
-  nspc_allocdata(nspc);
+  nspc_allocdata(emit->gwion->mp, nspc);
   emit_class_code(emit, type->name);
   if(cdef->base.ext && cdef->base.ext->array)
     CHECK_BB(emit_array_extend(emit, type->e->parent, cdef->base.ext->array->exp))

diff --git a/src/emit/emitter.c b/src/emit/emitter.c
index dda013c1f9fd8408c1d521fff0a6f18ea1224b49..97b6103475207831fc1c9c6cc7f9085b0332d6fd 100644 (file)
--- a/src/emit/emitter.c
+++ b/src/emit/emitter.c
@@ -28,7 +28,7 @@ ANN void free_emitter(Emitter a) {
 
 __attribute__((returns_nonnull))
 ANN2(1) Instr emit_add_instr(const Emitter emit, const f_instr f) {
-  const Instr instr = mp_alloc(emit->gwion->mp, Instr);
+  const Instr instr = mp_calloc(emit->gwion->mp, Instr);
   if((m_uint)f < 255)
     instr->opcode = (m_uint)f;
   else {

diff --git a/src/emit/escape.c b/src/emit/escape.c
index c171c14a3579d30a98fe07966dafae64bbc0e3ae..697e5361eb492fd9f6748b435fb3fcda8d114d52 100644 (file)
--- a/src/emit/escape.c
+++ b/src/emit/escape.c
@@ -8,7 +8,7 @@
 #include "escape.h"
 
 char* escape_table(void) {
-  char *escape = (char*)xcalloc(256, sizeof(char));
+  char *escape = (char*)calloc(256, sizeof(char));
   escape['0'] = '0';
   escape['\''] = '\'';
   escape['"'] = '"';

diff --git a/src/emit/memoize.c b/src/emit/memoize.c
index 28fbdc1f331da5e38c6dab1a2f83df35eaf96ea0..c9fe04d978af56dcdcf6c9b98a0aac0974d2ace8 100644 (file)
--- a/src/emit/memoize.c
+++ b/src/emit/memoize.c
@@ -45,7 +45,7 @@ static void(*mreturn[])(m_bit*, const m_bit*, const m_uint) =
   { memoize_return1, memoize_return2, memoize_return3, memoize_return4};
 
 Memoize memoize_ini(const Emitter emit, const Func f, const enum Kind kind) {
-  Memoize m = mp_alloc(emit->gwion->mp, Memoize);
+  Memoize m = mp_calloc(emit->gwion->mp, Memoize);
   vector_init(&m->v);
   m->ret_sz = f->def->base->ret_type->size;
   m->kind = kind;
@@ -68,7 +68,7 @@ void memoize_end(MemPool p, Memoize m) {
 }
 
 static inline void memoize_set(Memoize m, const m_bit* arg) {
-  m_bit* data = _mp_alloc2(m->p);
+  m_bit* data = _mp_calloc2(m->p, 0);
   memcpy(data, arg, m->arg_sz);
   if(vector_size(&m->v) < m->limit)
     vector_add(&m->v, (vtype)data);
@@ -111,4 +111,4 @@ INSTR(MemoizeStore) {
     mreturn[m->kind](data + m->arg_sz, shred->reg-m->ret_sz, m->ret_sz);
     return;
   }
-}
\ No newline at end of file
+}

diff --git a/src/gwion.c b/src/gwion.c
index 00fdd99e353b9d006bcc7646d8f95dc6519c538d..9b0c185c74b9bafde10daa6ea231531aae4d5cfd 100644 (file)
--- a/src/gwion.c
+++ b/src/gwion.c
@@ -45,7 +45,7 @@ ANN static inline void gwion_compile(const Gwion gwion, const Vector v) {
 
 #include "shreduler_private.h"
 ANN VM* gwion_cpy(const VM* src) {
-  const Gwion gwion = mp_alloc(src->gwion->mp, Gwion);
+  const Gwion gwion = mp_calloc(src->gwion->mp, Gwion);
   gwion->vm = new_vm(src->gwion->mp, 0);
   gwion->vm->gwion = gwion;
   gwion->vm->bbq->si = soundinfo_cpy(src->gwion->mp, src->bbq->si);

diff --git a/src/gwiondata.c b/src/gwiondata.c
index 653c8d9c8b71c1d938241042d114464306549fb9..8d31b0536745a45806dd4a991c919d2a7fa81ab9 100644 (file)
--- a/src/gwiondata.c
+++ b/src/gwiondata.c
@@ -2,7 +2,7 @@
 #include "gwiondata.h"
 
 ANN GwionData* new_gwiondata(MemPool mp) {
-  struct GwionData_ *data = mp_alloc(mp, GwionData);
+  struct GwionData_ *data = mp_calloc(mp, GwionData);
   map_init(&data->freearg);
   vector_init(&data->reserved);
   MUTEX_SETUP(data->mutex);

diff --git a/src/lib/array.c b/src/lib/array.c
index bc7b2e7df4fecf3c24ac25c1b1376f9a8e2c0aa8..2b421af3948ded7fee6b92db1010d3710f74e8e1 100644 (file)
--- a/src/lib/array.c
+++ b/src/lib/array.c
@@ -29,7 +29,7 @@ ANN m_uint m_vector_size(const M_Vector v) {
 }
 
 M_Vector new_m_vector(MemPool p, const m_uint size) {
-  const M_Vector array = mp_alloc(p, M_Vector);
+  const M_Vector array = mp_calloc(p, M_Vector);
   const size_t sz = (ARRAY_OFFSET*SZ_INT) + (2*size);
   array->ptr   = (m_bit*)xcalloc(1, sz);
   ARRAY_CAP(array)   = 2;
@@ -38,7 +38,7 @@ M_Vector new_m_vector(MemPool p, const m_uint size) {
 }
 
 M_Vector new_m_vector2(MemPool p, const m_uint size, const m_uint len) {
-  const M_Vector array = mp_alloc(p, M_Vector);
+  const M_Vector array = mp_calloc(p, M_Vector);
   const size_t sz = (ARRAY_OFFSET*SZ_INT) + (len*size);
   array->ptr   = (m_bit*)xcalloc(1, sz);
   m_uint cap = 1;

diff --git a/src/lib/import.c b/src/lib/import.c
index ce6068c7ac6d49d6e6ffbabf65da3cbae0f13d18..7b2dc7eeb837bf5e453e520f6d0c11a32a0c159b 100644 (file)
--- a/src/lib/import.c
+++ b/src/lib/import.c
@@ -267,7 +267,7 @@ ANN m_int gwi_class_ext(const Gwi gwi, Type_Decl* td) {
 ANN m_int gwi_class_end(const Gwi gwi) {
   if(!gwi->gwion->env->class_def)
     GWI_ERR_B("import: too many class_end called.")
-  nspc_allocdata(gwi->gwion->env->class_def->nspc);
+  nspc_allocdata(gwi->gwion->mp, gwi->gwion->env->class_def->nspc);
   env_pop(gwi->gwion->env, 0);
   return GW_OK;
 }

diff --git a/src/lib/object.c b/src/lib/object.c
index d82a68c02a2e3bc980c2257d680a7a1973e82255..3a04f52b52cbfb3eeb5f176a06cb69c0801c3d91 100644 (file)
--- a/src/lib/object.c
+++ b/src/lib/object.c
@@ -21,12 +21,12 @@ ANN void exception(const VM_Shred shred, const m_str c) {
 }
 
 M_Object new_object(MemPool p, const VM_Shred shred, const Type t) {
-  const M_Object a = mp_alloc(p, M_Object);
+  const M_Object a = mp_calloc(p, M_Object);
   a->ref = 1;
   a->type_ref = t;
   a->vtable = &t->nspc->info->vtable;
   if(t->nspc->info->offset)
-    a->data = (m_bit*)_mp_alloc(p, t->nspc->info->offset);
+    a->data = (m_bit*)_mp_calloc(p, t->nspc->info->offset);
   if(shred)
     vector_add(&shred->gc, (vtype)a);
   return a;

diff --git a/src/lib/ugen.c b/src/lib/ugen.c
index fe9bf20f6589ff03ebb814f4f0f273d3a2aa9949..a9e33fe76074a330d846f8e014060278c29afd06 100644 (file)
--- a/src/lib/ugen.c
+++ b/src/lib/ugen.c
@@ -76,7 +76,7 @@ describe_compute(mono,  trig, {u->module.gen.trig->compute(u->module.gen.trig);}
 describe_compute(multi, trig, {u->module.gen.trig->compute(u->module.gen.trig);})
 
 ANEW static UGen new_UGen(MemPool p) {
-  const UGen u = mp_alloc(p, UGen);
+  const UGen u = mp_calloc(p, UGen);
   u->op = ugop_add;
   u->compute = gen_compute_mono;
   return u;
@@ -116,11 +116,11 @@ ANN void ugen_gen(MemPool p, const UGen u, const f_tick tick, void* data, const
 ANN void ugen_ini(MemPool p, const UGen u, const uint in, const uint out) {
   const uint chan = in > out ? in : out;
   if(chan == 1) {
-    u->connect.net = mp_alloc(p, ugen_net);
+    u->connect.net = mp_calloc(p, ugen_net);
     vector_init(&u->connect.net->from);
     vector_init(&u->connect.net->to);
   } else {
-    u->connect.multi = mp_alloc(p, ugen_multi);
+    u->connect.multi = mp_calloc(p, ugen_multi);
     u->connect.multi->n_in   = in;
     u->connect.multi->n_out  = out;
     u->connect.multi->n_chan = chan;

diff --git a/src/lib/vararg.c b/src/lib/vararg.c
index 42444dd93d358c88e976ddf93990bdc75c81e304..34f4c2cb0ac5e9a33f01c51803751f7adfbe94f7 100644 (file)
--- a/src/lib/vararg.c
+++ b/src/lib/vararg.c
@@ -32,7 +32,7 @@ INSTR(VarargTop) {
 }
 
 INSTR(VarargIni) {
-  struct Vararg_* arg = mp_alloc(shred->info->mp, Vararg);
+  struct Vararg_* arg = mp_calloc(shred->info->mp, Vararg);
   POP_REG(shred,  instr->m_val - SZ_INT)
   arg->d = (m_bit*)xmalloc(instr->m_val);
   for(m_uint i = 0; i < instr->m_val; i += SZ_INT)

diff --git a/src/oo/context.c b/src/oo/context.c
index b940aa9089ff643ecf3a31509f684d174d24ebf1..a923085018d83e4e4c97082cbec3686c5e2749ef 100644 (file)
--- a/src/oo/context.c
+++ b/src/oo/context.c
@@ -14,7 +14,7 @@ ANN static void free_context(const Context a, Gwion gwion) {
 }
 
 ANN2(2) Context new_context(MemPool p, const Ast ast, const m_str str) {
-  const Context context = mp_alloc(p, Context);
+  const Context context = mp_calloc(p, Context);
   context->nspc = new_nspc(p, str);
   context->tree = ast;
   context->name = str;

diff --git a/src/oo/env.c b/src/oo/env.c
index ea3166a3976d9f3a6b2fdd8f031f9a93c535b65f..f7e305f78a09e348add29a6675e6688234a1be8c 100644 (file)
--- a/src/oo/env.c
+++ b/src/oo/env.c
@@ -17,13 +17,13 @@
 #include "parse.h"
 
 ANN static struct Env_Scope_ *new_envscope(MemPool p) {
-  struct Env_Scope_ *a = mp_alloc(p, Env_Scope);
+  struct Env_Scope_ *a = mp_calloc(p, Env_Scope);
   vector_init(&a->breaks);
   vector_init(&a->conts);
   vector_init(&a->class_stack);
   vector_init(&a->nspc_stack);
   vector_init(&a->known_ctx);
-  a->swi = mp_alloc(p, Scope);
+  a->swi = mp_calloc(p, Scope);
   _scope_init(a->swi);
   map_init(&a->swi->map);
   return a;

diff --git a/src/oo/nspc.c b/src/oo/nspc.c
index 9d8477a8902c4079cfd937b727ef8d244458988a..993b6a3e40fb8b90c0a8128ceeee1901e393684f 100644 (file)
--- a/src/oo/nspc.c
+++ b/src/oo/nspc.c
@@ -58,7 +58,7 @@ ANN static void free_nspc(Nspc a, Gwion gwion) {
   free_nspc_value(a, gwion);
 
   if(a->info->class_data)
-    free(a->info->class_data);
+    mp_free2(gwion->mp, a->info->class_data_size, a->info->class_data);
   if(a->info->vtable.ptr)
     vector_release(&a->info->vtable);
   if(a->info->op_map.ptr)
@@ -72,9 +72,9 @@ ANN static void free_nspc(Nspc a, Gwion gwion) {
 }
 
 ANN Nspc new_nspc(MemPool p, const m_str name) {
-  const Nspc a = mp_alloc(p, Nspc);
+  const Nspc a = mp_calloc(p, Nspc);
   a->name = name;
-  a->info = mp_alloc(p, NspcInfo);
+  a->info = mp_calloc(p, NspcInfo);
   a->info->value = new_scope(p);
   a->info->type = new_scope(p);
   a->info->func = new_scope(p);

diff --git a/src/oo/switch.c b/src/oo/switch.c
index c32c511e96869a46198f1787d17e5119c5ad33d9..11a5485c9032f3c176acdbf0961854ed3f2cdb65 100644 (file)
--- a/src/oo/switch.c
+++ b/src/oo/switch.c
@@ -20,7 +20,7 @@ static inline vtype _scope_back(Scope s) { return vector_back((Vector)(void*)s);
 static inline void _scope_clear(Scope s) { vector_clear((Vector)(void*)s); }
 
 static Switch new_switch(MemPool p) {
-  Switch sw = mp_alloc(p, Switch);
+  Switch sw = mp_calloc(p, Switch);
   sw->cases = new_map(p); // could be struct ?
   vector_init(&sw->exp);
   sw->vec = new_vector(p);
@@ -42,7 +42,7 @@ struct SwInfo_ {
 };
 
 ANN static Switch new_swinfo(const Env env, const Stmt_Switch stmt) {
-  struct SwInfo_ *info = mp_alloc(env->gwion->mp, SwInfo);
+  struct SwInfo_ *info = mp_calloc(env->gwion->mp, SwInfo);
   info->s = stmt;
   info->t = env->class_def;
   info->f = env->func;

diff --git a/src/oo/type.c b/src/oo/type.c
index 3c0071a1445aa2cae322e6481d1ca87cd5fa58f8..2c6b0b2815dcc540f070cfe38817a0a141d4f0d9 100644 (file)
--- a/src/oo/type.c
+++ b/src/oo/type.c
@@ -18,10 +18,10 @@ ANN static void free_type(Type a, Gwion gwion) {
 }
 
 Type new_type(MemPool p, const m_uint xid, const m_str name, const Type parent) {
-  const Type type = mp_alloc(p, Type);
+  const Type type = mp_calloc(p, Type);
   type->xid    = xid;
   type->name   = name;
-  type->e = mp_alloc(p, TypeInfo);
+  type->e = mp_calloc(p, TypeInfo);
   type->e->parent = parent;
   if(type->e->parent)
     type->size = parent->size;

diff --git a/src/oo/value.c b/src/oo/value.c
index 07a0f9496744ae74368f4d2fb2a390775d7037d4..3ef89738e6d1216b1a72deadb0134b5e6bdfd3d8 100644 (file)
--- a/src/oo/value.c
+++ b/src/oo/value.c
@@ -19,7 +19,7 @@ ANN static void free_value(Value a, Gwion gwion) {
 }
 
 ANN Value new_value(MemPool p, const Type type, const m_str name) {
-  const Value a = mp_alloc(p, Value);
+  const Value a = mp_calloc(p, Value);
   a->type       = type;
   a->name       = name;
   a->ref = new_refcount(p, free_value);

diff --git a/src/parse/func.c b/src/parse/func.c
index 0ee82dd0c615f80a7185437cdff94a70d636099e..62597aaaf2aee350095834fddebca4f60011dc07 100644 (file)
--- a/src/parse/func.c
+++ b/src/parse/func.c
@@ -22,7 +22,7 @@ ANN static void free_func(Func a, Gwion gwion) {
 }
 
 ANN Func new_func(MemPool p, const m_str name, const Func_Def def) {
-  Func func = mp_alloc(p, Func);
+  Func func = mp_calloc(p, Func);
   func->name = name;
   func->def = def;
   func->ref = new_refcount(p, free_func);

diff --git a/src/parse/operator.c b/src/parse/operator.c
index bb5f9b3e436a3299265c68b61e95cdb3e649cf42..a29062bbc5001ec6b9686572d8cc04f1b3a34da3 100644 (file)
--- a/src/parse/operator.c
+++ b/src/parse/operator.c
@@ -98,7 +98,7 @@ ANN m_bool add_op(const Gwion gwion, const Nspc nspc, const struct Op_Import* op
     map_set(&nspc->info->op_map, (vtype)opi->op, (vtype)v);
   }
 // new mo
-  mo = mp_alloc(gwion->mp, M_Operator);
+  mo = mp_calloc(gwion->mp, M_Operator);
   mo->lhs       = opi->lhs;
   mo->rhs       = opi->rhs;
   mo->ret       = opi->ret;

diff --git a/src/plug.c b/src/plug.c
index d3158fc4e219c66e1f09f7e84832ce69d323fcd5..3f76968f4b98d4f52629b296bf79dd764ff157ff 100644 (file)
--- a/src/plug.c
+++ b/src/plug.c
@@ -53,7 +53,7 @@ ANN static void plug_get(MemPool p, PlugInfo* pi, const m_str c) {
       vector_add(&pi->vec[GWPLUG_IMPORT], (vtype)imp);
     const modini ini = DLSYM(dl, modini, GWMODINI_NAME);
     if(ini) {
-      struct Plug_ *plug = mp_alloc(p, Plug);
+      struct Plug_ *plug = mp_calloc(p, Plug);
       plug->ini  = ini;
       const modstr str = DLSYM(dl, modstr, GWMODSTR_NAME);
       plug->name = str();
@@ -70,7 +70,7 @@ ANN static void plug_get(MemPool p, PlugInfo* pi, const m_str c) {
 }
 
 ANN PlugInfo* new_plug(MemPool p, const Vector list) {
-  PlugInfo *pi = (PlugInfo*)mp_alloc(p, PlugInfo);
+  PlugInfo *pi = (PlugInfo*)mp_calloc(p, PlugInfo);
   for(m_uint i = 0; i < GWPLUG_LAST; ++i)
     vector_init(&pi->vec[i]);
   map_init(&pi->drv);

diff --git a/src/soundinfo.c b/src/soundinfo.c
index 0873d842ae18be7eb6dd81c5bb6b78e45486387a..7f232a110880c5f8fd12ce3c1f52c23ac7fdefee 100644 (file)
--- a/src/soundinfo.c
+++ b/src/soundinfo.c
@@ -2,14 +2,14 @@
 #include <soundinfo.h>
 
 struct SoundInfo_ *new_soundinfo(MemPool p) {
-  struct SoundInfo_ *si = mp_alloc(p, SoundInfo);
+  struct SoundInfo_ *si = mp_calloc(p, SoundInfo);
   si->in = si->out = 2;
   si->sr = 48000;
   return si;
 }
 
 struct SoundInfo_ *soundinfo_cpy(MemPool p, const struct SoundInfo_ *src) {
-  struct SoundInfo_ *si = mp_alloc(p, SoundInfo);
+  struct SoundInfo_ *si = mp_calloc(p, SoundInfo);
   si->in  = src->in;
   si->out = src->out;
   si->sr  = src->sr;

diff --git a/src/vm/driver.c b/src/vm/driver.c
index e1a5f4b3b02a372251b40e531d6507f792cd42a9..da06f6f9a69dbb94b9f8d4f42ac38a3f1ce4044a 100644 (file)
--- a/src/vm/driver.c
+++ b/src/vm/driver.c
@@ -12,9 +12,9 @@
 #include "driver.h"
 
 ANN Driver* new_driver(MemPool p) {
-  Driver* di = (Driver*)mp_alloc(p, BBQ);
+  Driver* di = (Driver*)mp_calloc(p, BBQ);
   di->func = dummy_driver;
-  di->driver = (DriverData*)mp_alloc(p, DriverData);
+  di->driver = (DriverData*)mp_calloc(p, DriverData);
   di->is_running = 1;
   return di;
 }

diff --git a/src/vm/shreduler.c b/src/vm/shreduler.c
index a3b0c5b798489bfcdc0adcdf6fa358e61cd1d5e5..6d1e437105286f7a97f1af33a61b8917ea31bcb8 100644 (file)
--- a/src/vm/shreduler.c
+++ b/src/vm/shreduler.c
@@ -100,7 +100,7 @@ ANN void shredule(const Shreduler s, const VM_Shred shred, const m_float wake_ti
 }
 
 ANN void shreduler_add(const Shreduler s, const VM_Shred shred) {
-  shred->tick = mp_alloc(shred->info->mp, ShredTick);
+  shred->tick = mp_calloc(shred->info->mp, ShredTick);
   shred->tick->self = shred;
   shred->tick->shreduler = s;
   shred->tick->xid = ++s->shred_ids;

diff --git a/src/vm/vm.c b/src/vm/vm.c
index 88475d853d956c23d9095b696838cc54885a1155..5123753979844ec324bd6d0651a66255fddaa58e 100644 (file)
--- a/src/vm/vm.c
+++ b/src/vm/vm.c
@@ -810,11 +810,11 @@ static void vm_run_audio(const VM *vm) {
 }
 
 VM* new_vm(MemPool p, const m_bool audio) {
-  VM* vm = (VM*)mp_alloc(p, VM);
+  VM* vm = (VM*)mp_calloc(p, VM);
   vector_init(&vm->ugen);
   vm->bbq = new_driver(p);
   vm->bbq->run = audio ? vm_run_audio : vm_run;
-  vm->shreduler  = (Shreduler)mp_alloc(p, Shreduler);
+  vm->shreduler  = (Shreduler)mp_calloc(p, Shreduler);
   vector_init(&vm->shreduler->shreds);
   MUTEX_SETUP(vm->shreduler->mutex);
   vm->shreduler->bbq = vm->bbq;

diff --git a/src/vm/vm_code.c b/src/vm/vm_code.c
index 092caadbd910ffdca28ec158efaf24099e33233e..76078fdca562d7f0c5e07ebb5b4e10a8ca498b8a 100644 (file)
--- a/src/vm/vm_code.c
+++ b/src/vm/vm_code.c
@@ -41,7 +41,7 @@ ANN static void free_vm_code(VM_Code a, Gwion gwion) {
 
 VM_Code new_vm_code(MemPool p, const Vector instr, const m_uint stack_depth,
     const ae_flag flag, const m_str name) {
-  VM_Code code           = mp_alloc(p, VM_Code);
+  VM_Code code           = mp_calloc(p, VM_Code);
   code->instr            = instr ?  vector_copy(p, instr) : NULL;
   code->name             = strdup(name);
   code->stack_depth      = stack_depth;

diff --git a/src/vm/vm_shred.c b/src/vm/vm_shred.c
index e4edcebd48dfb3e10aedb64910fb731f813ad286..02e4fc760387fcc9fa4207e1d28faf5b2a124fbf 100644 (file)
--- a/src/vm/vm_shred.c
+++ b/src/vm/vm_shred.c
@@ -15,7 +15,7 @@ struct Stack_ {
 };
 
 static inline struct ShredInfo_ *new_shredinfo(MemPool p, const m_str name) {
-  struct ShredInfo_ *info = mp_alloc(p, ShredInfo);
+  struct ShredInfo_ *info = mp_calloc(p, ShredInfo);
   info->mp = p;
   info->name = strdup(name);
   return info;
@@ -34,7 +34,7 @@ static inline void free_shredinfo(MemPool mp, struct ShredInfo_ *info) {
 }
 
 VM_Shred new_vm_shred(MemPool p, VM_Code c) {
-  const VM_Shred shred = mp_alloc(p, Stack);
+  const VM_Shred shred = mp_calloc(p, Stack);
   shred->code          = c;
   shred->reg           = (m_bit*)shred + sizeof(struct VM_Shred_);
   shred->base = shred->mem = shred->reg + SIZEOF_REG;

diff --git a/tests/import/callback.c b/tests/import/callback.c
index 4b35ea5fb8ba7d9ba4258700a16d7b170b0dec6c..1dfd3cdba45312f9a6d310cdd219ce7e329153a2 100644 (file)
--- a/tests/import/callback.c
+++ b/tests/import/callback.c
@@ -43,7 +43,7 @@ static SFUN(cb_func) {
   }
   m_uint offset = shred->mem - ((m_bit*)shred + sizeof(struct VM_Shred_) + SIZEOF_REG);
   PUSH_MEM(shred, offset);
-  Instr instr = mp_alloc(shred->info->mp, Instr);
+  Instr instr = mp_calloc(shred->info->mp, Instr);
   struct ret_info* info = (struct ret_info*)xmalloc(sizeof(struct ret_info));
   info->offset = offset;
   info->code = shred->code;

diff --git a/util b/util
index bbaef376bdbc13bba73d5f24e58701bcaf885f72..059393b7d69ed555bfef29ba99500d508a378637 160000 (submodule)
--- a/util
+++ b/util
@@ -1 +1 @@
-Subproject commit bbaef376bdbc13bba73d5f24e58701bcaf885f72
+Subproject commit 059393b7d69ed555bfef29ba99500d508a378637