stlib arraylist

examples/programs/arraylist/main.bro

@@ -0,0 +1,77 @@
+arraylist :: import "@std/arraylist"
+mem :: import "@std/mem"
+
+_fail_alloc func(_ ?*mut anyopaque, _ usize, _ usize) ?*mut u8 {
+	return none
+}
+
+_fail_realloc func(_ ?*mut anyopaque, _ ?*mut u8, _ usize, _ usize, _ usize) ?*mut u8 {
+	return none
+}
+
+_fail_free func(_ ?*mut anyopaque, _ ?*mut u8, _ usize, _ usize) void {}
+
+_fail_vtable mem.AllocatorVTable :: mem.AllocatorVTable {
+	alloc = _fail_alloc,
+	realloc = _fail_realloc,
+	free = _fail_free,
+}
+
+_fail_allocator mem.Allocator :: mem.Allocator {
+	context = none,
+	vtable = &_fail_vtable,
+}
+
+_noop func() void {}
+
+run func() i32 ! mem.AllocError {
+	values arraylist.ArrayList(i32) = arraylist.init(i32, mem.c_allocator)
+	defer arraylist.deinit(i32, &values)
+	if (values.items.len != 0 or values.capacity != 0) return 1
+
+	i usize = 0
+	while i < 20 : i += 1 {
+		arraylist.append(i32, &values, i32(i)) catch |_| {
+			return .out_of_memory
+		}
+	}
+	if (values.items.len != 20 or values.capacity < 20) return 2
+	if (values.items[0] != 0 or values.items[19] != 19) return 3
+	values.items[3] = 33
+	if (values.items[3] != 33) return 4
+
+	arraylist.reserve(i32, &values, 50) catch |_| {
+		return .out_of_memory
+	}
+	if (values.capacity < 50 or values.items.len != 20 or values.items[19] != 19) return 5
+	capacity usize :: values.capacity
+	arraylist.clear(i32, &values)
+	if (values.items.len != 0 or values.capacity != capacity) return 6
+	arraylist.append(i32, &values, 7) catch |_| {
+		return .out_of_memory
+	}
+	if (values.items.len != 1 or values.items[0] != 7 or values.capacity != capacity) return 7
+
+	empty_values arraylist.ArrayList([0]u8) = arraylist.init([0]u8, mem.c_allocator)
+	defer arraylist.deinit([0]u8, &empty_values)
+	zero [0]u8 :: []
+	arraylist.append([0]u8, &empty_values, zero) catch |_| {
+		return .out_of_memory
+	}
+	if (empty_values.items.len != 1) return 8
+
+	failed arraylist.ArrayList(i32) = arraylist.init(i32, _fail_allocator)
+	failed_as_expected bool = false
+	arraylist.append(i32, &failed, 1) catch |_| {
+		failed_as_expected = true
+		yield _noop()
+	}
+	if (failed_as_expected == false or failed.items.len != 0 or failed.capacity != 0) return 9
+	arraylist.deinit(i32, &failed)
+
+	return 0
+}
+
+main func() i32 {
+	return run() catch 100
+}

examples/programs/mem_allocator/typed_alloc.bro

@@ -92,6 +92,14 @@ typed_allocator_test func() i32 {
 	typed[0] = 10
 	typed[3] = 20
 	if (typed[0] + typed[3] != 30) return 39
+	typed = mem.realloc(i32, mem.c_allocator, typed, 8) catch |_| {
+		return 41
+	}
+	if (typed.len != 8 or typed[0] != 10 or typed[3] != 20) return 42
+	typed = mem.realloc(i32, mem.c_allocator, typed, 2) catch |_| {
+		return 43
+	}
+	if (typed.len != 2 or typed[0] != 10) return 44
 
 	return 0
 }

examples/programs/type_factory/main.bro

@@ -0,0 +1,44 @@
+Box func($T type) type {
+	return struct {
+		value T
+	}
+}
+
+Buffer func($T type, $N usize) type {
+	if N == 0 {
+		return struct {
+			values [0]T
+		}
+	}
+	return struct {
+		values [N]T
+	}
+}
+
+BoxAlias func($T type) type {
+	return Box(T)
+}
+
+LocalAlias func($T type) type {
+	chosen :: T
+	return chosen
+}
+
+make_box func($T type, value T) Box(T) {
+	return Box(T) { value = value }
+}
+
+main func() i32 {
+	box Box(i32) :: make_box(i32, 42)
+	if (box.value != 42) return 1
+	aliased BoxAlias(i32) :: box
+	if (aliased.value != 42) return 3
+	local_alias LocalAlias(i32) :: 42
+	if (local_alias != 42) return 6
+	pointer @Box(i32) :: &box
+	if (pointer.value != 42) return 4
+	buffer Buffer(u8, 4) :: Buffer(u8, 4) { values = [1, 2, 3, 4] }
+	if (buffer.values.len != 4) return 2
+	if (size_of(Buffer(u8, 4)) != 4) return 5
+	return 0
+}