core/mtcore/core.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/


 
#pragma once
 
#ifndef MTCORE_CORE_HPP
#define MTCORE_CORE_HPP
 
#include <cerrno>
#ifndef MTCORE_NO_STACKTRACE
#include <cpptrace/cpptrace.hpp>
#endif
 
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
 
#if defined __linux__ || defined __EMSCRIPTEN__
using Environ = char **;
#else
using Environ = const char **;
#endif
 
// NOLINTBEGIN
typedef float f32;
typedef double f64;
typedef long double f80;
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef uintptr_t uptr;
typedef wchar_t wchar;
 
#ifndef EXIT_MAX
#define EXIT_MAX 255
#endif
 
#ifndef EXIT_ABORT
#define EXIT_ABORT EXIT_MAX
#endif
 
typedef int ThreeWayCompare;
// NOLINTEND
 
#ifndef mt_print_cur_stacktrace
#ifndef MTCORE_NO_STACKTRACE
#define mt_print_cur_stacktrace(...)                                                                                   \
  (void) fprintf(stderr, __VA_ARGS__);                                                                                 \
  (void) fflush(stderr);                                                                                               \
  cpptrace::stacktrace::current(1).print(std::cerr);
#else
#define mt_print_cur_stacktrace(...)                                                                                   \
  (void) fprintf(stderr, __VA_ARGS__);                                                                                 \
  (void) fflush(stderr);
#endif
#endif
 
#ifndef mt_print_stacktrace
#ifndef MTCORE_NO_STACKTRACE
#define mt_print_stacktrace(TRACE, ...)                                                                                \
  (void) fprintf(stderr, __VA_ARGS__);                                                                                 \
  (void) fflush(stderr);                                                                                               \
  (TRACE).print(std::cerr);
#else
#define mt_print_stacktrace(TRACE, ...)                                                                                \
  (void) fprintf(stderr, __VA_ARGS__);                                                                                 \
  (void) fflush(stderr);
#endif
#endif
 
#ifndef NDEBUG
#define not_implemented() unreachable("NOT IMPLEMENTED")
#else
#define not_implemented()                                                                                              \
  unreachable("NOT IMPLEMENTED");                                                                                      \
  static_assert(false, "CODE NOT IMPLEMENTED");
#endif
 
#ifndef print_debug
#ifndef NDEBUG
#define print_debug(fmt, ...) (void) fprintf(stderr, "\nDEBUG AT %s:%d! " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
#else
#define print_debug(fmt, ...)
#endif
#endif

#define ensure(check, ...)                                                                                             \
  if (!(check)) {                                                                                                      \
    mt_print_cur_stacktrace("\nCONDITION FAILED!\n\t"                                                                  \
                            "CONDITION: %s\n\t"                                                                        \
                            "MESSAGE: %s\n\t"                                                                          \
                            "WHERE: %s:%d\n\t"                                                                         \
                            "ERRNO: "                                                                                  \
                            "%d\n\tERRNO DESC: %s\n",                                                                  \
                            #check, #__VA_ARGS__, __FILE__, __LINE__, errno, strerror(errno));                         \
    abort();                                                                                                           \
  }
 
#if defined(_MSC_VER) && !defined(__clang__)  // MSVC
#define unreachable(...)                                                                                               \
  mt_print_cur_stacktrace("\n\nUNREACHABLE!\n\t"                                                                       \
                          "MESSAGE: %s\n\t"                                                                            \
                          "WHERE: %s:%d\n\t"                                                                           \
                          "ERRNO: "                                                                                    \
                          "%d\n\tERRNO DESC: %s\n",                                                                    \
                          #__VA_ARGS__, __FILE__, __LINE__, errno, strerror(errno));                                   \
  __assume(false);                                                                                                     \
  abort();
#else  // GCC, Clang
#define unreachable(...)                                                                                               \
  mt_print_cur_stacktrace("\nUNREACHABLE!\n\t"                                                                         \
                          "MESSAGE: %s\n\t"                                                                            \
                          "WHERE: %s:%d\n\t"                                                                           \
                          "ERRNO: "                                                                                    \
                          "%d\n\tERRNO DESC: %s\n",                                                                    \
                          #__VA_ARGS__, __FILE__, __LINE__, errno, strerror(errno));                                   \
  __builtin_unreachable();                                                                                             \
  abort();
#endif
 
#ifndef NDEBUG
#define mtcore_warn_trace(...)                                                                                         \
  mt_print_cur_stacktrace("\nWARNING!\n\t"                                                                             \
                          "MESSAGE: %s\n\t"                                                                            \
                          "WHERE: %s:%d\n",                                                                            \
                          #__VA_ARGS__, __FILE__, __LINE__);

#define mtcore_warn(...)                                                                                               \
  fprintf(stderr,                                                                                                      \
          "\nWARNING!\n\t"                                                                                             \
          "MESSAGE: %s\n\t"                                                                                            \
          "WHERE: %s:%d\n",                                                                                            \
          #__VA_ARGS__, __FILE__, __LINE__);                                                                           \
  (void) fflush(stderr);
#else
#define mtcore_warn(...)
#define mtcore_warn_trace(...)
#endif
 
namespace mtcore {
  enum class CollectionAddNoAllocationError {
    NO_ROOM,
  };

  template<typename... Ts>
  struct overload : Ts... {
    using Ts::operator()...;
  };
 
  template<class... Ts>
  overload(Ts...) -> overload<Ts...>;
 
  namespace defer_impl {
    // Struct that will be used for operator overloading
    // we're using our own struct so that we don't have to worry about overloading
    // collisions with other code
    struct DeferrerBuilder {};
 
    // The deferrer struct uses RAII to delay calling a callable
    // We intentionally don't define any custom constructors or make them explicit
    template<class F>
    struct Deferrer {
      F f;
 
      ~Deferrer() { f(); }
    };
 
    // We define a custom operator that takes a builder type and our function
    // callable type so we can generate a deferrable
    //  without the use of parenthesis
    // When we combine this with our macro, we will be able to create a block of
    // code which turns into a deferred lambda
    template<class F>
    Deferrer<F> operator+(DeferrerBuilder, F f) {
      return {f};
    }
  }  // namespace defer_impl
 
#define DEFER_(LINE) zz_defer##LINE
#define DEFER(LINE)  DEFER_(LINE)
 
  // NOLINTBEGIN
#define mtdefer auto DEFER(__LINE__) = mtcore::defer_impl::DeferrerBuilder{} + [&]()
  // NOLINTEND
}  // namespace mtcore
 
#endif  // MTCORE_CORE_HPP