error.h

#pragma once
#include "tool/ioprint.h"
#include "tool/iotext.h"
#include <stdexcept>
 
namespace tinker {
 
template <class T>
std::string translateErrorCode(T errcode);    
void printError();                            
void printBacktrace(std::FILE* out = stderr); 
 
class FatalError : public std::exception
{
private:
   std::string m_msg;
 
public:
   FatalError(const char* msg)
      : m_msg(msg)
   {}
   FatalError(const std::string& msg)
      : m_msg(msg)
   {}
   FatalError(const FatalError& e)
      : m_msg(e.m_msg)
   {}
   const char* what() const noexcept override
   {
      return m_msg.c_str();
   }
};
 
#define TINKER_THROW(msg)                                              \
   do {                                                                \
      printBacktrace();                                                \
      std::string ms_ = msg;                                           \
      std::string m_ = format("%s at %s:%d", ms_, __FILE__, __LINE__); \
      throw FatalError(m_);                                            \
   } while (0)
 
#define TINKER_ALWAYS_CHECK_RT_1_(call)                                            \
   do {                                                                            \
      auto res_ = call;                                                            \
      if (res_ != 0) {                                                             \
         printBacktrace();                                                         \
         std::string m_;                                                           \
         std::string msg_ = translateErrorCode(res_);                              \
         if (msg_ != "")                                                           \
            m_ = format("Errno %d (%s) at %s:%d", res_, msg_, __FILE__, __LINE__); \
         else                                                                      \
            m_ = format("Errno %d at %s:%d", res_, __FILE__, __LINE__);            \
         throw FatalError(m_);                                                     \
      }                                                                            \
   } while (0)
#define TINKER_ALWAYS_CHECK_RT_(...) TINKER_GET_2ND_ARG(__VA_ARGS__, TINKER_ALWAYS_CHECK_RT_1_)
 
#ifndef TINKER_ALWAYS_CHECK_RT
#define TINKER_ALWAYS_CHECK_RT 0
#endif
 
#if TINKER_DEBUG || TINKER_ALWAYS_CHECK_RT
#define check_rt(...) TINKER_ALWAYS_CHECK_RT_(__VA_ARGS__)(__VA_ARGS__)
#else
#define check_rt(call, ...) call
#endif
 
#define always_check_rt(...) TINKER_ALWAYS_CHECK_RT_(__VA_ARGS__)(__VA_ARGS__)
 
}