basic error handling, add ts impl to compare to, stumped...

Makefile

@@ -4,6 +4,9 @@ WASM3_O := $(WASM3_C:.c=.o)
 run: wasm3-test .PHONY
 	./wasm3-test
 
+run-ts:
+	deno run --allow-read main.ts
+
 wasm3-test: main.o $(WASM3_O)
 	gcc -g -lm -o wasm3-test $^
 

main.c

@@ -5,43 +5,59 @@
 
 void* loadFile(size_t* sizeOut, const char* filename) {
   FILE* file = fopen(filename, "rb");
+  assert(file != NULL);
   fseek(file, 0, SEEK_END);
   size_t size = (size_t)ftell(file);
   rewind(file);
 
   void* buffer = malloc(size);
-  fread(buffer, size, 1, file);
+  assert(fread(buffer, size, 1, file) == 1);
   fclose(file);
   *sizeOut = size;
   return buffer;
 }
 
+void verifyM3(M3Result result) {
+  if(result != NULL) {
+    fprintf(stderr, "Error: %s\n", result);
+    exit(1);
+  }
+}
+
 int main() {
   IM3Environment env = m3_NewEnvironment();
   IM3Runtime runtime = m3_NewRuntime(env, 16384, NULL);
   runtime->memory.maxPages = 4;
-  ResizeMemory(runtime, 4);
+  verifyM3(ResizeMemory(runtime, 4));
 
   uint8_t* memory = m3_GetMemory(runtime, NULL, 0);
+  assert(memory != NULL);
 
   size_t loaderSize;
   void* loaderWasm = loadFile(&loaderSize, "loader.wasm");
 
   IM3Module loaderMod;
-  m3_ParseModule(env, &loaderMod, loaderWasm, loaderSize);
+  verifyM3(m3_ParseModule(env, &loaderMod, loaderWasm, loaderSize));
   loaderMod->memoryImported = true;
-  m3_LoadModule(runtime, loaderMod);
+  verifyM3(m3_LoadModule(runtime, loaderMod));
 
-  size_t runtimeUw8Size;
-  void* runtimeUw8 = loadFile(&runtimeUw8Size, "platform.uw8");
-  memcpy(memory, runtimeUw8, runtimeUw8Size);
+  size_t platformUw8Size;
+  void* platformUw8 = loadFile(&platformUw8Size, "platform.uw8");
+  memcpy(memory, platformUw8, platformUw8Size);
+  printf("platform.uw8 size: %u\n", (unsigned int)platformUw8Size);
 
   IM3Function loadUw8;
-  m3_FindFunction(&loadUw8, runtime, "load_uw8");
-  m3_CallV(loadUw8, (uint32_t)runtimeUw8Size);
-  uint32_t runtimeSize;
-  m3_GetResultsV(loadUw8, &runtimeSize);
-  printf("size: %u\n", runtimeSize);
+  verifyM3(m3_FindFunction(&loadUw8, runtime, "load_uw8"));
+  verifyM3(m3_CallV(loadUw8, (uint32_t)platformUw8Size));
+  uint32_t platformSize;
+  verifyM3(m3_GetResultsV(loadUw8, &platformSize));
+  printf("platform size: %u\n", platformSize);
+  printf("First byte: %u\n", memory[0]);
+
+  IM3Module platformMod;
+  verifyM3(m3_ParseModule(env, &platformMod, memory, platformSize));
+  platformMod->memoryImported = true;
+  verifyM3(m3_LoadModule(runtime, platformMod));
 
   return 0;
 }

main.ts

@@ -0,0 +1,24 @@
+let U8 = (...a) => new Uint8Array(...a);
+
+let memory = new WebAssembly.Memory({ initial: 4 });
+let memU8 = U8(memory.buffer);
+
+let importObject = {
+  env: {
+    memory
+  }
+};
+
+let loaderWasm = await Deno.readFile("loader.wasm");
+let loader = (await WebAssembly.instantiate(loaderWasm, importObject)).instance;
+
+let platformUw8 = await Deno.readFile("platform.uw8");
+console.log("platform.uw8 size: " + platformUw8.byteLength);
+memU8.set(U8(platformUw8));
+let platformSize = loader.exports.load_uw8(platformUw8.byteLength);
+let platformWasm = new ArrayBuffer(platformSize);
+U8(platformWasm).set(memU8.slice(0, platformSize));
+
+console.log("Unpacked platform size: " + platformSize);
+
+console.log("First byte: " + U8(platformWasm)[0]);