refactor: Changed Result types return sytaxis

include/arena.h

@@ -60,4 +60,7 @@ ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment);
 bool mul_size_t_safe(size_t a, size_t b, size_t *out);
 
 
+
+
+
 #endif // !ARENA_H

src/arena.c

@@ -7,20 +7,12 @@
 
 ArenaResult arena_init(size_t capacity) {
     if (capacity < 1) {
-        ArenaResult err = {
+        return (ArenaResult) {.is_valid = false, .err = ARENA_INVALID_SIZE};
-            .is_valid = false,
-            .err = ARENA_INVALID_SIZE,
-        };
-        return err;
     }
 
     void *buffer = malloc(capacity);
     if (buffer == NULL) {
-        ArenaResult err = {
+        return (ArenaResult) {.is_valid = false, .err = ARENA_BAD_ALLOC};
-            .is_valid = false,
-            .err = ARENA_BAD_ALLOC,
-        };
-        return err;
     }
 
     Arena new_arena = {
@@ -28,12 +20,8 @@ ArenaResult arena_init(size_t capacity) {
         .capacity = capacity,
         .offset = 0,
     };
-    ArenaResult val = {
-        .is_valid = true,
-        .arena = new_arena,
-    };
 
-    return val;
+    return (ArenaResult) {.is_valid = true, .arena = new_arena};
 }
 
 void arena_destroy(Arena *arena) {
@@ -45,47 +33,27 @@ void arena_destroy(Arena *arena) {
 
 ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment) {
     if (arena == NULL) {
-        ArenaPointer err = {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_NULL_ARG};
-            .is_valid = false,
-            .err = ARENA_NULL_ARG,
-        };
-        return err;
     }
 
     SizeResult padding = get_arena_align_padding(arena, alignment);
     if (!padding.is_valid) {
-        ArenaPointer err = {
+        return (ArenaPointer) {.is_valid = false, .err = padding.err};
-            .is_valid = false,
-            .err = padding.err,
-        };
-        return err;
     }
 
 
     if (arena->offset + padding.val >= arena->capacity) {
-        ArenaPointer err = {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_OUT_OF_SPACE};
-            .is_valid = false,
-            .err = ARENA_OUT_OF_SPACE,
-        };
-        return err;
     }
 
     if (arena->offset > SIZE_MAX - padding.val - size) {
-        ArenaPointer err = {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_CAPACITY_OVERFLOW};
-            .is_valid = false,
-            .err = ARENA_CAPACITY_OVERFLOW,
-        };
-        return err;
     }
 
     size_t aligned_offset = arena->offset + padding.val;
 
     arena->offset = aligned_offset + size;
-    ArenaPointer val = {
+    return (ArenaPointer) {.is_valid = true, .address = arena->buffer + aligned_offset};
-        .is_valid = true,
-        .address = arena->buffer + aligned_offset,
-    };
-    return val;
 }
 
 ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment) {
@@ -122,20 +90,12 @@ ArenaErr arena_ensure_capacity(Arena *arena, size_t size, size_t alignment) {
 
 ArenaPointer arena_push(Arena *arena, void *data, size_t size, size_t alignment) {
     if (arena == NULL || data == NULL) {
-        ArenaPointer bad_pointer = {
+        return (ArenaPointer) {.is_valid = false, .err = ARENA_NULL_ARG};
-            .is_valid = false,
-            .err = ARENA_NULL_ARG,
-        };
-        return bad_pointer;
     }
 
     ArenaErr err = arena_ensure_capacity(arena, size, alignment);
     if (err != ARENA_OK) {
-        ArenaPointer bad_pointer = {
+        return (ArenaPointer) {.is_valid = false, .err = err};
-            .is_valid = false,
-            .err = err,
-        };
-        return bad_pointer;
     }
 
     ArenaPointer pointer = arena_alloc(arena, size, alignment);
@@ -168,28 +128,17 @@ ArenaErr arena_realloc(Arena *arena, size_t new_capacity) {
 
 SizeResult get_arena_align_padding(Arena *arena, size_t alignment) {
     if (arena == NULL) {
-        SizeResult err = {
+        return (SizeResult) {.is_valid = false, .err = ARENA_NULL_ARG};
-            .is_valid = false,
-            .err = ARENA_NULL_ARG,
-        };
-        return err;
     }
 
     if (alignment < 1) {
-        SizeResult err = {
+        return (SizeResult) {.is_valid = false, .err = ARENA_INVALID_ALIGN};
-            .is_valid = false,
-            .err = ARENA_INVALID_ALIGN,
-        };
-        return err;
     }
 
     uintptr_t current_address = (uintptr_t) (arena->buffer + arena->offset);
     uintptr_t aligned = ((current_address + (alignment - 1)) & ~(alignment - 1));
-    SizeResult val = {
+
-        .is_valid = true,
+    return (SizeResult) {.is_valid = true, .err = aligned - current_address};
-        .val = aligned - current_address,
-    };
-    return val;
 }
 
 bool mul_size_t_safe(size_t a, size_t b, size_t *out) {