pretty much all the structs we care about

build.zig

@@ -9,6 +9,8 @@ fn addEngineSources(c: *std.Build.Step.Compile) void {
             "src/lock.c",
             "src/utils.c",
             "src/value.c",
+            "src/component.c",
+            "src/computer.c",
             "src/universe.c",
         },
     });

src/component.c

@@ -0,0 +1,2 @@
+#include "neonucleus.h"
+#include "component.h"

src/component.h

@@ -0,0 +1,32 @@
+#ifndef NEONUCLEUS_COMPONENT_H
+#define NEONUCLEUS_COMPONENT_H
+
+#include "neonucleus.h"
+#include "computer.h"
+
+typedef struct nn_method {
+    const char *name;
+    nn_componentMethod *method;
+    void *userdata;
+    const char *doc;
+    bool direct;
+} nn_method;
+
+typedef struct nn_componentTable {
+    const char *name;
+    void *userdata;
+    nn_componentConstructor *constructor;
+    nn_componentConstructor *destructor;
+    nn_method methods[NN_MAX_METHODS];
+    size_t methodCount;
+} nn_componentTable;
+
+typedef struct nn_component {
+    nn_address address;
+    int slot;
+    nn_componentTable *table;
+    void *statePtr;
+    nn_computer *computer;
+} nn_component;
+
+#endif

src/computer.c

@@ -0,0 +1 @@
+#include "computer.h"

src/computer.h

@@ -0,0 +1,16 @@
+#ifndef NEONUCLEUS_COMPUTER_H
+#define NEONUCLEUS_COMPUTER_H
+
+#include "neonucleus.h"
+
+typedef struct nn_computer {
+    nn_component *components;
+    size_t componentLen;
+    size_t componentCap;
+    nn_value args[NN_MAX_ARGS];
+    size_t argc;
+    nn_value rets[NN_MAX_RETS];
+    size_t retc;
+} nn_computer;
+
+#endif

src/neonucleus.h

@@ -12,11 +12,11 @@
 
 #define NN_MAX_ARGS 32
 #define NN_MAX_RETS 32
-#define NN_MAX_METHODS 128
+#define NN_MAX_METHODS 32
 #define NN_MAX_USERS 128
 #define NN_MAX_ARCHITECTURES 16
-#define NN_MAX_SIGNALS 128
+#define NN_MAX_SIGNALS 32
-#define NN_MAX_SIGNAL_VALS 63
+#define NN_MAX_SIGNAL_VALS 32
 #define NN_MAX_USERDATA 1024
 
 typedef struct nn_guard nn_guard;
@@ -46,7 +46,7 @@ typedef const char *nn_address;
 #define NN_VALUE_NIL 7
 
 typedef struct nn_string {
-    const char *data;
+    char *data;
     size_t len;
     size_t refc;
 } nn_string;
@@ -100,7 +100,7 @@ void nn_unsafeDeleteUniverse(nn_universe *universe);
 void *nn_queryUserdata(nn_universe *universe, const char *name);
 void nn_storeUserdata(nn_universe *universe, const char *name, void *data);
 
-nn_computer *nn_newComputer(nn_universe *universe, nn_address address, nn_architecture *arch, void *userdata, size_t memoryLimit);
+nn_computer *nn_newComputer(nn_universe *universe, nn_address address, nn_architecture *arch, void *userdata, size_t memoryLimit, size_t componentLimit);
 void nn_tickComputer(nn_computer *computer);
 void nn_setUptime(nn_computer *computer, double uptime);
 double nn_getUptime(nn_computer *computer);
@@ -155,6 +155,12 @@ const char *nn_indexUser(nn_computer *computer, size_t idx);
 int nn_getState(nn_computer *computer);
 void nn_setState(nn_computer *computer, int state);
 
+size_t nn_countUsers(nn_computer *computer);
+bool nn_isUser(nn_computer *computer, const char *user);
+void nn_addUser(nn_computer *computer, const char *user);
+void nn_removeUser(nn_computer *computer, const char *user);
+const char *nn_getUser(nn_computer *computer, size_t idx);
+
 void nn_setEnergyInfo(nn_computer *computer, size_t energy, size_t capacity);
 size_t nn_getEnergy(nn_computer *computer);
 void nn_removeEnergy(nn_computer *computer, size_t energy);
@@ -189,7 +195,7 @@ typedef void *nn_componentConstructor(void *userdata);
 typedef void *nn_componentDestructor(void *tableUserdata, void *componentUserdata);
 typedef void nn_componentMethod(void *componentUserdata, void *methodUserdata, nn_component *component, nn_computer *computer);
 
-nn_componentTable *nn_newComponentTable(const char *typeName, void *userdata, nn_componentConstructor, nn_componentDestructor);
+nn_componentTable *nn_newComponentTable(const char *typeName, void *userdata, nn_componentConstructor *constructor, nn_componentDestructor *destructor);
 void nn_destroyComponentTable(nn_componentTable *table);
 void nn_defineMethod(nn_componentTable *table, const char *methodName, bool direct, nn_componentMethod *methodFunc, void *methodUserdata, const char *methodDoc);
 const char *nn_getTableMethod(nn_componentTable *table, size_t idx, bool *outDirect);
@@ -224,7 +230,7 @@ void nn_values_drop(nn_value val);
 void nn_values_set(nn_value arr, size_t idx, nn_value val);
 nn_value nn_values_get(nn_value arr, size_t idx);
 
-void nn_values_setPair(nn_value obj, nn_value key, nn_value val);
+void nn_values_setPair(nn_value obj, size_t idx, nn_value key, nn_value val);
 nn_pair nn_values_getPair(nn_value obj, size_t idx);
 
 intptr_t nn_toInt(nn_value val);

src/value.c

@@ -85,3 +85,72 @@ nn_value nn_values_table(size_t pairCount) {
 size_t nn_values_getType(nn_value val) {
     return val.tag;
 }
+
+nn_value nn_values_retain(nn_value val) {
+    if(val.tag == NN_VALUE_STR) {
+        val.string->refc++;
+    } else if(val.tag == NN_VALUE_ARRAY) {
+        val.array->refc++;
+    } else if(val.tag == NN_VALUE_TABLE) {
+        val.table->refc++;
+    }
+    return val;
+}
+
+void nn_values_drop(nn_value val) {
+    if(val.tag == NN_VALUE_STR) {
+        val.string->refc--;
+        if(val.string->refc == 0) {
+            nn_free(val.string->data);
+            nn_free(val.string);
+        }
+    } else if(val.tag == NN_VALUE_ARRAY) {
+        val.array->refc--;
+        if(val.array->refc == 0) {
+            for(size_t i = 0; i < val.array->len; i++) {
+                nn_values_drop(val.array->values[i]);
+            }
+            nn_free(val.array->values);
+            nn_free(val.array);
+        }
+    } else if(val.tag == NN_VALUE_TABLE) {
+        val.table->refc--;
+        if(val.table->refc == 0) {
+            for(size_t i = 0; i < val.table->len; i++) {
+                nn_values_drop(val.table->pairs[i].key);
+                nn_values_drop(val.table->pairs[i].val);
+            }
+            nn_free(val.table->pairs);
+            nn_free(val.table);
+        }
+    }
+}
+
+void nn_values_set(nn_value arr, size_t idx, nn_value val) {
+    if(arr.tag != NN_VALUE_ARRAY) return;
+    if(idx >= arr.array->len) return;
+    nn_values_drop(arr.array->values[idx]);
+    arr.array->values[idx] = val;
+}
+
+nn_value nn_values_get(nn_value arr, size_t idx) {
+    if(arr.tag != NN_VALUE_ARRAY) return nn_values_nil();
+    if(idx >= arr.array->len) return nn_values_nil();
+    return arr.array->values[idx];
+}
+
+void nn_values_setPair(nn_value obj, size_t idx, nn_value key, nn_value val) {
+    if(obj.tag != NN_VALUE_TABLE) return;
+    if(idx >= obj.table->len) return;
+    nn_values_drop(obj.table->pairs[idx].key);
+    nn_values_drop(obj.table->pairs[idx].val);
+    obj.table->pairs[idx].key = key;
+    obj.table->pairs[idx].val = val;
+}
+
+nn_pair nn_values_getPair(nn_value obj, size_t idx) {
+    nn_pair badPair = {.key = nn_values_nil(), .val = nn_values_nil()};
+    if(obj.tag != NN_VALUE_TABLE) return badPair;
+    if(idx >= obj.table->len) return badPair;
+    return obj.table->pairs[idx];
+}