wrote dsa/dsc code examples including an allocator

resources/dsa/lib/memory/arena_alloc.dsa

@@ -0,0 +1,100 @@
+dw heap_start: 196608
+dw heap_end: 262144
+dw heap_current: 196608
+
+new:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg0, 8
+	lli 12, rg1
+	add rg0, rg1, rg2
+	ldw heap_current, rg1
+	add rg1, rg2, rg3
+	ldw heap_end, rg4
+	cmp rg3, rg4
+	lli 0, rg5
+	jle _cmp_end_2
+	lli 1, rg5
+_cmp_end_2:
+	cmp rg5, zero
+	jeq _else_4
+_then_3:
+	lli 0, rg4
+	stw rg4, bpr, 8
+	jmp _ret
+	jmp _end_5
+_else_4:
+	nop
+_end_5:
+	lli 12, rg4
+	add rg1, rg4, rg5
+	add rg1, rg2, rg4
+	stw rg5, rg1
+	lli 4, rg6
+	add rg1, rg6, rg7
+	stw rg5, rg7
+	lli 8, rg6
+	add rg1, rg6, rg7
+	stw rg4, rg7
+	stw rg3, heap_current
+	stw rg1, bpr, 8
+	jmp _ret
+
+alloc:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg0, 8
+	ldw bpr, rg1, 12
+	lli 4, rg2
+	add rg0, rg2, rg3
+	ldw rg3, rg2
+	lli 8, rg3
+	add rg0, rg3, rg4
+	ldw rg4, rg3
+	add rg2, rg1, rg4
+	cmp rg4, rg3
+	lli 0, rg5
+	jle _cmp_end_6
+	lli 1, rg5
+_cmp_end_6:
+	cmp rg5, zero
+	jeq _else_8
+_then_7:
+	lli 0, rg5
+	stw rg5, bpr, 8
+	jmp _ret
+	jmp _end_9
+_else_8:
+	nop
+_end_9:
+	lli 4, rg5
+	add rg0, rg5, rg6
+	stw rg4, rg6
+	stw rg2, bpr, 8
+	jmp _ret
+
+destroy:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg0, 8
+	lli 0, rg1
+	stw rg1, bpr, 8
+	jmp _ret
+
+reset_all:
+	push bpr
+	mov spr, bpr
+
+	ldw heap_start, rg0
+	stw rg0, heap_current
+	lli 0, rg0
+	stw rg0, bpr, 8
+	jmp _ret
+
+_ret:
+    mov bpr, spr
+    pop bpr
+    return

resources/dsa/lib/memory/arena_alloc.dsc

@@ -0,0 +1,77 @@
+// Arena Allocator
+// Supports multiple arenas that can be destroyed independently
+// Much more practical than a simple bump allocator
+
+// Global heap management
+static heap_start: u32 = 0x30000;
+static heap_end: u32 = 0x40000;
+static heap_current: u32 = 0x30000;
+
+// Arena structure (stored at the start of each arena):
+// [0-3]: start_address (u32)
+// [4-7]: current_position (u32)
+// [8-11]: end_address (u32)
+// Total header size: 12 bytes
+
+// Create a new arena with given size
+// Returns pointer to arena handle (or 0 if failed)
+fn arena_create(size: u32) -> u32 {
+    let total_size: u32 = size + 12;
+    let arena_ptr: u32 = heap_current;
+    let new_current: u32 = arena_ptr + total_size;
+
+    // Check if we have space
+    if new_current > heap_end {
+        return 0;
+    }
+
+    // Calculate arena data region
+    let data_start: u32 = arena_ptr + 12;
+    let data_end: u32 = arena_ptr + total_size;
+
+    // Initialize arena header
+    // Note: In real implementation, you'd use pointer writes here
+    // For now, using placeholder comments:
+    *arena_ptr = data_start;        // start_address
+    *(arena_ptr + 4) = data_start;  // current_position
+    *(arena_ptr + 8) = data_end;    // end_address
+
+    heap_current = new_current;
+
+    return arena_ptr;
+}
+
+// Allocate from an arena
+// Returns pointer to allocated memory (or 0 if failed)
+fn arena_alloc(arena: u32, size: u32) -> u32 {
+    // Read current position from arena
+    let current: u32 = *(arena + 4);
+    let end: u32 = *(arena + 8);
+
+    let new_current: u32 = current + size;
+
+    // Check if arena has space
+    if new_current > end {
+        return 0;
+    }
+
+    // Update current position in arena
+    *(arena + 4) = new_current;
+
+    return current;
+}
+
+// Destroy an arena (in bump allocator, this is a no-op)
+// In a real allocator, you'd mark the memory as free
+fn arena_destroy(arena: u32) {
+    // In a true allocator, mark memory as reusable
+    // For bump allocator, we can't reclaim memory
+    // unless we destroy ALL arenas and reset
+    return 0;
+}
+
+// Reset entire heap (destroys ALL arenas)
+fn reset_all() {
+    heap_current = heap_start;
+    return 0;
+}