@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,311 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,106 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,81 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,81 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,81 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/