86 lines
2.3 KiB
Plaintext
86 lines
2.3 KiB
Plaintext
arraylist :: import "@std/arraylist"
|
|
mem :: import "@std/mem"
|
|
std :: import "@std"
|
|
|
|
Token :: struct { value i32 }
|
|
ScanDiagnostic :: struct { value i32 }
|
|
|
|
State :: struct {
|
|
tokens std.ArrayList(Token)
|
|
diagnostics std.ArrayList(ScanDiagnostic)
|
|
}
|
|
|
|
arrlist_test std.ArrayList(Token) = arraylist.init(mem.c_allocator)
|
|
|
|
hide fail_alloc func(_ ?@mut anyopaque, _ usize, _ usize) ?*mut u8 {
|
|
return none
|
|
}
|
|
|
|
hide fail_realloc func(_ ?@mut anyopaque, _ ?*mut u8, _ usize, _ usize, _ usize) ?*mut u8 {
|
|
return none
|
|
}
|
|
|
|
hide fail_free func(_ ?@mut anyopaque, _ ?*mut u8, _ usize, _ usize) void {}
|
|
|
|
hide fail_vtable mem.AllocatorVTable :: mem.AllocatorVTable {
|
|
alloc = fail_alloc,
|
|
realloc = fail_realloc,
|
|
free = fail_free,
|
|
}
|
|
|
|
hide fail_allocator mem.Allocator :: mem.Allocator {
|
|
context = none,
|
|
vtable = &fail_vtable,
|
|
}
|
|
|
|
run func() i32 ! mem.AllocError {
|
|
values std.ArrayList(i32) = arraylist.init(mem.c_allocator)
|
|
defer arraylist.deinit(&values)
|
|
if (values.items.len != 0 or values.capacity != 0) return 1
|
|
|
|
i usize = 0
|
|
while i < 20 : i += 1 {
|
|
arraylist.append(&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(&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(&values)
|
|
if (values.items.len != 0 or values.capacity != capacity) return 6
|
|
arraylist.append(&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(mem.c_allocator)
|
|
defer arraylist.deinit(&empty_values)
|
|
zero [0]u8 :: []
|
|
arraylist.append(&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(&failed, 1) catch |_| {
|
|
failed_as_expected = true
|
|
}
|
|
if (failed_as_expected == false or failed.items.len != 0 or failed.capacity != 0) return 9
|
|
arraylist.deinit(&failed)
|
|
|
|
return 0
|
|
}
|
|
|
|
main func() i32 {
|
|
return run() catch 100
|
|
}
|