:art: Improve Nspc

diff --git a/include/env/nspc.h b/include/env/nspc.h
index 1980cd09a0b23592debd6ddc2f95195af2422ee9..dc590f697a647d3658de278820be6e8cbfe71bcf 100644 (file)
--- a/include/env/nspc.h
+++ b/include/env/nspc.h
@@ -1,25 +1,25 @@
 #ifndef __NSPC
 #define __NSPC
 struct NspcInfo_ {
-  m_bit *        class_data;
   struct Map_    op_map;
   Scope          value;
   Scope          type;
   Scope          func;
   Scope          trait;
   struct Vector_ op_tmpl;
-  uint16_t       offset;
-  uint16_t       class_data_size;
 };
 
 struct Nspc_ {
-  struct NspcInfo_ *info;
-  Nspc              parent;
-  m_str             name;
   struct Vector_    vtable;
+  m_bit *           class_data;
   struct VM_Code_ * pre_ctor;
   struct VM_Code_ * dtor;
+  Nspc              parent;
+  m_str             name;
+  struct NspcInfo_ *info;
+  uint16_t       offset;
   uint16_t          ref;
+  uint16_t       class_data_size;
 };
 
 REF_FUNC(Nspc, nspc)
@@ -78,9 +78,9 @@ ANN void did_you_mean_type(const Type, const char *);
   if (strlen(b) < DID_YOU_MEAN_LIMIT) did_you_mean_type(a, b);
 
 ANN static inline void nspc_allocdata(MemPool mp, const Nspc nspc) {
-  if (nspc->info->class_data_size) {
-    nspc->info->class_data =
-        (m_bit *)mp_calloc2(mp, nspc->info->class_data_size);
+  if (nspc->class_data_size) {
+    nspc->class_data =
+        (m_bit *)mp_calloc2(mp, nspc->class_data_size);
   }
 }
 #endif

diff --git a/plug b/plug
index ac29ebb012d01fda0eb1c84dc204941fc6a55d4f..57d4e8c83af845579d08ebb7b1453aa6a98aaa47 160000 (submodule)
--- a/plug
+++ b/plug
@@ -1 +1 @@
-Subproject commit ac29ebb012d01fda0eb1c84dc204941fc6a55d4f
+Subproject commit 57d4e8c83af845579d08ebb7b1453aa6a98aaa47

diff --git a/src/emit/emit.c b/src/emit/emit.c
index cddf0dbd1926f83c0f766e1675ad5c35a59c0ed6..9fc957a8f72be0435b906e419f995dadc36daee1 100644 (file)
--- a/src/emit/emit.c
+++ b/src/emit/emit.c
@@ -799,7 +799,7 @@ ANN static m_bool emit_dot_static_data(const Emitter emit, const Value v,
                                        const bool emit_var) {
   const m_uint size  = v->type->size;
   const Instr  instr = emit_dotstatic(emit, size, emit_var);
-  instr->m_val  = (m_uint)(v->from->owner->info->class_data + v->from->offset);
+  instr->m_val  = (m_uint)(v->from->owner->class_data + v->from->offset);
   instr->m_val2 = size;
   return GW_OK;
 }
@@ -2228,7 +2228,7 @@ ANN static m_bool emit_enum_def(const Emitter emit NUSED, const Enum_Def edef) {
   LOOP_OPTIM
   for (m_uint i = 0; i < vector_size(&edef->values); ++i) {
     const Value v = (Value)vector_at(&edef->values, i);
-    *(m_uint *)(v->from->owner->info->class_data + v->from->offset) = i;
+    *(m_uint *)(v->from->owner->class_data + v->from->offset) = i;
   }
   set_tflag(edef->t, tflag_emit);
   return GW_OK;

diff --git a/src/env/nspc.c b/src/env/nspc.c
index 5e4ed2999ebb5bd376318a67d4bce327ab104a49..ff9a00f5b41647d385d94b893a09762f39b0c464 100644 (file)
--- a/src/env/nspc.c
+++ b/src/env/nspc.c
@@ -15,23 +15,23 @@ ANN void nspc_commit(const Nspc nspc) {
 
 ANN static inline void nspc_release_object(const Nspc a, Value value,
                                            Gwion gwion) {
-  if ((GET_FLAG(value, static) && a->info->class_data) ||
+  if ((GET_FLAG(value, static) && a->class_data) ||
       (value->d.ptr && vflag(value, vflag_builtin))) {
     const M_Object obj =
         value->d.ptr ? (M_Object)value->d.ptr
-                     : *(M_Object *)(a->info->class_data + value->from->offset);
+                     : *(M_Object *)(a->class_data + value->from->offset);
     release(obj, gwion->vm->cleaner_shred);
   }
 }
 
 ANN2(1, 3)
 static inline void nspc_release_struct(const Nspc a, Value value, Gwion gwion) {
-  if (value && ((GET_FLAG(value, static) && a->info->class_data) ||
+  if (value && ((GET_FLAG(value, static) && a->class_data) ||
                 (vflag(value, vflag_builtin) && value->d.ptr))) {
     const m_bit *ptr =
         (value && value->d.ptr)
             ? (m_bit *)value->d.ptr
-            : (m_bit *)(a->info->class_data + value->from->offset);
+            : (m_bit *)(a->class_data + value->from->offset);
     for (m_uint i = 0; i < vector_size(&value->type->info->tuple->types); ++i) {
       const Type t = (Type)vector_at(&value->type->info->tuple->types, i);
       if (isa(t, gwion->type[et_object]) > 0)
@@ -80,8 +80,8 @@ ANN void free_nspc(const Nspc a, const Gwion gwion) {
   if (a->info->op_map.ptr) free_op_map(&a->info->op_map, gwion);
   if (a->info->op_tmpl.ptr) free_op_tmpl(&a->info->op_tmpl, gwion);
   nspc_free_type(a, gwion);
-  if (a->info->class_data && a->info->class_data_size)
-    mp_free2(gwion->mp, a->info->class_data_size, a->info->class_data);
+  if (a->class_data && a->class_data_size)
+    mp_free2(gwion->mp, a->class_data_size, a->class_data);
   if (a->vtable.ptr) vector_release(&a->vtable);
   mp_free(gwion->mp, NspcInfo, a->info);
   if (a->pre_ctor) vmcode_remref(a->pre_ctor, gwion);

diff --git a/src/env/type.c b/src/env/type.c
index e964c15ba4833962caeca2a31ff673b444276504..1c794a807b8bf50c60f9dcb47a9bf32ce14bd174 100644 (file)
--- a/src/env/type.c
+++ b/src/env/type.c
@@ -154,6 +154,6 @@ ANN Type actual_type(const struct Gwion_ *gwion, const Type t) {
 ANN void inherit(const Type t) {
   const Nspc nspc = t->nspc, parent = t->info->parent->nspc;
   if (!nspc || !parent) return;
-  nspc->info->offset = parent->info->offset;
+  nspc->offset = parent->offset;
   if (parent->vtable.ptr) vector_copy2(&parent->vtable, &nspc->vtable);
 }

diff --git a/src/import/import_cdef.c b/src/import/import_cdef.c
index d57b8a271258c0bd194e612fba19966767d6e8db..734cd1806c3e4204927be084607ec4ef00384804 100644 (file)
--- a/src/import/import_cdef.c
+++ b/src/import/import_cdef.c
@@ -130,7 +130,7 @@ ANN m_int gwi_class_end(const Gwi gwi) {
   if (!gwi->gwion->env->class_def)
     GWI_ERR_B(_("import: too many class_end called."))
   const Type t = gwi->gwion->env->class_def;
-  if (t->nspc->info->class_data_size && !t->nspc->info->class_data)
+  if (t->nspc->class_data_size && !t->nspc->class_data)
     nspc_allocdata(gwi->gwion->mp, t->nspc);
   if (tflag(t, tflag_tmpl)) {
     --gwi->tmpls;

diff --git a/src/import/import_udef.c b/src/import/import_udef.c
index 97e89fa7f8392c9072a507c980557e84ae499124..88f6d5f92d047bd4a2f91a9381e02f328b402529 100644 (file)
--- a/src/import/import_udef.c
+++ b/src/import/import_udef.c
@@ -47,7 +47,7 @@ ANN static Type union_type(const Gwi gwi, const Union_Def udef) {
   //  if(!udef->tmpl)
   //    emit_union_offset(udef->l, udef->o);
   //  if(gwi->gwion->env->class_def && !GET_FLAG(udef, static))
-  //      gwi->gwion->env->class_def->nspc->info->offset =
+  //      gwi->gwion->env->class_def->nspc->offset =
   //       udef->o + udef->s;
   //  set_vflag(udef->value, vflag_builtin);
   //  const M_Object o = new_object(gwi->gwion->mp, NULL, udef->value->type);

diff --git a/src/lib/lib_func.c b/src/lib/lib_func.c
index ba782e4b2c9268b5d0d4d6e74f29bf05e24745f6..8818dee470c90d0e1a4dadea5342a9f471ac253b 100644 (file)
--- a/src/lib/lib_func.c
+++ b/src/lib/lib_func.c
@@ -608,8 +608,8 @@ ANN static Type fork_type(const Env env, const Exp_Unary *unary) {
   UNSET_FLAG(fork, final);
   const Type typed = str2type(env->gwion, "TypedFork", exp_self(unary)->pos);
   // ensure room for retval
-  if (typed->nspc->info->offset == fork->nspc->info->offset)
-    typed->nspc->info->offset += t->size;
+  if (typed->nspc->offset == fork->nspc->offset)
+    typed->nspc->offset += t->size;
   UNSET_FLAG(typed, final);
   const Type ret = str2type(env->gwion, c, exp_self(unary)->pos);
   SET_FLAG(typed, final);

diff --git a/src/lib/object.c b/src/lib/object.c
index 8854107f22057bd411776b8b33359723c33334a6..2880c96fde2119285e910ca67f59c9d036aa1b6b 100644 (file)
--- a/src/lib/object.c
+++ b/src/lib/object.c
@@ -26,8 +26,8 @@ M_Object new_object(MemPool p, const VM_Shred shred, const Type t) {
   a->type_ref      = t;
   if (t->nspc) {
     a->vtable.ptr = t->nspc->vtable.ptr;
-    if (t->nspc->info->offset)
-      a->data = (m_bit *)_mp_calloc(p, t->nspc->info->offset);
+    if (t->nspc->offset)
+      a->data = (m_bit *)_mp_calloc(p, t->nspc->offset);
   }
   if (shred) vector_add(&shred->gc, (vtype)a);
   return a;
@@ -86,8 +86,8 @@ __attribute__((hot)) ANN void __release(const M_Object o,
 }
 
 ANN void free_object(MemPool p, const M_Object o) {
-  if (o->type_ref->nspc && o->type_ref->nspc->info->offset)
-    mp_free2(p, o->type_ref->nspc->info->offset, o->data);
+  if (o->type_ref->nspc && o->type_ref->nspc->offset)
+    mp_free2(p, o->type_ref->nspc->offset, o->data);
   mp_free(p, M_Object, o);
 }
 

diff --git a/src/lib/object_op.c b/src/lib/object_op.c
index 26b93c776bc3f2382489f4d298630555abae59c9..cfff45460f41515359d6e15509b912cfb9e1f2b4 100644 (file)
--- a/src/lib/object_op.c
+++ b/src/lib/object_op.c
@@ -88,7 +88,7 @@ ANN static void emit_dot_static_data(const Emitter emit, const Value v,
                                      const bool emit_addr) {
   const m_uint size  = v->type->size;
   const Instr  instr = emit_dotstatic(emit, size, emit_addr);
-  instr->m_val  = (m_uint)(v->from->owner->info->class_data + v->from->offset);
+  instr->m_val  = (m_uint)(v->from->owner->class_data + v->from->offset);
   instr->m_val2 = size;
 }
 

diff --git a/src/lib/shred.c b/src/lib/shred.c
index 7c2533e79b237cd94ab872a82e9151f8deb98165..f9ac2e512f87cf1ddd15756dd0e2ebf55b5f8769 100644 (file)
--- a/src/lib/shred.c
+++ b/src/lib/shred.c
@@ -256,7 +256,7 @@ static ANN THREAD_FUNC(fork_run) {
   MUTEX_LOCK(vm->parent->shreduler->mutex);
   if (!*(m_int *)(me->data + o_shred_cancel) &&
       me->type_ref != vm->gwion->type[et_fork])
-    memcpy(me->data + vm->gwion->type[et_fork]->nspc->info->offset, ME(me)->reg,
+    memcpy(me->data + vm->gwion->type[et_fork]->nspc->offset, ME(me)->reg,
            FORK_RETSIZE(me));
   *(m_int *)(me->data + o_fork_done) = 1;
   if (!*(m_int *)(me->data + o_shred_cancel))

diff --git a/src/parse/check.c b/src/parse/check.c
index da633d90c748ed98810804d0fd177f24d3b9c2fb..3489d33246f9a14e862446653de179add77fc022 100644 (file)
--- a/src/parse/check.c
+++ b/src/parse/check.c
@@ -60,12 +60,12 @@ ANN static inline m_bool check_exp_decl_parent(const Env      env,
   return GW_OK;
 }
 
-#define describe_check_decl(a, b, flag)                                        \
-  ANN static inline void decl_##a(const Env env, const Value v) {              \
-    const Nspc nspc = env->curr;                                               \
-    flag;                                                                      \
-    v->from->offset = nspc->info->b;                                           \
-    nspc->info->b += v->type->size;                                            \
+#define describe_check_decl(a, b, flag)                            \
+  ANN static inline void decl_##a(const Env env, const Value v) {  \
+    const Nspc nspc = env->curr;                                   \
+    flag;                                                          \
+    v->from->offset = nspc->b;                                     \
+    nspc->b += v->type->size;                                      \
   }
 
 describe_check_decl(member, offset, v->vflag |= vflag_member);

diff --git a/src/parse/scan0.c b/src/parse/scan0.c
index f29249e55b70652a4800481c13841ab71d327241..7c3adedacc9ced51cca3827d4c8b15be3a754a41 100644 (file)
--- a/src/parse/scan0.c
+++ b/src/parse/scan0.c
@@ -266,9 +266,9 @@ ANN m_bool scan0_union_def(const Env env, const Union_Def udef) {
   CHECK_BB(scan0_defined(env, udef->xid, udef->pos));
   udef->type   = union_type(env, udef->xid, udef->pos);
   Union_List l = udef->l;
-  do udef->type->nspc->info->offset += SZ_INT;
+  do udef->type->nspc->offset += SZ_INT;
   while ((l = l->next));
-  udef->type->nspc->info->offset += SZ_INT;
+  udef->type->nspc->offset += SZ_INT;
   SET_ACCESS(udef, udef->type);
   if (udef->tmpl) union_tmpl(env, udef);
   if (global) env_pop(env, 0);

diff --git a/src/parse/scan1.c b/src/parse/scan1.c
index 5860ece36f4f9e2586e92f10dcf428fd013eaa35..cc661dfc540b328ecc96b25005c71d13a1d67e85 100644 (file)
--- a/src/parse/scan1.c
+++ b/src/parse/scan1.c
@@ -499,7 +499,7 @@ ANN static inline m_bool scan1_union_def_inner_loop(const Env env,
     nspc_add_value_front(env->curr, l->xid, v);
     if (t->size > sz) sz = t->size;
   } while ((l = l->next));
-  udef->type->nspc->info->offset = SZ_INT + sz;
+  udef->type->nspc->offset = SZ_INT + sz;
   return GW_OK;
 }