mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2025-12-30 18:02:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Serialize errors to make them sortable, deterministic, and generally more control

Browse Source
This commit is contained in:
gingerBill
2024-03-19 15:34:29 +00:00
parent 8ff788f4ff
commit 9a2fc6cf4c
12 changed files with 159 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
src/error.cpp
View File

@@ -1,3 +1,14 @@
enum ErrorValueKind : u32 {
ErrorValue_Error,
ErrorValue_Warning,
};
struct ErrorValue {
ErrorValueKind kind;
TokenPos pos;
Array<String> msgs;
};
struct ErrorCollector {
TokenPos prev;
std::atomic<i64> count;
@@ -8,21 +19,54 @@ struct ErrorCollector {
BlockingMutex string_mutex;
RecursiveMutex block_mutex;
RecursiveMutex error_buffer_mutex;
Array<u8> error_buffer;
Array<String> errors;
Array<ErrorValue> error_values;
ErrorValue curr_error_value;
std::atomic<bool> curr_error_value_set;
};
gb_global ErrorCollector global_error_collector;
gb_internal void push_error_value(TokenPos const &pos, ErrorValueKind kind = ErrorValue_Error) {
GB_ASSERT(global_error_collector.curr_error_value_set.load() == false);
ErrorValue ev = {kind, pos};
ev.msgs.allocator = heap_allocator();
global_error_collector.curr_error_value = ev;
global_error_collector.curr_error_value_set.store(true);
}
gb_internal void pop_error_value(void) {
if (global_error_collector.curr_error_value_set.load()) {
array_add(&global_error_collector.error_values, global_error_collector.curr_error_value);
global_error_collector.curr_error_value = {};
global_error_collector.curr_error_value_set.store(false);
}
}
gb_internal void try_pop_error_value(void) {
if (!global_error_collector.in_block.load()) {
pop_error_value();
}
}
gb_internal ErrorValue *get_error_value(void) {
GB_ASSERT(global_error_collector.curr_error_value_set.load() == true);
return &global_error_collector.curr_error_value;
}
gb_internal bool any_errors(void) {
return global_error_collector.count.load() != 0;
}
gb_internal void init_global_error_collector(void) {
array_init(&global_error_collector.errors, heap_allocator());
array_init(&global_error_collector.error_buffer, heap_allocator());
array_init(&global_error_collector.error_values, heap_allocator());
array_init(&global_file_path_strings, heap_allocator(), 1, 4096);
array_init(&global_files, heap_allocator(), 1, 4096);
}
@@ -102,6 +146,7 @@ gb_internal AstFile *thread_safe_get_ast_file_from_id(i32 index) {
gb_internal bool global_warnings_as_errors(void);
gb_internal bool global_ignore_warnings(void);
gb_internal bool show_error_line(void);
gb_internal bool terse_errors(void);
gb_internal bool has_ansi_terminal_colours(void);
gb_internal gbString get_file_line_as_string(TokenPos const &pos, i32 *offset);
@@ -113,6 +158,24 @@ gb_internal void syntax_error(Token const &token, char const *fmt, ...);
gb_internal void syntax_error(TokenPos pos, char const *fmt, ...);
gb_internal void syntax_warning(Token const &token, char const *fmt, ...);
gb_internal void compiler_error(char const *fmt, ...);
gb_internal void print_all_errors(void);
#define ERROR_OUT_PROC(name) void name(char const *fmt, va_list va)
typedef ERROR_OUT_PROC(ErrorOutProc);
gb_internal ERROR_OUT_PROC(default_error_out_va) {
char buf[4096] = {};
isize len = gb_snprintf_va(buf, gb_size_of(buf), fmt, va);
isize n = len-1;
String msg = {(u8 *)buf, n};
ErrorValue *ev = get_error_value();
array_add(&ev->msgs, copy_string(permanent_allocator(), msg));
}
gb_global ErrorOutProc *error_out_va = default_error_out_va;
gb_internal void begin_error_block(void) {
mutex_lock(&global_error_collector.block_mutex);
@@ -120,48 +183,7 @@ gb_internal void begin_error_block(void) {
}
gb_internal void end_error_block(void) {
mutex_lock(&global_error_collector.error_buffer_mutex);
isize n = global_error_collector.error_buffer.count;
if (n > 0) {
u8 *text = global_error_collector.error_buffer.data;
bool add_extra_newline = false;
if (show_error_line()) {
if (n >= 2 && !(text[n-2] == '\n' && text[n-1] == '\n')) {
add_extra_newline = true;
}
} else {
isize newline_count = 0;
for (isize i = 0; i < n; i++) {
if (text[i] == '\n') {
newline_count += 1;
}
}
if (newline_count > 1) {
add_extra_newline = true;
}
}
if (add_extra_newline) {
// add an extra new line as padding when the error line is being shown
error_line("\n");
}
n = global_error_collector.error_buffer.count;
text = gb_alloc_array(permanent_allocator(), u8, n+1);
gb_memmove(text, global_error_collector.error_buffer.data, n);
text[n] = 0;
mutex_lock(&global_error_collector.error_out_mutex);
String s = {text, n};
array_add(&global_error_collector.errors, s);
mutex_unlock(&global_error_collector.error_out_mutex);
global_error_collector.error_buffer.count = 0;
}
mutex_unlock(&global_error_collector.error_buffer_mutex);
pop_error_value();
global_error_collector.in_block.store(false);
mutex_unlock(&global_error_collector.block_mutex);
}
@@ -169,40 +191,6 @@ gb_internal void end_error_block(void) {
#define ERROR_BLOCK() begin_error_block(); defer (end_error_block())
#define ERROR_OUT_PROC(name) void name(char const *fmt, va_list va)
typedef ERROR_OUT_PROC(ErrorOutProc);
gb_internal ERROR_OUT_PROC(default_error_out_va) {
gbFile *f = gb_file_get_standard(gbFileStandard_Error);
char buf[4096] = {};
isize len = gb_snprintf_va(buf, gb_size_of(buf), fmt, va);
isize n = len-1;
if (global_error_collector.in_block) {
mutex_lock(&global_error_collector.error_buffer_mutex);
isize cap = global_error_collector.error_buffer.count + n;
array_reserve(&global_error_collector.error_buffer, cap);
u8 *data = global_error_collector.error_buffer.data + global_error_collector.error_buffer.count;
gb_memmove(data, buf, n);
global_error_collector.error_buffer.count += n;
mutex_unlock(&global_error_collector.error_buffer_mutex);
} else {
mutex_lock(&global_error_collector.error_out_mutex);
{
u8 *text = gb_alloc_array(permanent_allocator(), u8, n+1);
gb_memmove(text, buf, n);
text[n] = 0;
array_add(&global_error_collector.errors, make_string(text, n));
}
mutex_unlock(&global_error_collector.error_out_mutex);
}
gb_file_write(f, buf, n);
}
gb_global ErrorOutProc *error_out_va = default_error_out_va;
gb_internal void error_out(char const *fmt, ...) {
va_list va;
@@ -357,9 +345,12 @@ gb_internal void error_out_coloured(char const *str, TerminalStyle style, Termin
gb_internal void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
global_error_collector.count.fetch_add(1);
if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
print_all_errors();
gb_exit(1);
}
mutex_lock(&global_error_collector.mutex);
push_error_value(pos, ErrorValue_Error);
// NOTE(bill): Duplicate error, skip it
if (pos.line == 0) {
error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -377,6 +368,7 @@ gb_internal void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va
} else {
global_error_collector.count.fetch_sub(1);
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
@@ -387,6 +379,9 @@ gb_internal void warning_va(TokenPos const &pos, TokenPos end, char const *fmt,
}
global_error_collector.warning_count.fetch_add(1);
mutex_lock(&global_error_collector.mutex);
push_error_value(pos, ErrorValue_Warning);
if (!global_ignore_warnings()) {
// NOTE(bill): Duplicate error, skip it
if (pos.line == 0) {
@@ -402,6 +397,7 @@ gb_internal void warning_va(TokenPos const &pos, TokenPos end, char const *fmt,
show_error_on_line(pos, end);
}
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
@@ -413,9 +409,13 @@ gb_internal void error_line_va(char const *fmt, va_list va) {
gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) {
global_error_collector.count.fetch_add(1);
if (global_error_collector.count.load() > MAX_ERROR_COLLECTOR_COUNT()) {
print_all_errors();
gb_exit(1);
}
mutex_lock(&global_error_collector.mutex);
push_error_value(pos, ErrorValue_Error);
// NOTE(bill): Duplicate error, skip it
if (pos.line == 0) {
error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -428,6 +428,8 @@ gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_li
}
error_out_va(fmt, va);
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
@@ -435,9 +437,13 @@ gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_li
gb_internal void syntax_error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
global_error_collector.count.fetch_add(1);
if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
print_all_errors();
gb_exit(1);
}
mutex_lock(&global_error_collector.mutex);
push_error_value(pos, ErrorValue_Warning);
// NOTE(bill): Duplicate error, skip it
if (global_error_collector.prev != pos) {
global_error_collector.prev = pos;
@@ -451,15 +457,21 @@ gb_internal void syntax_error_va(TokenPos const &pos, TokenPos end, char const *
error_out_va(fmt, va);
error_out("\n");
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
gb_internal void syntax_error_with_verbose_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
global_error_collector.count.fetch_add(1);
if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
print_all_errors();
gb_exit(1);
}
mutex_lock(&global_error_collector.mutex);
push_error_value(pos, ErrorValue_Warning);
// NOTE(bill): Duplicate error, skip it
if (pos.line == 0) {
error_out_coloured("Syntax_Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -475,6 +487,8 @@ gb_internal void syntax_error_with_verbose_va(TokenPos const &pos, TokenPos end,
error_out("\n");
show_error_on_line(pos, end);
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
@@ -486,6 +500,10 @@ gb_internal void syntax_warning_va(TokenPos const &pos, TokenPos end, char const
}
mutex_lock(&global_error_collector.mutex);
global_error_collector.warning_count++;
push_error_value(pos, ErrorValue_Warning);
if (!global_ignore_warnings()) {
// NOTE(bill): Duplicate error, skip it
if (global_error_collector.prev != pos) {
@@ -501,6 +519,8 @@ gb_internal void syntax_warning_va(TokenPos const &pos, TokenPos end, char const
error_out("\n");
}
}
try_pop_error_value();
mutex_unlock(&global_error_collector.mutex);
}
@@ -568,6 +588,8 @@ gb_internal void syntax_error_with_verbose(TokenPos pos, TokenPos end, char cons
gb_internal void compiler_error(char const *fmt, ...) {
print_all_errors();
va_list va;
va_start(va, fmt);
@@ -577,3 +599,34 @@ gb_internal void compiler_error(char const *fmt, ...) {
GB_DEBUG_TRAP();
gb_exit(1);
}
gb_internal int error_value_cmp(void const *a, void const *b) {
ErrorValue *x = cast(ErrorValue *)a;
ErrorValue *y = cast(ErrorValue *)b;
return token_pos_cmp(x->pos, y->pos);
}
gb_internal void print_all_errors(void) {
GB_ASSERT(any_errors());
gbFile *f = gb_file_get_standard(gbFileStandard_Error);
array_sort(global_error_collector.error_values, error_value_cmp);
for_array(i, global_error_collector.error_values) {
ErrorValue ev = global_error_collector.error_values[i];
for_array(j, ev.msgs) {
String msg = ev.msgs[j];
gb_file_write(f, msg.text, msg.len);
if (terse_errors()) {
if (string_contains_char(msg, '\n')) {
break;
}
}
}
}
}