Fix memory allocation and update catto

Author: James-Livesey

include/catto

@@ -143,11 +143,23 @@ export class Context {
         this.#commands[command](...args);
     }
 
+    get errorState() {
+        return readString(exports.getErrorState(this.#getContext()));
+    }
+
+    checkErrorState() {
+        if (this.errorState != "CATTO_ERROR_STATE_NONE") {
+            throw new Error(this.errorState);
+        }
+    }
+
     load(code) {
         var codeString = internString(code);
 
         try {
             exports.load(this.#getContext(), codeString);
+
+            this.checkErrorState();
         } finally {
             freeString(codeString);
         }
@@ -158,6 +170,10 @@ export class Context {
 
         this.#steps++;
 
+        if (!running) {
+            this.checkErrorState();
+        }
+
         return running;
     }
 

lib/atto.js

@@ -41,8 +41,33 @@ WASM_EXPORT_AS("freeString") void freeString(char* string) {
     free(string);
 }
 
+void print(char* message) {
+    main_log(message);
+    main_log("\n");
+}
+
 WASM_EXPORT_AS("init") void init(Block* memoryBase) {
+    heapLogger = print;
+
     firstFreeBlock = base = memoryBase;
+    *firstFreeBlock = 0;
+}
+
+WASM_EXPORT_AS("getErrorState") char* getErrorState(catto_Context* context) {
+    switch (context->errorState) {
+        case CATTO_ERROR_STATE_NONE: return "CATTO_ERROR_STATE_NONE";
+        case CATTO_ERROR_STATE_UNEXPECTED_TOKEN: return "CATTO_ERROR_STATE_UNEXPECTED_TOKEN";
+        case CATTO_ERROR_STATE_NO_RETURN: return "CATTO_ERROR_STATE_NO_RETURN";
+        case CATTO_ERROR_STATE_MISMATCHED_OPENING_MARK: return "CATTO_ERROR_STATE_MISMATCHED_OPENING_MARK";
+        case CATTO_ERROR_STATE_MISMATCHED_CLOSING_MARK: return "CATTO_ERROR_STATE_MISMATCHED_CLOSING_MARK";
+        case CATTO_ERROR_STATE_LOOP_CONTROL_OUTSIDE_LOOP: return "CATTO_ERROR_STATE_LOOP_CONTROL_OUTSIDE_LOOP";
+        case CATTO_ERROR_STATE_UNKNOWN_PROCEDURE: return "CATTO_ERROR_STATE_UNKNOWN_PROCEDURE";
+        case CATTO_ERROR_STATE_NOT_A_FUNCTION: return "CATTO_ERROR_STATE_NOT_A_FUNCTION";
+        case CATTO_ERROR_STATE_NOT_A_LIST: return "CATTO_ERROR_STATE_NOT_A_LIST";
+        case CATTO_ERROR_STATE_INVALID_LIST_VALUE: return "CATTO_ERROR_STATE_INVALID_LIST_VALUE";
+        case CATTO_ERROR_STATE_CANNOT_ASSIGN_VALUE: return "CATTO_ERROR_STATE_CANNOT_ASSIGN_VALUE";
+        default: return "ATTOJS_ERROR_STATE_UNKNOWN";
+    }
 }
 
 void handleCommand(catto_Context* context) {

lib/bin/atto.wasm

@@ -17,6 +17,8 @@
 Block* base;
 Block* firstFreeBlock;
 
+void (*heapLogger)(char*);
+
 void* memset(void* destination, int value, size_t size) {
     for (size_t i = 0; i < size; i++) {
         *((char*)destination + size) = value;
@@ -81,19 +83,16 @@ void* malloc(size_t size) {
 
             Block* originalBlock = currentBlock;
             size_t totalUsableSize = originalBlockSize;
-            bool encounteredUsedBlock = false;
             bool encounteredLastBlock = false;
 
-            DEBUG_HEAP_LOG("Attempt resize");
+            DEBUG_HEAP_LOG("Attempt merge");
 
-            do {
+            while (true) {
                 currentBlock += sizeof(Block) + BLOCK_SIZE(currentBlock);
 
                 if (BLOCK_IS_USED(currentBlock)) {
                     DEBUG_HEAP_LOG("  Encountered used block");
 
-                    encounteredUsedBlock = true;
-
                     break;
                 }
 
@@ -108,20 +107,26 @@ void* malloc(size_t size) {
                 }
 
                 totalUsableSize += *currentBlock + sizeof(Block);
-            } while (totalUsableSize < size);
-
-            if (encounteredUsedBlock) {
-                continue;
             }
 
-            currentBlock = originalBlock;
-
             if (encounteredLastBlock) {
                 DEBUG_HEAP_LOG("  Using last block");
 
+                currentBlock = originalBlock;
+
                 *(currentBlock + sizeof(Block) + size) = 0; // Create a new last block after this one
+                originalBlockSize = totalUsableSize;
             } else {
-                *currentBlock = totalUsableSize;
+                *originalBlock = totalUsableSize;
+
+                if (totalUsableSize < size + sizeof(Block)) {
+                    continue;
+                }
+
+                DEBUG_HEAP_LOG("  Use merged block");
+
+                currentBlock = originalBlock;
+                originalBlockSize = totalUsableSize;
             }
         }
 

src/atto.c

@@ -8,6 +8,8 @@ typedef char bool;
 extern Block* base;
 extern Block* firstFreeBlock;
 
+extern void (*heapLogger)(char*);
+
 void* memset(void* destination, int value, size_t size);
 void* memcpy(void* destination, const void* source, size_t size);
 void* malloc(size_t size);