arena & vec work

docs/spec/alloc.md

@@ -19,8 +19,8 @@ Allocator := struct {
     /// same behaviour as alloc, except:
     /// must move data to new allocation,
     /// must ensure the old allocation is freed at some point.
-    realloc := fn(self: ^Self, $T: type, ptr: ^T, new_count: uint): ?[]T
+    realloc := fn(self: ^Self, $T: type, prev: []T, new_count: uint): ?[]T
     /// must dealloc or schedule the freeing of the given allocation
-    dealloc := fn(self: ^Self, $T: type, ptr: ^T): void
+    dealloc := fn(self: ^Self, $T: type, prev: []T): void
 }
 ```

main.hb

@@ -1,6 +1,6 @@
 lily.{fmt, log, mem, alloc, target} := @use("lily")
 
-b: []u8 = idk
+// b: []u8 = idk
 
 main := fn(): void {
 	arena := alloc.Arena.new()
@@ -13,11 +13,18 @@ main := fn(): void {
 	// 	i += 1
 	// }
 
-	b = arena.alloc_zeroed(u8, 1000).?
+	// b = arena.alloc_zeroed(u8, 1000).?
 
-	mem.bytes(mem.reverse("Hello, World!")[1..]).take(5).for_each(fn(x: u8): void {
-		len := fmt.fmt_int(b, x, 16)
-		log.info(b[0..len])
-		mem.set(b.ptr, 0, len)
-	})
+	// mem.bytes(mem.reverse("Hello, World!")[1..]).take(5).for_each(fn(x: u8): void {
+	// 	len := fmt.fmt_int(b, x, 16)
+	// 	log.info(b[0..len])
+	// 	mem.set(b.ptr, 0, len)
+	// })
+
+	c := alloc.Vec(uint, alloc.Arena).new(&arena)
+	defer c.deinit()
+
+	loop if c.len() == 100000 break else {
+		c.push(1)
+	}
 }

src/alloc/arena.hb

@@ -61,11 +61,13 @@ Arena := struct {
 		mem.set(slice.?.ptr, 0, slice.?.len)
 		return slice
 	}
-	$realloc := fn(self: ^Self, $T: type, ptr_old: ^T, count_new: uint): ?[]T {
-		@error("todo: ", Self.realloc)
-		return null
+	$realloc := fn(self: ^Self, $T: type, prev: []T, count_new: uint): ?[]T {
+		slice := self.alloc(T, mem.size(T, count_new))
+		if slice == null return null
+		mem.copy(@bit_cast(slice.?.ptr), @bit_cast(prev.ptr), mem.size(T, prev.len))
+		return slice
 	}
-	$dealloc := fn(self: ^Self, $T: type, ptr: ^T): void {
+	$dealloc := fn(self: ^Self, $T: type, prev: []T): void {
 	}
 	deinit := fn(self: ^Self): void {
 		if self.allocation == null {

src/alloc/vec.hb

@@ -1,4 +1,3 @@
-// ! stub
 Vec := fn(T: type, A: type): type return struct {
 	.slice: []T;
 	.cap: uint;
@@ -9,7 +8,36 @@ Vec := fn(T: type, A: type): type return struct {
 	$new := fn(allocator: ^A): Self {
 		return .(idk, 0, allocator)
 	}
+	push := fn(self: ^Self, elem: T): void {
+		if self.slice.len == self.cap {
+			if self.cap == 0 {
+				new_slice := self.allocator.alloc(T, 1)
+				if new_slice == null {
+					// todo: handle
+					die
+				}
+				self.slice = new_slice.?[0..self.slice.len]
+				self.cap = new_slice.?.len
+			} else {
+				new_slice := self.allocator.realloc(T, self.slice[0..self.cap], self.cap * 2)
+				if new_slice == null {
+					// todo: handle
+					die
+				}
+				self.slice = new_slice.?[0..self.slice.len]
+				self.cap = new_slice.?.len
+			}
+		}
+		self.slice[self.slice.len] = elem
+		self.slice = self.slice[0..self.slice.len + 1]
+	}
+
+	$len := fn(self: ^Self): uint {
+		return self.slice.len
+	}
 
 	deinit := fn(self: ^Self): void {
+		self.allocator.dealloc(T, self.slice[0..self.cap])
+		self.* = idk
 	}
 }