From 58287455d64ab16091522bf8a358b079ef05daad Mon Sep 17 00:00:00 2001 From: Daniel Gavin Date: Fri, 4 Mar 2022 12:17:00 +0100 Subject: strip colons and update ast to use unions --- src/common/allocator.odin | 104 +++++++++++++++++++++++----------------------- 1 file changed, 52 insertions(+), 52 deletions(-) (limited to 'src/common/allocator.odin') diff --git a/src/common/allocator.odin b/src/common/allocator.odin index bbb654c..6d2d371 100644 --- a/src/common/allocator.odin +++ b/src/common/allocator.odin @@ -12,119 +12,119 @@ Scratch_Allocator :: struct { } scratch_allocator_init :: proc (s: ^Scratch_Allocator, size: int, backup_allocator := context.allocator) { - s.data, _ = mem.make_aligned([]byte, size, 2 * align_of(rawptr), backup_allocator); - s.curr_offset = 0; - s.prev_allocation = nil; - s.backup_allocator = backup_allocator; - s.leaked_allocations.allocator = backup_allocator; + s.data, _ = mem.make_aligned([]byte, size, 2 * align_of(rawptr), backup_allocator) + s.curr_offset = 0 + s.prev_allocation = nil + s.backup_allocator = backup_allocator + s.leaked_allocations.allocator = backup_allocator } scratch_allocator_destroy :: proc (s: ^Scratch_Allocator) { if s == nil { - return; + return } for ptr in s.leaked_allocations { - mem.free_bytes(ptr, s.backup_allocator); + mem.free_bytes(ptr, s.backup_allocator) } - delete(s.leaked_allocations); - delete(s.data, s.backup_allocator); - s^ = {}; + delete(s.leaked_allocations) + delete(s.data, s.backup_allocator) + s^ = {} } scratch_allocator_proc :: proc (allocator_data: rawptr, mode: mem.Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, mem.Allocator_Error) { - s := (^Scratch_Allocator)(allocator_data); + s := (^Scratch_Allocator)(allocator_data) if s.data == nil { - DEFAULT_BACKING_SIZE :: 1 << 22; + DEFAULT_BACKING_SIZE :: 1 << 22 if !(context.allocator.procedure != scratch_allocator_proc && context.allocator.data != allocator_data) { - panic("cyclic initialization of the scratch allocator with itself"); + panic("cyclic initialization of the scratch allocator with itself") } - scratch_allocator_init(s, DEFAULT_BACKING_SIZE); + scratch_allocator_init(s, DEFAULT_BACKING_SIZE) } - size := size; + size := size switch mode { case .Alloc: - size = mem.align_forward_int(size, alignment); + size = mem.align_forward_int(size, alignment) switch { case s.curr_offset + size <= len(s.data): - start := uintptr(raw_data(s.data)); - ptr := start + uintptr(s.curr_offset); - ptr = mem.align_forward_uintptr(ptr, uintptr(alignment)); - mem.zero(rawptr(ptr), size); - - s.prev_allocation = rawptr(ptr); - offset := int(ptr - start); - s.curr_offset = offset + size; - return mem.byte_slice(rawptr(ptr), size), nil; + start := uintptr(raw_data(s.data)) + ptr := start + uintptr(s.curr_offset) + ptr = mem.align_forward_uintptr(ptr, uintptr(alignment)) + mem.zero(rawptr(ptr), size) + + s.prev_allocation = rawptr(ptr) + offset := int(ptr - start) + s.curr_offset = offset + size + return mem.byte_slice(rawptr(ptr), size), nil } - a := s.backup_allocator; + a := s.backup_allocator if a.procedure == nil { - a = context.allocator; - s.backup_allocator = a; + a = context.allocator + s.backup_allocator = a } - ptr, err := mem.alloc_bytes(size, alignment, a, loc); + ptr, err := mem.alloc_bytes(size, alignment, a, loc) if err != nil { - return ptr, err; + return ptr, err } if s.leaked_allocations == nil { - s.leaked_allocations = make([dynamic][]byte, a); + s.leaked_allocations = make([dynamic][]byte, a) } - append(&s.leaked_allocations, ptr); + append(&s.leaked_allocations, ptr) if logger := context.logger; logger.lowest_level <= .Warning { if logger.procedure != nil { - logger.procedure(logger.data, .Warning, "mem.Scratch_Allocator resorted to backup_allocator" , logger.options, loc); + logger.procedure(logger.data, .Warning, "mem.Scratch_Allocator resorted to backup_allocator" , logger.options, loc) } } - return ptr, err; + return ptr, err case .Free: case .Free_All: - s.curr_offset = 0; - s.prev_allocation = nil; + s.curr_offset = 0 + s.prev_allocation = nil for ptr in s.leaked_allocations { - mem.free_bytes(ptr, s.backup_allocator); + mem.free_bytes(ptr, s.backup_allocator) } - clear(&s.leaked_allocations); + clear(&s.leaked_allocations) case .Resize: - begin := uintptr(raw_data(s.data)); - end := begin + uintptr(len(s.data)); - old_ptr := uintptr(old_memory); + begin := uintptr(raw_data(s.data)) + end := begin + uintptr(len(s.data)) + old_ptr := uintptr(old_memory) - data, err := scratch_allocator_proc(allocator_data, .Alloc, size, alignment, old_memory, old_size, loc); + data, err := scratch_allocator_proc(allocator_data, .Alloc, size, alignment, old_memory, old_size, loc) if err != nil { - return data, err; + return data, err } - runtime.copy(data, mem.byte_slice(old_memory, old_size)); - _, err = scratch_allocator_proc(allocator_data, .Free, 0, alignment, old_memory, old_size, loc); - return data, err; + runtime.copy(data, mem.byte_slice(old_memory, old_size)) + _, err = scratch_allocator_proc(allocator_data, .Free, 0, alignment, old_memory, old_size, loc) + return data, err case .Query_Features: - set := (^mem.Allocator_Mode_Set)(old_memory); + set := (^mem.Allocator_Mode_Set)(old_memory) if set != nil { - set^ = {.Alloc, .Free, .Free_All, .Resize, .Query_Features}; + set^ = {.Alloc, .Free, .Free_All, .Resize, .Query_Features} } - return nil, nil; + return nil, nil case .Query_Info: - return nil, nil; + return nil, nil } - return nil, nil; + return nil, nil } scratch_allocator :: proc (allocator: ^Scratch_Allocator) -> mem.Allocator { return mem.Allocator { procedure = scratch_allocator_proc, data = allocator, - }; + } } -- cgit v1.2.3