@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/math/bswap.hpp

@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * tlx/math/bswap.hpp
+ *
+ * bswap16(), bswap32(), and bswap64() to swap bytes - mainly for portability.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_BSWAP_HEADER
+#define TLX_MATH_BSWAP_HEADER
+
+#include <cstdint>
+
+#ifdef _MSC_VER
+#include <cstdlib>
+#endif
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// bswap16() - swap 16-bit integers
+
+//! bswap16 - generic implementation
+static inline std::uint16_t bswap16_generic(const std::uint16_t& x)
+{
+    return ((x >> 8) & 0x00FFUL) | ((x << 8) & 0xFF00UL);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+
+//! bswap16 - gcc/clang intrinsic
+static inline std::uint16_t bswap16(const std::uint16_t& v)
+{
+    return __builtin_bswap16(v);
+}
+
+#elif defined(_MSC_VER)
+
+//! bswap16 - MSVC intrinsic
+static inline std::uint16_t bswap16(const std::uint16_t& v)
+{
+    return _byteswap_ushort(v);
+}
+
+#else
+
+//! bswap16 - generic
+static inline std::uint16_t bswap16(const std::uint16_t& v)
+{
+    return bswap16_generic(v);
+}
+
+#endif
+
+/******************************************************************************/
+// bswap32() - swap 32-bit integers
+
+//! bswap32 - generic implementation
+static inline std::uint32_t bswap32_generic(const std::uint32_t& x)
+{
+    return ((x >> 24) & 0x000000FFUL) | ((x << 24) & 0xFF000000UL) |
+           ((x >> 8) & 0x0000FF00UL) | ((x << 8) & 0x00FF0000UL);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+
+//! bswap32 - gcc/clang intrinsic
+static inline std::uint32_t bswap32(const std::uint32_t& v)
+{
+    return __builtin_bswap32(v);
+}
+
+#elif defined(_MSC_VER)
+
+//! bswap32 - MSVC intrinsic
+static inline std::uint32_t bswap32(const std::uint32_t& v)
+{
+    return _byteswap_ulong(v);
+}
+
+#else
+
+//! bswap32 - generic
+static inline std::uint32_t bswap32(const std::uint32_t& v)
+{
+    return bswap32_generic(v);
+}
+
+#endif
+
+/******************************************************************************/
+// bswap64() - swap 64-bit integers
+
+//! bswap64 - generic implementation
+static inline std::uint64_t bswap64_generic(const std::uint64_t& x)
+{
+    return ((x >> 56) & 0x00000000000000FFULL) |
+           ((x >> 40) & 0x000000000000FF00ULL) |
+           ((x >> 24) & 0x0000000000FF0000ULL) |
+           ((x >> 8) & 0x00000000FF000000ULL) |
+           ((x << 8) & 0x000000FF00000000ULL) |
+           ((x << 24) & 0x0000FF0000000000ULL) |
+           ((x << 40) & 0x00FF000000000000ULL) |
+           ((x << 56) & 0xFF00000000000000ULL);
+}
+
+#if defined(__GNUC__) || defined(__clang__)
+
+//! bswap64 - gcc/clang intrinsic
+static inline std::uint64_t bswap64(const std::uint64_t& v)
+{
+    return __builtin_bswap64(v);
+}
+
+#elif defined(_MSC_VER)
+
+//! bswap64 - MSVC intrinsic
+static inline std::uint64_t bswap64(const std::uint64_t& v)
+{
+    return _byteswap_uint64(v);
+}
+
+#else
+
+//! bswap64 - generic
+static inline std::uint64_t bswap64(const std::uint64_t& v)
+{
+    return bswap64_generic(v);
+}
+
+#endif
+
+/******************************************************************************/
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_BSWAP_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/bswap_be.hpp

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * tlx/math/bswap_be.hpp
+ *
+ * bswap16_be(), bswap32_be() and bswap64_be() to swap bytes to big-endian:
+ * no-operations on big-endian systems, bswaps on little-endian systems.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_BSWAP_BE_HEADER
+#define TLX_MATH_BSWAP_BE_HEADER
+
+#include <tlx/define/endian.hpp>
+#include <tlx/math/bswap.hpp>
+#include <cstdint>
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// bswap16_be() - swap 16-bit integers to big-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint16_t bswap16_be(const std::uint16_t& v)
+{
+    return bswap16(v);
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint16_t bswap16_be(const std::uint16_t& v)
+{
+    return v;
+}
+#endif
+
+/******************************************************************************/
+// bswap32_be() - swap 32-bit integers to big-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint32_t bswap32_be(const std::uint32_t& v)
+{
+    return bswap32(v);
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint32_t bswap32_be(const std::uint32_t& v)
+{
+    return v;
+}
+#endif
+
+/******************************************************************************/
+// bswap64_be() - swap 64-bit integers to big-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint64_t bswap64_be(const std::uint64_t& v)
+{
+    return bswap64(v);
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint64_t bswap64_be(const std::uint64_t& v)
+{
+    return v;
+}
+#endif
+
+/******************************************************************************/
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_BSWAP_BE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/bswap_le.hpp

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * tlx/math/bswap_le.hpp
+ *
+ * bswap16_le(), bswap32_le() and bswap64_le() to swap bytes to little-endian:
+ * no-operations on little-endian systems, bswaps on big-endian systems.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_BSWAP_LE_HEADER
+#define TLX_MATH_BSWAP_LE_HEADER
+
+#include <tlx/define/endian.hpp>
+#include <tlx/math/bswap.hpp> // NOLINT(misc-include-cleaner)
+#include <cstdint>
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// bswap16_le() - swap 16-bit integers to little-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint16_t bswap16_le(const std::uint16_t& v)
+{
+    return v;
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint16_t bswap16_le(const std::uint16_t& v)
+{
+    return bswap16(v);
+}
+#endif
+
+/******************************************************************************/
+// bswap32_le() - swap 32-bit integers to little-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint32_t bswap32_le(const std::uint32_t& v)
+{
+    return v;
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint32_t bswap32_le(const std::uint32_t& v)
+{
+    return bswap32(v);
+}
+#endif
+
+/******************************************************************************/
+// bswap64_le() - swap 64-bit integers to little-endian
+
+#if TLX_LITTLE_ENDIAN
+static inline std::uint64_t bswap64_le(const std::uint64_t& v)
+{
+    return v;
+}
+#elif TLX_BIG_ENDIAN
+static inline std::uint64_t bswap64_le(const std::uint64_t& v)
+{
+    return bswap64(v);
+}
+#endif
+
+/******************************************************************************/
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_BSWAP_LE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/clz.hpp

@@ -0,0 +1,174 @@
+/*******************************************************************************
+ * tlx/math/clz.hpp
+ *
+ * clz() count leading zeros - mainly for portability.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_CLZ_HEADER
+#define TLX_MATH_CLZ_HEADER
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// clz() - count leading zeros
+
+//! clz (count leading zeros) - generic implementation
+template <typename Integral>
+static inline unsigned clz_template(Integral x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    unsigned r = 0;
+    while ((x & (static_cast<Integral>(1) << (8 * sizeof(x) - 1))) == 0)
+        x <<= 1, ++r;
+    return r;
+}
+
+/******************************************************************************/
+
+template <typename Integral>
+inline unsigned clz(Integral x);
+
+#if defined(__GNUC__) || defined(__clang__)
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned>(unsigned x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_clz(x));
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<int>(int x)
+{
+    return clz(static_cast<unsigned>(x));
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned long>(unsigned long x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_clzl(x));
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<long>(long x)
+{
+    return clz(static_cast<unsigned long>(x));
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned long long>(unsigned long long x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_clzll(x));
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<long long>(long long x)
+{
+    return clz(static_cast<unsigned long long>(x));
+}
+
+#elif defined(_MSC_VER)
+
+//! clz (count leading zeros)
+template <typename Integral>
+inline unsigned clz<unsigned>(Integral x)
+{
+    unsigned long leading_zeros = 0;
+    if (sizeof(x) > 4)
+    {
+#if defined(_WIN64)
+        if (_BitScanReverse64(&leading_zeros, x))
+            return 63 - leading_zeros;
+        else
+            return 8 * sizeof(x);
+#else
+        return clz_template(x);
+#endif
+    }
+    else
+    {
+        if (_BitScanReverse(&leading_zeros, static_cast<unsigned>(x)))
+            return 31 - leading_zeros;
+        else
+            return 8 * sizeof(x);
+    }
+}
+
+#else
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<int>(int x)
+{
+    return clz_template(x);
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned>(unsigned x)
+{
+    return clz_template(x);
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<long>(long x)
+{
+    return clz_template(x);
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned long>(unsigned long x)
+{
+    return clz_template(x);
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<long long>(long long x)
+{
+    return clz_template(x);
+}
+
+//! clz (count leading zeros)
+template <>
+inline unsigned clz<unsigned long long>(unsigned long long x)
+{
+    return clz_template(x);
+}
+
+#endif
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_CLZ_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/ctz.hpp

@@ -0,0 +1,174 @@
+/*******************************************************************************
+ * tlx/math/ctz.hpp
+ *
+ * ctz() count trailing zeros - mainly for portability.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_CTZ_HEADER
+#define TLX_MATH_CTZ_HEADER
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// ctz() - count trailing zeros
+
+//! ctz (count trailing zeros) - generic implementation
+template <typename Integral>
+static inline unsigned ctz_template(Integral x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    unsigned r = 0;
+    while ((x & static_cast<Integral>(1)) == 0)
+        x >>= 1, ++r;
+    return r;
+}
+
+/******************************************************************************/
+
+template <typename Integral>
+inline unsigned ctz(Integral x);
+
+#if defined(__GNUC__) || defined(__clang__)
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned>(unsigned x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_ctz(x));
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<int>(int x)
+{
+    return ctz(static_cast<unsigned>(x));
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned long>(unsigned long x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_ctzl(x));
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<long>(long x)
+{
+    return ctz(static_cast<unsigned long>(x));
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned long long>(unsigned long long x)
+{
+    if (x == 0)
+        return 8 * sizeof(x);
+    return static_cast<unsigned>(__builtin_ctzll(x));
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<long long>(long long x)
+{
+    return ctz(static_cast<unsigned long long>(x));
+}
+
+#elif defined(_MSC_VER)
+
+//! ctz (count trailing zeros)
+template <typename Integral>
+inline unsigned ctz<unsigned>(Integral x)
+{
+    unsigned long trailing_zeros = 0;
+    if (sizeof(x) > 4)
+    {
+#if defined(_WIN64)
+        if (_BitScanForward64(&trailing_zeros, x))
+            return trailing_zeros;
+        else
+            return 8 * sizeof(x);
+#else
+        return ctz_template(x);
+#endif
+    }
+    else
+    {
+        if (_BitScanForward(&trailing_zeros, static_cast<unsigned>(x)))
+            return trailing_zeros;
+        else
+            return 8 * sizeof(x);
+    }
+}
+
+#else
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<int>(int x)
+{
+    return ctz_template(x);
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned>(unsigned x)
+{
+    return ctz_template(x);
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<long>(long x)
+{
+    return ctz_template(x);
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned long>(unsigned long x)
+{
+    return ctz_template(x);
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<long long>(long long x)
+{
+    return ctz_template(x);
+}
+
+//! ctz (count trailing zeros)
+template <>
+inline unsigned ctz<unsigned long long>(unsigned long long x)
+{
+    return ctz_template(x);
+}
+
+#endif
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_CTZ_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/math/div_ceil.hpp

@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * tlx/math/div_ceil.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MATH_DIV_CEIL_HEADER
+#define TLX_MATH_DIV_CEIL_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_math
+//! \{
+
+/******************************************************************************/
+// div_ceil() - calculate n div k with rounding up
+
+//! calculate n div k with rounding up, for n and k positive!
+template <typename IntegralN, typename IntegralK>
+static constexpr auto div_ceil(const IntegralN& n,
+                               const IntegralK& k) -> decltype(n + k)
+{
+    return (n + k - 1) / k;
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_MATH_DIV_CEIL_HEADER
+
+/******************************************************************************/