error.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <exception>
#include <string>
#include <unordered_map>
 
#ifdef TCALC_USE_TL_EXPECTED
#include <tl/expected.hpp>
#define _TCALC_EXPECTED_NS tl
#else
#include <expected>
#define _TCALC_EXPECTED_NS std
#endif
 
#include "tcalc/common.hpp"
 
#define ret_err(expr)                                                          \
  if (auto res = (expr); !res.has_value()) {                                   \
    return _TCALC_EXPECTED_NS::unexpected(res.error());                        \
  }
 
#define unwrap_err(expr)                                                       \
  ({                                                                           \
    auto _ret = (expr);                                                        \
    if (!_ret.has_value()) {                                                   \
      return _TCALC_EXPECTED_NS::unexpected(_ret.error());                     \
    }                                                                          \
    _ret.value();                                                              \
  })
 
#define log_err(expr)                                                          \
  {                                                                            \
    auto _ret = (expr);                                                        \
    if (!_ret.has_value()) {                                                   \
      _ret.error().log();                                                      \
    }                                                                          \
  }
 
#define log_err_exit(expr)                                                     \
  {                                                                            \
    auto _ret = (expr);                                                        \
    if (!_ret.has_value()) {                                                   \
      _ret.error().log();                                                      \
      std::exit(EXIT_FAILURE);                                                 \
    }                                                                          \
  }
 
namespace tcalc::error {
 
enum class Code : uint8_t
{
  SYNTAX_ERROR,    
  UNDEFINED_VAR,   
  UNDEFINED_FUNC,  
  MISMATCHED_ARGS, 
  ZERO_DIVISION,   
  RECURSION_LIMIT, 
  FILE_NOT_FOUND,  
};
 
inline const std::unordered_map<Code, std::string> CODE_NAMES = {
  { Code::SYNTAX_ERROR, "SYNAX_ERROR" },
  { Code::UNDEFINED_VAR, "UNDEFINED_VAR" },
  { Code::UNDEFINED_FUNC, "UNDEFINED_FUNC" },
  { Code::MISMATCHED_ARGS, "MISMATCHED_ARGS" },
  { Code::ZERO_DIVISION, "ZERO_DIVISION" },
  { Code::RECURSION_LIMIT, "RECURSION_LIMIT" },
  { Code::FILE_NOT_FOUND, "FILE_NOT_FOUND" },
}; 
class TCALC_PUBLIC Error : public std::exception
{
public:
  constexpr static std::size_t MAX_MSG_LEN = 256; 
private:
  Code _code;
  std::string _msg;
 
public:
  Error(Code code, std::string msg) noexcept
    : _code{ code }
    , _msg{ std::move(msg) }
  {
  }
 
  [[nodiscard]] TCALC_INLINE auto code() const noexcept { return _code; }
 
  [[nodiscard]] TCALC_INLINE const auto& msg() const noexcept { return _msg; }
 
  void log() const noexcept;
 
  [[nodiscard]] const char* what() const noexcept override
  {
    return _msg.c_str();
  }
};
 
template<typename T>
using Result = _TCALC_EXPECTED_NS::expected<T, Error>;
 
TCALC_INLINE auto
err(Code code, const std::string& message) noexcept
{
  return _TCALC_EXPECTED_NS::unexpected(Error(code, message));
}
 
TCALC_INLINE auto
raw_err(Code code) noexcept
{
  auto errno_copy = errno;
  return Error(code,
               errno_copy == 0 ? "Unknown error" : std::strerror(errno_copy));
}
 
TCALC_INLINE auto
err(Code code) noexcept
{
  return _TCALC_EXPECTED_NS::unexpected(raw_err(code));
}
 
TCALC_PRINTF_FORMAT(2, 3)
_TCALC_EXPECTED_NS::unexpected<Error>
err(Code code, const char* fmt, ...) noexcept;
 
template<typename T, typename... Args>
TCALC_INLINE auto
ok(Args&&... args) noexcept
{
  return _TCALC_EXPECTED_NS::expected<T, Error>(T(std::forward<Args>(args)...));
}
 
template<>
TCALC_INLINE auto
ok<void>() noexcept
{
  return _TCALC_EXPECTED_NS::expected<void, Error>();
}
 
}