error.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "error.h"
#include "frontend/lexer/loc.h"
#include "util/abort.h"
#ifdef COMPILED_FROM_MAKE
    #include "termcolor.h"
#else
    #include "../libtermcolor/include/termcolor.h"
#endif
#include "enum/make.h"
 
// not sure why this redeclaration from frontend/lexer/loc.h is necessary to
// make it compile
bool ps_is_loc_none(const struct ps_loc* loc);
 
// defines to make stream writing easier.
#define _PRINTF(...) tcol_fprintf(stream, __VA_ARGS__)
#define _PRINTF_FST(...) fprintf(stream, __VA_ARGS__)
// #define _PRINTF(...) (printer->stream, __VA_ARGS__)
#define _PUTCHR(__c) fputc(__c, stream)
 
static STR error_scope_strs[] = {
#define ENUM TO_STRING
#include "error_scope.h"
#undef ENUM
};
static STR error_scope_color_strs[] = {
#define ENUM TO_STRING2
#include "error_scope.h"
#undef ENUM
};
static STR error_code_strs[] = {
#define ENUM TO_STRING
#include "error_codes.h"
#undef ENUM
};
 
static usize error_count;
 
static struct ps_error errors[PS_MAX_ERRORS];
 
// Produces the ANSI escape sequence for a given termcolor-style string.
// Inefficient but works.
static const char* ps_color(const char* tc_color) {
#define N_COLORS_STORABLE 20
#define N_ESTIMATED_MAX_COLOR_LENGTH 24
 
    // store all color strings in a ring buffer
    static char buffer[N_COLORS_STORABLE * 16];
 
    // wrap around the ring buffer to avoid writing past its end
    static usize used = 0;
    if (used + N_ESTIMATED_MAX_COLOR_LENGTH + 1 > sizeof(buffer)) {
        used = 0;
    }
 
    // parse the termcolor-style color into an ANSI color and write it as a
    // null-terminated string inot the buffer
    usize length;
    char* result = buffer + used;
    if (tcol_color_parse(result, N_ESTIMATED_MAX_COLOR_LENGTH, (char*)tc_color,
            strlen(tc_color), &length)
        != TermColorErrorNone) {
        result = NULL;
    }
    used += length + 1;
    result[length] = 0;
 
    return result;
 
#undef N_COLORS_STORABLE
#undef N_ESTIMATED_MAX_COLOR_LENGTH
}
 
void ps_error(enum ps_error_scope scope, short code, const char* file_source,
    struct ps_loc loc, usize length, const char* message, const char* explain,
    const char* fix) {
    // we only add errors if there is space
    if (error_count + 1 < PS_MAX_ERRORS) {
        // construct the error and add it to the error buffer
        struct ps_error* err = &errors[error_count++];
        err->scope = scope;
        err->code = code;
        err->file_source = file_source;
        err->loc = loc;
        err->length = file_source[err->loc.pos] == '\n' ? 0 : length;
        err->message = message;
        err->explain = explain;
        err->fix = fix;
    }
}
 
static inline void ps_fprint_error_primary(FILE* stream, struct ps_error* err) {
    if (!ps_is_loc_none(&err->loc)) {
        // write the error location
        _PRINTF("{+}%s{0}:%zu:%zu: ", err->loc.filename, err->loc.line,
            err->loc.col);
    }
    // write the error domain
    _PRINTF_FST("%s%s", err->theme, error_scope_strs[err->scope]);
    // write the error code
    if (err->code >= 0) {
        _PRINTF_FST("[%c%04d]", toupper(error_scope_strs[err->scope][0]),
            err->code);
    }
 
    // write the main message
    _PRINTF("{0}: %s\n", err->message);
}
 
static inline void ps_fprintf_error_line_prefix(FILE* stream,
    struct ps_error* err, isize line) {
    if (line == -1) {
        _PRINTF("      %s┃{0} ", err->theme);
    } else {
        _PRINTF(" %4zu %s┃{0} ", (usize)line, err->theme);
    }
}
 
static inline void ps_fprintf_error_explain(FILE* stream, struct ps_error* err,
    usize chars_before_error) {
    // we draw a smooth line underneath the region of error
    ps_fprintf_error_line_prefix(stream, err, -1);
    _PRINTF_FST("%*s%s%s", (int)chars_before_error, "", err->theme,
        err->length > 1 ? "┌" : "│");
    for (usize i = 1; i < err->length; i++) {
        _PRINTF_FST("─");
    }
    _PUTCHR('\n');
 
    // the explain message is drawn underneath this region-outlining line
    ps_fprintf_error_line_prefix(stream, err, -1);
    _PRINTF_FST("%*s%s│\n", (int)chars_before_error, "", err->theme);
    ps_fprintf_error_line_prefix(stream, err, -1);
    _PRINTF("%*s%s{0}{/}%s{0}\n", (int)chars_before_error, "", err->theme,
        err->explain);
}
 
static inline void ps_fprintf_error_fix(FILE* stream, struct ps_error* err) {
    // write it on a new line
    _PRINTF_FST("%s\n", err->fix);
}
 
static inline void ps_fprintf_error_line(FILE* stream, struct ps_error* err) {
    ps_fprintf_error_line_prefix(stream, err, err->loc.line);
 
    // find line start
    usize line_start = err->loc.pos;
    if (line_start > 0 && err->file_source[line_start] == '\n') {
        line_start--;
    }
    while (line_start > 0 && err->file_source[line_start] != '\n') {
        line_start--;
    }
    if (err->loc.line > 1 /* the first line is not prefixed with a newline */) {
        line_start++;
    }
 
    // determine the length of the line
    usize line_length = 0;
    char end_char;
    while ((end_char = err->file_source[line_start + line_length]),
        end_char != '\n' && end_char != 0) {
        line_length++;
    }
 
    // find the ranges of the line start and the error region
    usize chars_before_error = err->loc.pos - line_start;
    usize chars_after_error = line_length - (chars_before_error + err->length);
    usize start_after_error = line_start + chars_before_error + err->length;
 
    // display the line
    _PRINTF(
        "%.*s"
        "%s%.*s{0}"
        "%.*s\n",
        (int)chars_before_error, &err->file_source[line_start],
 
        err->theme, (int)err->length,
        &err->file_source[line_start + chars_before_error],
 
        (int)chars_after_error, &err->file_source[start_after_error]);
 
    // if additional messages are available, display them
    if (err->explain) {
        ps_fprintf_error_explain(stream, err, chars_before_error);
    }
    if (err->fix) {
        ps_fprintf_error_fix(stream, err);
    }
}
 
void ps_fprint_error(FILE* stream, struct ps_error* err) {
    ps_fprint_error_primary(stream, err);
    if (!ps_is_loc_none(&err->loc)) {
        ps_fprintf_error_line(stream, err);
    }
}
 
void ps_fprint_errors(FILE* stream) {
    // respect the choices and system requirements for whether colored output is
    // given
    tcol_auto_color(stream);
 
    // print all the errors to stream
    for (usize i = 0; i < error_count; i++) {
        // if (i > 0) {
        //     _PUTCHR('\n');
        // }
 
        struct ps_error* error = &errors[i];
 
        // not great
        error->theme = ps_color(error_scope_color_strs[error->scope]);
        error->theme = tcol_dyn(error->theme);
 
        ps_fprint_error(stream, error);
    }
 
    // every error we printed is now "consumed," so we start afresh
    error_count = 0;
}
 
// getters are eh but whatever
usize ps_error_count(void) {
    return error_count;
}