@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/die/core.hpp

@@ -0,0 +1,311 @@
+/*******************************************************************************
+ * tlx/die/core.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_DIE_CORE_HEADER
+#define TLX_DIE_CORE_HEADER
+
+#include <cstring>
+#include <iomanip> // NOLINT(misc-include-cleaner)
+#include <sstream> // NOLINT(misc-include-cleaner)
+#include <stdexcept>
+#include <string>
+
+namespace tlx {
+
+/******************************************************************************/
+// die macros
+
+//! die with message - either throw an exception or die via std::terminate()
+void die_with_message(const std::string& msg);
+
+//! die with message - either throw an exception or die via std::terminate()
+void die_with_message(const char* msg, const char* file, size_t line);
+
+//! die with message - either throw an exception or die via std::terminate()
+void die_with_message(const std::string& msg, const char* file, size_t line);
+
+//! Instead of std::terminate(), throw the output the message via an exception.
+#define tlx_die_with_sstream(msg)                                              \
+    do                                                                         \
+    {                                                                          \
+        std::ostringstream oss__;                                              \
+        oss__ << msg << " @ " << __FILE__ << ':' << __LINE__;                  \
+        ::tlx::die_with_message(oss__.str());                                  \
+        std::terminate(); /* tell compiler this never returns */               \
+    } while (false)
+
+//! Instead of std::terminate(), throw the output the message via an exception.
+#define tlx_die(msg)                                                           \
+    do                                                                         \
+    {                                                                          \
+        tlx_die_with_sstream("DIE: " << msg);                                  \
+    } while (false)
+
+//! Exception thrown by die_with_message() if
+class DieException : public std::runtime_error
+{
+public:
+    explicit DieException(const std::string& message);
+};
+
+//! Switch between dying via std::terminate() and throwing an exception.
+//! Alternatively define the macro TLX_DIE_WITH_EXCEPTION=1
+bool set_die_with_exception(bool b);
+
+/******************************************************************************/
+// die_unless() and die_if()
+
+//! Check condition X and die miserably if false. Same as assert() except this
+//! is also active in Release mode.
+#define tlx_die_unless(X)                                                      \
+    do                                                                         \
+    {                                                                          \
+        if (!(X)) /* NOLINT(readability-simplify-boolean-expr) */              \
+        {                                                                      \
+            ::tlx::die_with_message("DIE: Assertion \"" #X "\" failed!",       \
+                                    __FILE__, __LINE__);                       \
+        }                                                                      \
+    } while (false)
+
+//! Check condition X and die miserably if true. Opposite of assert() except
+//! this is also active in Release mode.
+#define tlx_die_if(X)                                                          \
+    do                                                                         \
+    {                                                                          \
+        if (X)                                                                 \
+        {                                                                      \
+            ::tlx::die_with_message("DIE: Assertion \"" #X "\" succeeded!",    \
+                                    __FILE__, __LINE__);                       \
+        }                                                                      \
+    } while (false)
+
+//! Check condition X and die miserably if false. Same as tlx_die_unless()
+//! except the user additionally passes a message.
+#define tlx_die_verbose_unless(X, msg)                                         \
+    do                                                                         \
+    {                                                                          \
+        if (!(X)) /* NOLINT(readability-simplify-boolean-expr) */              \
+        {                                                                      \
+            tlx_die_with_sstream("DIE: Assertion \"" #X "\" failed!\n"         \
+                                 << msg << '\n');                              \
+        }                                                                      \
+    } while (false)
+
+//! Check condition X and die miserably if false. Same as tlx_die_if()
+//! except the user additionally passes a message.
+#define tlx_die_verbose_if(X, msg)                                             \
+    do                                                                         \
+    {                                                                          \
+        if ((X))                                                               \
+        {                                                                      \
+            tlx_die_with_sstream("DIE: Assertion \"" #X "\" succeeded!\n"      \
+                                 << msg << '\n');                              \
+        }                                                                      \
+    } while (false)
+
+/******************************************************************************/
+// die_unequal()
+
+//! helper method to compare two values in die_unequal()
+template <typename TypeA, typename TypeB>
+inline bool die_equal_compare(TypeA a, TypeB b)
+{
+    return a == b;
+}
+
+template <>
+inline bool die_equal_compare(const char* a, const char* b)
+{
+    // compare string contents
+    return std::strcmp(a, b) == 0;
+}
+
+template <>
+inline bool die_equal_compare(float a, float b)
+{
+    // special case for NAN
+    return a != a ? b != b : a == b;
+}
+
+template <>
+inline bool die_equal_compare(double a, double b)
+{
+    // special case for NAN
+    return a != a ? b != b : a == b;
+}
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging.
+#define tlx_die_unequal(X, Y)                                                  \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (!::tlx::die_equal_compare(x__, y__))                               \
+        {                                                                      \
+            tlx_die_with_sstream("DIE-UNEQUAL: " #X " != " #Y " : "            \
+                                 "\""                                          \
+                                 << x__ << "\" != \"" << y__ << "\"");         \
+        }                                                                      \
+    } while (false)
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging. Only active if NDEBUG is not defined.
+#ifdef NDEBUG
+#define tlx_assert_equal(X, Y)
+#else
+#define tlx_assert_equal(X, Y) die_unequal(X, Y)
+#endif
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging. Same as tlx_die_unequal() except the user additionally
+//! pass a message.
+#define tlx_die_verbose_unequal(X, Y, msg)                                     \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (!::tlx::die_equal_compare(x__, y__))                               \
+        {                                                                      \
+            tlx_die_with_sstream("DIE-UNEQUAL: " #X " != " #Y " : "            \
+                                 "\""                                          \
+                                 << x__ << "\" != \"" << y__ << "\"\n"         \
+                                 << msg << '\n');                              \
+        }                                                                      \
+    } while (false)
+
+/******************************************************************************/
+// die_unequal_eps()
+
+//! simple replacement for std::abs
+template <typename Type>
+inline Type die_unequal_eps_abs(const Type& t)
+{
+    return t < 0 ? -t : t;
+}
+
+//! helper method to compare two values in die_unequal_eps()
+template <typename TypeA, typename TypeB>
+inline bool die_equal_eps_compare(TypeA x, TypeB y, double eps)
+{
+    // special case for NAN
+    return x != x ? y != y : die_unequal_eps_abs(x - y) <= eps;
+}
+
+//! Check that ABS(X - Y) <= eps or die miserably, but output the values of X
+//! and Y for better debugging.
+#define tlx_die_unequal_eps(X, Y, eps)                                         \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (!::tlx::die_equal_eps_compare(x__, y__, eps))                      \
+        {                                                                      \
+            tlx_die("DIE-UNEQUAL-EPS: " #X " != " #Y " : "                     \
+                    << std::setprecision(18) << "\"" << x__ << "\" != \""      \
+                    << y__ << "\"");                                           \
+        }                                                                      \
+    } while (false)
+
+//! Check that ABS(X - Y) <= eps or die miserably, but output the values of X
+//! and Y for better debugging. Same as tlx_die_unequal_eps() except the user
+//! additionally passes a message.
+#define tlx_die_verbose_unequal_eps(X, Y, eps, msg)                            \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (!::tlx::die_equal_eps_compare(x__, y__, eps))                      \
+        {                                                                      \
+            tlx_die("DIE-UNEQUAL-EPS: " #X " != " #Y " : "                     \
+                    << std::setprecision(18) << "\"" << x__ << "\" != \""      \
+                    << y__ << "\"\n"                                           \
+                    << msg << '\n');                                           \
+        }                                                                      \
+    } while (false)
+
+//! Check that ABS(X - Y) <= 0.000001 or die miserably, but output the values of
+//! X and Y for better debugging.
+#define tlx_die_unequal_eps6(X, Y) die_unequal_eps(X, Y, 1e-6)
+
+//! Check that ABS(X - Y) <= 0.000001 or die miserably, but output the values of
+//! X and Y for better debugging. Same as tlx_die_unequal_eps6() except the user
+//! additionally passes a message.
+#define tlx_die_verbose_unequal_eps6(X, Y, msg)                                \
+    die_verbose_unequal_eps(X, Y, 1e-6, msg)
+
+/******************************************************************************/
+// die_equal()
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging.
+#define tlx_die_equal(X, Y)                                                    \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (::tlx::die_equal_compare(x__, y__))                                \
+        {                                                                      \
+            tlx_die_with_sstream("DIE-EQUAL: " #X " == " #Y " : "              \
+                                 "\""                                          \
+                                 << x__ << "\" == \"" << y__ << "\"");         \
+        }                                                                      \
+    } while (false)
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging. Only active if NDEBUG is not defined.
+#ifdef NDEBUG
+#define tlx_assert_unequal(X, Y)
+#else
+#define tlx_assert_unequal(X, Y) die_equal(X, Y)
+#endif
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging. Same as tlx_die_equal() except the user additionally passes a
+//! message.
+#define tlx_die_verbose_equal(X, Y, msg)                                       \
+    do                                                                         \
+    {                                                                          \
+        auto x__ = (X); /* NOLINT */                                           \
+        auto y__ = (Y); /* NOLINT */                                           \
+        if (::tlx::die_equal_compare(x__, y__))                                \
+        {                                                                      \
+            tlx_die_with_sstream("DIE-EQUAL: " #X " == " #Y " : "              \
+                                 "\""                                          \
+                                 << x__ << "\" == \"" << y__ << "\"\n"         \
+                                 << msg << '\n');                              \
+        }                                                                      \
+    } while (false)
+
+/******************************************************************************/
+// die_unless_throws()
+
+//! Define to check that [code] throws and exception of given type
+#define tlx_die_unless_throws(code, exception_type)                            \
+    do                                                                         \
+    {                                                                          \
+        try                                                                    \
+        {                                                                      \
+            code;                                                              \
+        }                                                                      \
+        catch (const exception_type&)                                          \
+        {                                                                      \
+            break;                                                             \
+        }                                                                      \
+        ::tlx::die_with_message("DIE-UNLESS-THROWS: " #code                    \
+                                " - NO EXCEPTION " #exception_type,            \
+                                __FILE__, __LINE__);                           \
+    } while (false)
+
+} // namespace tlx
+
+#endif // !TLX_DIE_CORE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/die.hpp

@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * tlx/die.hpp
+ *
+ * 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_DIE_HEADER
+#define TLX_DIE_HEADER
+
+#include <tlx/die/core.hpp>
+
+namespace tlx {
+
+/******************************************************************************/
+// die macros
+
+//! Instead of std::terminate(), throw the output the message via an exception.
+#define die(msg) tlx_die(msg)
+
+//! Check condition X and die miserably if false. Same as assert() except this
+//! is also active in Release mode.
+#define die_unless(X) tlx_die_unless(X)
+
+//! Check condition X and die miserably if true. Opposite of assert() except
+//! this is also active in Release mode.
+#define die_if(X) tlx_die_if(X)
+
+//! Check condition X and die miserably if false. Same as die_unless() except
+//! the user additionally passes a message.
+#define die_verbose_unless(X, msg) tlx_die_verbose_unless(X, msg)
+
+//! Check condition X and die miserably if false. Same as die_if() except the
+//! the user additionally passes a message.
+#define die_verbose_if(X, msg) tlx_die_verbose_if(X, msg)
+
+/******************************************************************************/
+// die_unequal()
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging.
+#define die_unequal(X, Y) tlx_die_unequal(X, Y)
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging. Only active if NDEBUG is not defined.
+#define assert_equal(X, Y) tlx_assert_equal(X, Y)
+
+//! Check that X == Y or die miserably, but output the values of X and Y for
+//! better debugging. Same as die_unequal() except the user additionally passes
+//! a message.
+#define die_verbose_unequal(X, Y, msg) tlx_die_verbose_unequal(X, Y, msg)
+
+/******************************************************************************/
+// die_unequal_eps()
+
+//! Check that ABS(X - Y) <= eps or die miserably, but output the values of X
+//! and Y for better debugging.
+#define die_unequal_eps(X, Y, eps) tlx_die_unequal_eps(X, Y, eps)
+
+//! Check that ABS(X - Y) <= eps or die miserably, but output the values of X
+//! and Y for better debugging. Same as die_unequal_eps() except the user
+//! additionally passes a message.
+#define die_verbose_unequal_eps(X, Y, eps, msg)                                \
+    tlx_die_verbose_unequal_eps(X, Y, eps, msg)
+
+//! Check that ABS(X - Y) <= 0.000001 or die miserably, but output the values of
+//! X and Y for better debugging.
+#define die_unequal_eps6(X, Y) tlx_die_unequal_eps6(X, Y)
+
+//! Check that ABS(X - Y) <= 0.000001 or die miserably, but output the values of
+//! X and Y for better debugging. Same as die_unequal_eps6() except the user
+//! additionally passes a message.
+#define die_verbose_unequal_eps6(X, Y, msg)                                    \
+    tlx_die_verbose_unequal_eps6(X, Y, msg)
+
+/******************************************************************************/
+// die_equal()
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging.
+#define die_equal(X, Y) tlx_die_equal(X, Y)
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging. Only active if NDEBUG is not defined.
+#define assert_unequal(X, Y) tlx_assert_unequal(X, Y)
+
+//! Die miserably if X == Y, but first output the values of X and Y for better
+//! debugging. Same as die_equal() except the user additionally passes a
+//! message.
+#define die_verbose_equal(X, Y, msg) tlx_die_verbose_equal(X, Y, msg)
+
+/******************************************************************************/
+// die_unless_throws()
+
+//! Define to check that [code] throws and exception of given type
+#define die_unless_throws(code, exception_type)                                \
+    tlx_die_unless_throws(code, exception_type)
+
+} // namespace tlx
+
+#endif // !TLX_DIE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/digest/md5.hpp

@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * tlx/digest/md5.hpp
+ *
+ * Public domain implementation of MD-5 processor. Based on LibTomCrypt from
+ * https://github.com/libtom/libtomcrypt.git
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_DIGEST_MD5_HEADER
+#define TLX_DIGEST_MD5_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_digest
+//! \{
+
+/*!
+ * MD-5 processor without external dependencies.
+ */
+class MD5
+{
+public:
+    //! construct empty object.
+    MD5();
+    //! construct context and process data range
+    MD5(const void* data, std::uint32_t size);
+    //! construct context and process string
+    explicit MD5(tlx::string_view str);
+
+    //! process more data
+    void process(const void* data, std::uint32_t size);
+    //! process more data
+    void process(tlx::string_view str);
+
+    //! digest length in bytes
+    static constexpr size_t kDigestLength = 16;
+
+    //! finalize computation and output 16 byte (128 bit) digest
+    void finalize(void* digest);
+
+    //! finalize computation and return 16 byte (128 bit) digest
+    std::string digest();
+    //! finalize computation and return 16 byte (128 bit) digest hex encoded
+    std::string digest_hex();
+    //! finalize computation and return 16 byte (128 bit) digest upper-case hex
+    std::string digest_hex_uc();
+
+private:
+    std::uint64_t length_ = 0;
+    std::uint32_t state_[4];
+    std::uint32_t curlen_ = 0;
+    std::uint8_t buf_[64];
+};
+
+//! process data and return 16 byte (128 bit) digest hex encoded
+std::string md5_hex(const void* data, std::uint32_t size);
+//! process data and return 16 byte (128 bit) digest hex encoded
+std::string md5_hex(tlx::string_view str);
+
+//! process data and return 16 byte (128 bit) digest upper-case hex encoded
+std::string md5_hex_uc(const void* data, std::uint32_t size);
+//! process data and return 16 byte (128 bit) digest upper-case hex encoded
+std::string md5_hex_uc(tlx::string_view str);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_DIGEST_MD5_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/digest/sha1.hpp

@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * tlx/digest/sha1.hpp
+ *
+ * Public domain implementation of SHA-1 processor. Based on LibTomCrypt from
+ * https://github.com/libtom/libtomcrypt.git
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_DIGEST_SHA1_HEADER
+#define TLX_DIGEST_SHA1_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_digest
+//! \{
+
+/*!
+ * SHA-1 processor without external dependencies.
+ */
+class SHA1
+{
+public:
+    //! construct empty object.
+    SHA1();
+    //! construct context and process data range
+    SHA1(const void* data, std::uint32_t size);
+    //! construct context and process string
+    explicit SHA1(tlx::string_view str);
+
+    //! process more data
+    void process(const void* data, std::uint32_t size);
+    //! process more data
+    void process(tlx::string_view str);
+
+    //! digest length in bytes
+    static constexpr size_t kDigestLength = 20;
+
+    //! finalize computation and output 20 byte (160 bit) digest
+    void finalize(void* digest);
+
+    //! finalize computation and return 20 byte (160 bit) digest
+    std::string digest();
+    //! finalize computation and return 20 byte (160 bit) digest hex encoded
+    std::string digest_hex();
+    //! finalize computation and return 20 byte (160 bit) digest upper-case hex
+    std::string digest_hex_uc();
+
+private:
+    std::uint64_t length_ = 0;
+    std::uint32_t state_[5];
+    std::uint32_t curlen_ = 0;
+    std::uint8_t buf_[64];
+};
+
+//! process data and return 20 byte (160 bit) digest hex encoded
+std::string sha1_hex(const void* data, std::uint32_t size);
+//! process data and return 20 byte (160 bit) digest hex encoded
+std::string sha1_hex(tlx::string_view str);
+
+//! process data and return 20 byte (160 bit) digest upper-case hex encoded
+std::string sha1_hex_uc(const void* data, std::uint32_t size);
+//! process data and return 20 byte (160 bit) digest upper-case hex encoded
+std::string sha1_hex_uc(tlx::string_view str);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_DIGEST_SHA1_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/digest/sha256.hpp

@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * tlx/digest/sha256.hpp
+ *
+ * Public domain implementation of SHA-256 (SHA-2) processor. Copied from
+ * https://github.com/kalven/sha-2, which is based on LibTomCrypt.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_DIGEST_SHA256_HEADER
+#define TLX_DIGEST_SHA256_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_digest
+//! \{
+
+/*!
+ * SHA-256 processor without external dependencies.
+ */
+class SHA256
+{
+public:
+    //! construct empty object.
+    SHA256();
+    //! construct context and process data range
+    SHA256(const void* data, std::uint32_t size);
+    //! construct context and process string
+    explicit SHA256(tlx::string_view str);
+
+    //! process more data
+    void process(const void* data, std::uint32_t size);
+    //! process more data
+    void process(tlx::string_view str);
+
+    //! digest length in bytes
+    static constexpr size_t kDigestLength = 32;
+
+    //! finalize computation and output 32 byte (256 bit) digest
+    void finalize(void* digest);
+
+    //! finalize computation and return 32 byte (256 bit) digest
+    std::string digest();
+    //! finalize computation and return 32 byte (256 bit) digest hex encoded
+    std::string digest_hex();
+    //! finalize computation and return 32 byte (256 bit) digest upper-case hex
+    std::string digest_hex_uc();
+
+private:
+    std::uint64_t length_ = 0;
+    std::uint32_t state_[8];
+    std::uint32_t curlen_ = 0;
+    std::uint8_t buf_[64];
+};
+
+//! process data and return 32 byte (256 bit) digest hex encoded
+std::string sha256_hex(const void* data, std::uint32_t size);
+//! process data and return 32 byte (256 bit) digest hex encoded
+std::string sha256_hex(tlx::string_view str);
+
+//! process data and return 32 byte (256 bit) digest upper-case hex encoded
+std::string sha256_hex_uc(const void* data, std::uint32_t size);
+//! process data and return 32 byte (256 bit) digest upper-case hex encoded
+std::string sha256_hex_uc(tlx::string_view str);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_DIGEST_SHA256_HEADER
+
+/******************************************************************************/