error.c

#include <kiba/core/error.h>
 
#include <kiba/core/memory.h>
 
#define KB_MAX_ERRORS     8
#define KB_MAX_ERROR_DATA KB_KILOBYTE(KB_MAX_ERRORS)
 
// TODO this would be threadlocal
usize    next_error_idx                = 0;
kb_error error_chain[KB_MAX_ERRORS]    = {0};
usize    next_data_idx                 = 0;
u8       error_data[KB_MAX_ERROR_DATA] = {0};
 
void kb_errors_reset(void) {
    next_error_idx = 0;
    memory_zero(error_data, next_data_idx);
    next_data_idx  = 0;
}
 
void kb_errors_new(enum kb_error_code code, const char *file, const char *function, i32 line) {
    kb_errors_reset();
    error_chain[next_error_idx++] = (kb_error){
        .code     = code,
        .file     = file,
        .function = function,
        .line     = line,
    };
}
 
void kb_errors_append(enum kb_error_code code, const char *file, const char *function, i32 line) {
    if (next_error_idx == KB_MAX_ERRORS) {
        KB_WARN("error chain has reached its maximum length, cannot append error");
        return;
    }
    error_chain[next_error_idx] = (kb_error){
        .code       = code,
        .file       = file,
        .function   = function,
        .line       = line,
        .data_start = next_data_idx,
        .data_end   = next_data_idx,
        .next       = next_error_idx ? error_chain + next_error_idx - 1 : KB_NULL,
    };
    ++next_error_idx;
}
 
const void *kb_error_add_data(const void *src, usize size) {
    if (!next_error_idx) {
        KB_WARN("no error to append data to, ignoring this call");
        return KB_NULL;
    }
    if (next_data_idx + size > KB_MAX_ERROR_DATA) {
        KB_WARN("data to append to error would exceed buffer, ignoring this call");
        return KB_NULL;
    }
    memory_copy(error_data + next_data_idx, src, size);
    next_error_idx += size;
    error_chain[next_error_idx - 1].data_end = next_data_idx;
    return src;
}
 
kb_error *kb_errors_last_error(void) {
    if (!next_error_idx) {
        return KB_NULL;
    }
    return error_chain + next_error_idx - 1;
}
 
// TODO could add assert for valid dst here and src above
void *kb_error_get_data(kb_error *error, void *dst, usize size) {
    if (error->data_start + size > error->data_end) {
        KB_WARN("attempted to read more data for error than was initially added");
        return KB_NULL;
    }
    memory_copy(dst, error_data + error->data_start, size);
    error->data_start += size;
    return dst;
}