core/utils/Utility.cpp

#include "utils/Utility.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static Core::ErrorHandler errorHandler = nullptr;
static void* errorData = nullptr;
static Core::ExitHandler exitHandler = nullptr;
static void* exitData = nullptr;

bool Core::handleError(const char* file, int line, Error e, bool check) {
    if(check && errorHandler != nullptr) {
        errorHandler(file, line, e, errorData);
    }
    return check;
}

void Core::setErrorHandler(ErrorHandler eh, void* data) {
    errorHandler = eh;
    errorData = data;
}

void* operator new(size_t bytes) noexcept {
    return malloc(bytes);
}

void* operator new[](size_t bytes) noexcept {
    return malloc(bytes);
}

void operator delete(void* p) noexcept {
    free(p);
}

void operator delete[](void* p) noexcept {
    free(p);
}

void operator delete(void* p, size_t bytes) noexcept {
    (void)bytes;
    free(p);
}

void operator delete[](void* p, size_t bytes) noexcept {
    (void)bytes;
    free(p);
}

void* operator new(size_t bytes, void* p) noexcept {
    (void)bytes;
    return p;
}

/*void* operator new[](size_t bytes, void* p) noexcept {
    (void)bytes;
    return p;
}*/

void Core::exitWithHandler(const char* file, int line, int value) {
    printf("\33[1;31mExit from %s:%d\33[39;49m\n", file, line);
    if(exitHandler != nullptr) {
        exitHandler(value, exitData);
    }
    exit(value);
}

void Core::setExitHandler(ExitHandler eh, void* data) {
    exitHandler = eh;
    exitData = data;
}

#define CORE_TO_STRING(type, cast, format)                                     \
    check_return bool Core::toString(type t, char* buffer, int size) {         \
        if(size < 0) {                                                         \
            return CORE_ERROR(Error::NEGATIVE_ARGUMENT);                       \
        }                                                                      \
        return CORE_ERROR(Error::CAPACITY_REACHED,                             \
                          snprintf(buffer, static_cast<unsigned int>(size),    \
                                   format, static_cast<cast>(t)) >= size);     \
    }

CORE_TO_STRING(signed short, signed short, "%hd")
CORE_TO_STRING(unsigned short, unsigned short, "%hu")
CORE_TO_STRING(signed int, signed int, "%d")
CORE_TO_STRING(unsigned int, unsigned int, "%u")
CORE_TO_STRING(signed long, signed long, "%ld")
CORE_TO_STRING(unsigned long, unsigned long, "%lu")
CORE_TO_STRING(signed long long, signed long long, "%lld")
CORE_TO_STRING(unsigned long long, unsigned long long, "%llu")
CORE_TO_STRING(float, double, "%.2f")
CORE_TO_STRING(double, double, "%.2lf")
CORE_TO_STRING(long double, long double, "%.2Lf")

bool Core::putChar(int c) {
    return CORE_ERROR(Error::BLOCKED_STDOUT, putchar(c) == EOF);
}

void Core::memorySet(void* p, int c, int n) {
    if(n <= 0) {
        return;
    }
    memset(p, c, static_cast<unsigned int>(n));
}

void Core::memoryCopy(void* dest, const void* src, int n) {
    if(n < 0) {
        return;
    }
    memcpy(dest, src, static_cast<unsigned int>(n));
}

const char* Core::getFileName(const char* path) {
    int end = 0;
    while(path[end] != '\0') {
        end++;
    }
    while(end > 0 && path[end - 1] != '/') {
        end--;
    }
    return path + end;
}