cxxaux.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#ifndef __ASE_CXXAUX_HH__
#define __ASE_CXXAUX_HH__
 
#include <ase/sysconfig.h>
#include <sys/types.h>                  // uint, ssize
#include <cstdint>                      // uint64_t
#include <string>
#include <functional>
#include <vector>
#include <memory>
#include <cmath>
#include <mutex>
#include <map>
 
namespace Ase {
 
typedef uint32_t uint;                  
static_assert (sizeof (uint) == 4, "");
 
// == type aliases ==
typedef uint8_t         uint8;          
typedef uint16_t        uint16;         
typedef uint32_t        uint32;         
typedef uint64_t        uint64;         
typedef int8_t          int8;           
typedef int16_t         int16;          
typedef int32_t         int32;          
typedef int64_t         int64;          
typedef uint32_t        unichar;        
static_assert (sizeof (uint8) == 1 && sizeof (uint16) == 2 && sizeof (uint32) == 4 && sizeof (uint64) == 8, "");
static_assert (sizeof (int8)  == 1 && sizeof (int16)  == 2 && sizeof (int32)  == 4 && sizeof (int64)  == 8, "");
static_assert (sizeof (int) == 4 && sizeof (uint) == 4 && sizeof (unichar) == 4, "");
using std::void_t;
using String = std::string;               
using StringS = std::vector<String>;      
using StringPair = std::pair<std::string, std::string>;
using VoidF = std::function<void()>;
 
// == Utility Macros ==
#define ASE_CPP_STRINGIFY(s)    ASE_CPP_STRINGIFY_ (s)                  
#define ASE_CPP_STRINGIFY_(s)   #s                                      // Indirection helper, required to expand macros like __LINE__
#define ASE_CPP_PASTE2_(a,b)    a ## b                                  // Indirection helper, required to expand macros like __LINE__
#define ASE_CPP_PASTE2(a,b)     ASE_CPP_PASTE2_ (a,b)                   
#define ASE_ISLIKELY(expr)      __builtin_expect (bool (expr), 1)       
#define ASE_UNLIKELY(expr)      __builtin_expect (bool (expr), 0)       
#define ASE_ABS(a)              ((a) < 0 ? -(a) : (a))                  
#define ASE_MIN(a,b)            ((a) <= (b) ? (a) : (b))                
#define ASE_MAX(a,b)            ((a) >= (b) ? (a) : (b))                
#define ASE_CLAMP(v,mi,ma)      ((v) < (mi) ? (mi) : ((v) > (ma) ? (ma) : (v))) 
#define ASE_ARRAY_SIZE(array)   (sizeof (array) / sizeof ((array)[0]))          
#define ASE_ALIGN(size, base)   ((base) * ((size_t (size) + (base) - 1) / (base))) 
#define ASE_ALIGNMENT16(pointer) (0xf & ptrdiff_t (pointer))
#define ASE_ALIGNED16(pointer)   (!ALIGNMENT16 (pointer))
 
// Ase macro shorthands for <a href="https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html">GCC Attributes</a>.
#define ASE_ALWAYS_INLINE       __attribute__ ((__always_inline__))
#define ASE_COLD                __attribute__ ((__cold__))
#define ASE_CONST               __attribute__ ((__const__))
#define ASE_CONSTRUCTOR         __attribute__ ((constructor,used))      // gcc-3.3 also needs "used" to emit code
#define ASE_DEPRECATED          __attribute__ ((__deprecated__))
#define ASE_FORMAT(fx)          __attribute__ ((__format_arg__ (fx)))
#define ASE_HOT                 __attribute__ ((__hot__))
#define ASE_MALLOC              __attribute__ ((__malloc__))
#define ASE_MAY_ALIAS           __attribute__ ((may_alias))
#define ASE_NOINLINE            __attribute__ ((noinline))
#define ASE_NORETURN            __attribute__ ((__noreturn__))
#define ASE_NO_INSTRUMENT       __attribute__ ((__no_instrument_function__))
#define ASE_PRINTF(fx, ax)      __attribute__ ((__format__ (__printf__, fx, ax)))
#define ASE_PURE                __attribute__ ((__pure__))
#define ASE_SCANF(fx, ax)       __attribute__ ((__format__ (__scanf__, fx, ax)))
#define ASE_SENTINEL            __attribute__ ((__sentinel__))
#define ASE_UNUSED              __attribute__ ((__unused__))
#define ASE_USE_RESULT          __attribute__ ((warn_unused_result))
#define ASE_USED                __attribute__ ((__used__))
#define ASE_WEAK                __attribute__ ((__weak__))
 
#define ASE_RETURN_UNLESS(cond, ...)      do { if (ASE_UNLIKELY (!bool (cond))) return __VA_ARGS__; } while (0)
 
#define ASE_ASSERT_RETURN(expr, ...)     do { if (expr) [[likely]] break; ::Ase::assertion_failed (#expr); return __VA_ARGS__; } while (0)
 
#define ASE_ASSERT_RETURN_UNREACHED(...) do { ::Ase::assertion_failed (nullptr); return __VA_ARGS__; } while (0)
 
#define ASE_ASSERT_UNREACHED(...)        do { ::Ase::assertion_fatal (nullptr); } while (0)
 
#define ASE_ASSERT(expr)                 do { if (expr) [[likely]] break; ::Ase::assertion_fatal (#expr); } while (0)
 
#define ASE_ASSERT_WARN(expr)            do { if (expr) [[likely]] break; ::Ase::assertion_failed (#expr); } while (0)
 
#ifndef NDEBUG
#define ASE_PARANOID(expr)              do { if (expr) [[likely]] break; ::Ase::assertion_failed (#expr); } while (0)
#else
#define ASE_PARANOID(expr)              do { break; } while (expr)
#endif
 
 
#define ASE_DIE(msg)                    do { errno = 0; ::Ase::perror_die (msg); } while (0)
 
#define ASE_PERROR_DIE(msg)             do { ::Ase::perror_die (msg); } while (0)
 
#define ASE_CLASS_NON_COPYABLE(ClassName)  \
  /*copy-ctor*/ ClassName  (const ClassName&) = delete; \
  ClassName&    operator=  (const ClassName&) = delete
 
#define ASE_STRUCT_DECLS(Klass)                                  \
  struct Klass;                                                  \
  using ASE_CPP_PASTE2 (Klass, P) = ::std::shared_ptr<Klass>;   \
  using ASE_CPP_PASTE2 (Klass, S) = ::std::vector<Klass>;
 
#define ASE_CLASS_DECLS(Klass)                                  \
  class Klass;                                                  \
  using ASE_CPP_PASTE2 (Klass, W) = ::std::weak_ptr<Klass>;     \
  using ASE_CPP_PASTE2 (Klass, P) = ::std::shared_ptr<Klass>;   \
  using ASE_CPP_PASTE2 (Klass, S) = ::std::vector<ASE_CPP_PASTE2 (Klass, P)>;
 
// == Operations on flags enum classes ==
#define ASE_DEFINE_ENUM_EQUALITY(Enum)         \
  constexpr bool    operator== (Enum v, int64_t n) { return int64_t (v) == n; } \
  constexpr bool    operator== (int64_t n, Enum v) { return n == int64_t (v); } \
  constexpr bool    operator!= (Enum v, int64_t n) { return int64_t (v) != n; } \
  constexpr bool    operator!= (int64_t n, Enum v) { return n != int64_t (v); }
#define ASE_DEFINE_FLAGS_ARITHMETIC(Enum)      \
  constexpr int64_t operator>> (Enum v, int64_t n) { return int64_t (v) >> n; } \
  constexpr int64_t operator<< (Enum v, int64_t n) { return int64_t (v) << n; } \
  constexpr int64_t operator^  (Enum v, int64_t n) { return int64_t (v) ^ n; } \
  constexpr int64_t operator^  (int64_t n, Enum v) { return n ^ int64_t (v); } \
  constexpr Enum    operator^  (Enum v, Enum w)    { return Enum (int64_t (v) ^ w); } \
  constexpr int64_t operator|  (Enum v, int64_t n) { return int64_t (v) | n; } \
  constexpr int64_t operator|  (int64_t n, Enum v) { return n | int64_t (v); } \
  constexpr Enum    operator|  (Enum v, Enum w)    { return Enum (int64_t (v) | w); } \
  constexpr int64_t operator&  (Enum v, int64_t n) { return int64_t (v) & n; } \
  constexpr int64_t operator&  (int64_t n, Enum v) { return n & int64_t (v); } \
  constexpr Enum    operator&  (Enum v, Enum w)    { return Enum (int64_t (v) & w); } \
  constexpr bool    operator!  (Enum e) noexcept   { return static_cast<std::underlying_type_t<Enum>> (e) == 0; } \
  constexpr int64_t operator~  (Enum v)            { return ~int64_t (v); } \
  constexpr int64_t operator+  (Enum v)            { return +int64_t (v); } \
  constexpr int64_t operator-  (Enum v)            { return -int64_t (v); } \
  constexpr int64_t operator+  (Enum v, int64_t n) { return int64_t (v) + n; } \
  constexpr int64_t operator+  (int64_t n, Enum v) { return n + int64_t (v); } \
  constexpr int64_t operator-  (Enum v, int64_t n) { return int64_t (v) - n; } \
  constexpr int64_t operator-  (int64_t n, Enum v) { return n - int64_t (v); } \
  constexpr int64_t operator*  (Enum v, int64_t n) { return int64_t (v) * n; } \
  constexpr int64_t operator*  (int64_t n, Enum v) { return n * int64_t (v); } \
  constexpr int64_t operator/  (Enum v, int64_t n) { return int64_t (v) / n; } \
  constexpr int64_t operator/  (int64_t n, Enum v) { return n / int64_t (v); } \
  constexpr int64_t operator%  (Enum v, int64_t n) { return int64_t (v) % n; } \
  constexpr int64_t operator%  (int64_t n, Enum v) { return n % int64_t (v); } \
  constexpr Enum&   operator^= (Enum &e, int64_t n) { e = Enum (e ^ n); return e; } \
  constexpr Enum&   operator|= (Enum &e, int64_t n) { e = Enum (e | n); return e; } \
  constexpr Enum&   operator&= (Enum &e, int64_t n) { e = Enum (e & n); return e; } \
  constexpr Enum&   operator+= (Enum &e, int64_t n) { e = Enum (e + n); return e; } \
  constexpr Enum&   operator-= (Enum &e, int64_t n) { e = Enum (e - n); return e; } \
  constexpr Enum&   operator*= (Enum &e, int64_t n) { e = Enum (e * n); return e; } \
  constexpr Enum&   operator/= (Enum &e, int64_t n) { e = Enum (e / n); return e; } \
  constexpr Enum&   operator%= (Enum &e, int64_t n) { e = Enum (e % n); return e; } \
  ASE_DEFINE_ENUM_EQUALITY (Enum)
 
template<typename UInt> static inline constexpr UInt
rotr (UInt bits, uint32_t offset)
{
  const uint32_t wrapped_bits = sizeof (bits) * 8 - offset;
  return (bits >> offset) | (bits << wrapped_bits);
}
 
template<typename UInt> static inline constexpr UInt
rotl (UInt bits, uint32_t offset)
{
  const uint32_t wrapped_bits = sizeof (bits) * 8 - offset;
  return (bits << offset) | (bits >> wrapped_bits);
}
 
template<typename T> static inline constexpr T
divmod (T dividend, T divisor, T *reminderp)
{
  *reminderp = dividend % divisor; // uses single DIV or IDIV for %
  return dividend / divisor;       // and / in gcc and clang with -O1
}
 
const char* cxx_demangle (const std::type_info &typeinfo) noexcept;
std::string cxx_demangle (const char *mangled_identifier) noexcept;
 
template<class T> ASE_PURE static inline const char*
typeid_name()
{
  return cxx_demangle (typeid (T));
}
 
template<class T> ASE_PURE static inline const char*
typeid_name (T &obj)
{
  return cxx_demangle (typeid (obj));
}
 
template<typename T> static T*
unalias_ptr (T *ptr)
{
  asm ("" : "+r" (ptr));        // accept ptr and yield ptr
  return ptr;
}
 
struct VirtualBase {
protected:
  virtual ~VirtualBase() noexcept = 0;
};
using VirtualBaseP = std::shared_ptr<VirtualBase>;
 
void perror_die (const std::string &msg) noexcept ASE_NORETURN;
void assertion_failed (const char *msg = nullptr, const char *file = __builtin_FILE(),
                       int line = __builtin_LINE(), const char *func = __builtin_FUNCTION()) noexcept;
void assertion_fatal  (const char *msg = nullptr, const char *file = __builtin_FILE(),
                       int line = __builtin_LINE(), const char *func = __builtin_FUNCTION()) noexcept ASE_NORETURN;
 
void ase_rethrow (std::exception_ptr exception = std::current_exception());
 
extern inline constexpr bool
constexpr_equals (const char *a, const char *b, size_t n)
{
  return n == 0 || (a[0] == b[0] && (a[0] == 0 || constexpr_equals (a + 1, b + 1, n - 1)));
}
 
template<class Type, class ...Ts> ASE_ALWAYS_INLINE inline void
new_inplace (Type &typemem, Ts &&... args)
{
  new (&typemem) Type (std::forward<Ts> (args)...);
}
 
template<class Type> ASE_ALWAYS_INLINE inline void
delete_inplace (Type &typemem)
{
  typemem.~Type();
}
 
template<class T> void
call_delete (T *o)
{
  delete o; // automatically handles nullptr
}
 
template<bool value> using REQUIRES = typename ::std::enable_if<value, bool>::type;
 
template<bool value> using REQUIRESv = typename ::std::enable_if<value, void>::type;
 
#define ASE_DEFINE_MAKE_SHARED(CLASS)                                   \
  struct MakeSharedAllocator_ : std::allocator<CLASS> {                 \
    template<typename ...Args>                                          \
    static void construct (CLASS *p, Args &&...args)                    \
    { ::new (p) CLASS (std::forward<Args> (args)...); }                 \
    static void destroy (CLASS *p)                                      \
    { p->~CLASS (); }                                                   \
    template<typename U> struct rebind {                                \
      using other =                                                     \
        std::conditional_t<std::is_same<U, CLASS>::value,               \
                           MakeSharedAllocator_, std::allocator<U>>;    \
    };                                                                  \
  };                                                                    \
  template<typename ...Args> static std::shared_ptr<CLASS>              \
  make_shared (Args &&...args)                                          \
  {                                                                     \
    return std::allocate_shared<CLASS> (MakeSharedAllocator_(),         \
                                        std::forward<Args> (args)...);  \
  }
 
template<class Target, class Source> std::shared_ptr<typename std::remove_pointer<Target>::type>
shared_ptr_cast (Source *object)
{
  if (!object)
    return nullptr;
  // construct shared_ptr if possible
  typedef decltype (object->shared_from_this()) ObjectP;
  ObjectP sptr;
  if (std::is_pointer<Target>::value)
    try {
      sptr = object->shared_from_this();
    } catch (const std::bad_weak_ptr&) {
      return nullptr;
    }
  else // for non-pointers, allow bad_weak_ptr exceptions
    sptr = object->shared_from_this();
  // cast into target shared_ptr<> type
  return std::dynamic_pointer_cast<typename std::remove_pointer<Target>::type> (sptr);
}
template<class Target, class Source> const std::shared_ptr<typename std::remove_pointer<Target>::type>
shared_ptr_cast (const Source *object)
{
  return shared_ptr_cast<Target> (const_cast<Source*> (object));
}
template<class Target, class Source> std::shared_ptr<typename std::remove_pointer<Target>::type>
shared_ptr_cast (std::shared_ptr<Source> &sptr)
{
  return std::dynamic_pointer_cast<typename std::remove_pointer<Target>::type> (sptr);
}
template<class Target, class Source> const std::shared_ptr<typename std::remove_pointer<Target>::type>
shared_ptr_cast (const std::shared_ptr<Source> &sptr)
{
  return shared_ptr_cast<Target> (const_cast<std::shared_ptr<Source>&> (sptr));
}
 
template<class Source> std::shared_ptr<typename std::remove_pointer<Source>::type>
shared_ptr_from (Source *object)
{
  // ultimately calls shared_from_this()
  return shared_ptr_cast<Source> (object);
}
 
template<class C> std::shared_ptr<C>
weak_ptr_fetch_or_create (std::weak_ptr<C> &wptr, const std::function<std::shared_ptr<C>()> &ctor)
{
  std::shared_ptr<C> cptr = wptr.lock();
  if (__builtin_expect (!!cptr, true))
    return cptr; // fast path
  std::shared_ptr<C> nptr = ctor();
  { // C++20 has: std::atomic<std::weak_ptr<C>>::compare_exchange
    static std::mutex mutex;
    std::lock_guard<std::mutex> locker (mutex);
    cptr = wptr.lock();
    if (!cptr)
      wptr = cptr = nptr;
  }
  return cptr;
}
 
template<class Class>
class Persistent final {
  static_assert (std::is_class<Class>::value, "Persistent<Class> requires class template argument");
  uint64 mem_[(sizeof (Class) + sizeof (uint64) - 1) / sizeof (uint64)] = { 0, };
  Class *ptr_ = nullptr;
  void
  initialize() ASE_NOINLINE
  {
    static std::mutex mtx;
    std::unique_lock<std::mutex> lock (mtx);
    if (ptr_ == nullptr)
      ptr_ = new (mem_) Class(); // exclusive construction
  }
public:
  constexpr Persistent    () noexcept {}
  explicit  operator bool () const ASE_PURE  { return ptr_ != nullptr; }
  Class&    operator*     () ASE_PURE        { return *operator->(); }
  Class*    operator->    () ASE_PURE
  {
    if (ASE_UNLIKELY (ptr_ == nullptr))
      initialize();
    return ptr_;
  }
};
 
struct Id32 {
  template<typename T,
           REQUIRES< (sizeof (T) <= 4 && (std::is_integral<T>::value || std::is_enum<T>::value)) > = true>
  constexpr
  Id32 (T eid) :
    id (uint32_t (eid))
  {}
  operator    uint32_t   () const noexcept              { return id; }
  bool        operator== (int64_t i) const noexcept     { return id == i; }
  bool        operator!= (int64_t i) const noexcept     { return id != i; }
  friend bool operator== (int64_t i, const Id32 &id)    { return id.operator== (i); }
  friend bool operator!= (int64_t i, const Id32 &id)    { return id.operator!= (i); }
  uint32_t    id;
};
 
} // Ase
 
#endif // __ASE_CXXAUX_HH__