Utility.cpp 3.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122
  1. #include "utils/Utility.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. static Core::ErrorHandler errorHandler = nullptr;
  6. static void* errorData = nullptr;
  7. static Core::ExitHandler exitHandler = nullptr;
  8. static void* exitData = nullptr;
  9. bool Core::handleError(const char* file, int line, Error e, bool check) {
  10. if(check && errorHandler != nullptr) {
  11. errorHandler(file, line, e, errorData);
  12. }
  13. return check;
  14. }
  15. void Core::setErrorHandler(ErrorHandler eh, void* data) {
  16. errorHandler = eh;
  17. errorData = data;
  18. }
  19. void* operator new(size_t bytes) noexcept {
  20. return malloc(bytes);
  21. }
  22. void* operator new[](size_t bytes) noexcept {
  23. return malloc(bytes);
  24. }
  25. void operator delete(void* p) noexcept {
  26. free(p);
  27. }
  28. void operator delete[](void* p) noexcept {
  29. free(p);
  30. }
  31. void operator delete(void* p, size_t bytes) noexcept {
  32. (void)bytes;
  33. free(p);
  34. }
  35. void operator delete[](void* p, size_t bytes) noexcept {
  36. (void)bytes;
  37. free(p);
  38. }
  39. void* operator new(size_t bytes, void* p) noexcept {
  40. (void)bytes;
  41. return p;
  42. }
  43. /*void* operator new[](size_t bytes, void* p) noexcept {
  44. (void)bytes;
  45. return p;
  46. }*/
  47. void Core::exitWithHandler(const char* file, int line, int value) {
  48. printf("\33[1;31mExit from %s:%d\33[39;49m\n", file, line);
  49. if(exitHandler != nullptr) {
  50. exitHandler(value, exitData);
  51. }
  52. exit(value);
  53. }
  54. void Core::setExitHandler(ExitHandler eh, void* data) {
  55. exitHandler = eh;
  56. exitData = data;
  57. }
  58. #define CORE_TO_STRING(type, cast, format) \
  59. check_return bool Core::toString(type t, char* buffer, int size) { \
  60. if(size < 0) { \
  61. return CORE_ERROR(Error::NEGATIVE_ARGUMENT); \
  62. } \
  63. return CORE_ERROR(Error::CAPACITY_REACHED, \
  64. snprintf(buffer, static_cast<unsigned int>(size), \
  65. format, static_cast<cast>(t)) >= size); \
  66. }
  67. CORE_TO_STRING(signed short, signed short, "%hd")
  68. CORE_TO_STRING(unsigned short, unsigned short, "%hu")
  69. CORE_TO_STRING(signed int, signed int, "%d")
  70. CORE_TO_STRING(unsigned int, unsigned int, "%u")
  71. CORE_TO_STRING(signed long, signed long, "%ld")
  72. CORE_TO_STRING(unsigned long, unsigned long, "%lu")
  73. CORE_TO_STRING(signed long long, signed long long, "%lld")
  74. CORE_TO_STRING(unsigned long long, unsigned long long, "%llu")
  75. CORE_TO_STRING(float, double, "%.2f")
  76. CORE_TO_STRING(double, double, "%.2lf")
  77. CORE_TO_STRING(long double, long double, "%.2Lf")
  78. bool Core::putChar(int c) {
  79. return CORE_ERROR(Error::BLOCKED_STDOUT, putchar(c) == EOF);
  80. }
  81. void Core::memorySet(void* p, int c, int n) {
  82. if(n <= 0) {
  83. return;
  84. }
  85. memset(p, c, static_cast<unsigned int>(n));
  86. }
  87. void Core::memoryCopy(void* dest, const void* src, int n) {
  88. if(n < 0) {
  89. return;
  90. }
  91. memcpy(dest, src, static_cast<unsigned int>(n));
  92. }
  93. const char* Core::getFileName(const char* path) {
  94. int end = 0;
  95. while(path[end] != '\0') {
  96. end++;
  97. }
  98. while(end > 0 && path[end - 1] != '/') {
  99. end--;
  100. }
  101. return path + end;
  102. }