aboutsummaryrefslogtreecommitdiff
path: root/src/zeroscript/App/object-store.js
diff options
context:
space:
mode:
authorNathan Reiner <nathan@nathanreiner.xyz>2026-10-09 14:01:20 +0200
committerNathan Reiner <nathan@nathanreiner.xyz>2026-10-09 14:01:20 +0200
commit32a251aa9645de070727a6ec91490d3e9219ec7c (patch)
tree5dd55205c5df68fa449e766ec2a8d248e21bd2be /src/zeroscript/App/object-store.js
parent09e8d4548361ece6151b914709c39e254eba65e3 (diff)
rename z framework to zeroscript
Diffstat (limited to 'src/zeroscript/App/object-store.js')
-rw-r--r--src/zeroscript/App/object-store.js210
1 files changed, 210 insertions, 0 deletions
diff --git a/src/zeroscript/App/object-store.js b/src/zeroscript/App/object-store.js
new file mode 100644
index 0000000..096d085
--- /dev/null
+++ b/src/zeroscript/App/object-store.js
@@ -0,0 +1,210 @@
+class ObjectStore {
+ static types = Object.freeze({
+ 0: "uninit",
+ 1: "object",
+ 2: "string",
+ 3: "int",
+ 4: "uint",
+ 5: "float",
+ 6: "undefined",
+
+ "uninit": 0,
+ "object": 1,
+ "string": 2,
+ "int": 3,
+ "uint": 4,
+ "float": 5,
+ "undefined": 6,
+ });
+
+ static methods = Object.freeze({
+ 0: 'free',
+ 1: 'getProp',
+ 2: 'setProp',
+ 3: 'delProp',
+ 4: 'callMethod',
+ 5: 'call',
+ 6: 'new',
+ });
+
+ static store = { 0: null };
+
+ static generateFreeId() {
+ let id = 0;
+
+ while (id in ObjectStore.store) {
+ id = Math.floor(Math.random() * (2**32 - 1))
+ }
+
+ return id;
+ }
+
+ static free(target) {
+ const id = target[ZsId];
+ delete target[ZsId];
+ delete ObjectStore.store[id];
+ }
+
+ static getProp(target, key) {
+ return target[key];
+ }
+
+ static setProp(target, key, value) {
+ target[key] = value;
+ }
+
+ static delProp(target, key) {
+ delete target[key];
+ }
+
+ static callMethod(target, method, ...args) {
+ return target[method](...args);
+ }
+
+ static call(target, args) {
+ return target(args);
+ }
+
+ static new(target, ...args) {
+ return new target(...args);
+ }
+
+ static decodeString(base, len) {
+ const slice = new Uint8Array(wasm.memory.buffer, base, len);
+ return new TextDecoder().decode(slice);
+ }
+
+ static decodeCall(view, offset) {
+ const kind = ObjectStore.methods[view.getUint8(offset, true)]
+
+ if (!kind) throw "unknown method, cannot decode";
+
+ return {
+ kind: kind,
+ num_args: view.getUint8(offset + 1, true),
+ }
+ }
+
+ static decodeValue(view, offset) {
+ const kind = ObjectStore.types[view.getUint8(offset, true)];
+
+ if (!kind) throw "unknown type, cannot decode";
+
+ if (kind === 'string') {
+ const ptr = view.getUint32(offset + 8, true)
+ const len = view.getUint32(offset + 12, true)
+ return ObjectStore.decodeString(ptr, len);
+ }
+
+ if (kind === 'int') {
+ return view.getInt32(offset + 8, true);
+ }
+
+ if (kind === 'uint') {
+ return view.getUint32(offset + 8, true);
+ }
+
+ if (kind === 'object') {
+ const id = view.getUint32(offset + 8, true);
+ return ObjectStore.store[id];
+ }
+
+ if (kind === 'float') {
+ return view.getFloat64(offset + 8, true);
+ }
+ }
+
+ static registerObject(id, obj) {
+ ObjectStore.store[id] = obj;
+ Object.defineProperty(obj, ZsId, {
+ enumerable: false,
+ writable: false,
+ configurable: true,
+ value: id,
+ })
+ }
+
+ static writeValue(ptr, value) {
+ const mem = new DataView(wasm.memory.buffer, ptr);
+
+ if (typeof value === 'object' || typeof value === 'function') {
+ mem.setUint8(0, ObjectStore.types['object'], true);
+ let id = value == null ? 0 : value[ZsId];
+
+ if (id === undefined) {
+ id = ObjectStore.generateFreeId();
+ ObjectStore.registerObject(id, value);
+ }
+
+ mem.setUint32(8, id, true);
+
+ return;
+ }
+
+ if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+ mem.setUint8(0, ObjectStore.types['uint'], true);
+ mem.setUint32(8, value, true)
+ return;
+ }
+
+ if (typeof value === 'number' && Number.isInteger(value)) {
+ mem.setUint8(0, ObjectStore.types['int'], true);
+ mem.setInt32(8, value, true)
+ return;
+ }
+
+ if (typeof value === 'number') {
+ mem.setUint8(0, ObjectStore.types['float'], true);
+ mem.setFloat64(8, value, true)
+ return;
+ }
+
+ if (typeof value === 'string') {
+ const string_ptr = wasm.exports.valueAllocString(ptr, value.length);
+ const encoder = new TextEncoder();
+ const string = encoder.encode(value);
+ const memory = new Uint8Array(wasm.memory.buffer);
+ memory.set(string, string_ptr);
+ return;
+ }
+
+ if (typeof value === 'undefined') {
+ mem.setUint8(0, ObjectStore.types['undefined'], true);
+ return;
+ }
+ }
+
+ static processWasm(
+ calls_base,
+ values_base,
+ result_base,
+ length,
+ ) {
+ const offset = {
+ call: 0,
+ value: 0,
+ result: 0,
+ }
+
+ const calls_view = new DataView(wasm.memory.buffer, calls_base);
+ const values_view = new DataView(wasm.memory.buffer, values_base);
+ const results_view = new DataView(wasm.memory.buffer, result_base);
+
+ for (let i = 0; i < length; ++i) {
+ const method = ObjectStore.decodeCall(calls_view, offset.call);
+ offset.call += 2;
+
+ let args = new Array(method.num_args).fill().map(_ => {
+ const value = ObjectStore.decodeValue(values_view, offset.value);
+ offset.value += 16;
+ return value;
+ });
+
+ const result = ObjectStore[method.kind](...args);
+ const result_ptr = results_view.getUint32(offset.result, true);
+ offset.result += 4;
+
+ ObjectStore.writeValue(result_ptr, result);
+ }
+ }
+}