/*

* Runtime assertion checking

* (C) 2010,2018 Jack Lloyd

*     2017 Simon Warta (Kullo GmbH)

*

* Botan is released under the Simplified BSD License (see license.txt)

*/

#ifndef BOTAN_ASSERTION_CHECKING_H_

#define BOTAN_ASSERTION_CHECKING_H_

#include <botan/compiler.h>

namespace Botan {

/**

* Called when an assertion fails

* Throws an Exception object

*/

[[noreturn]] void BOTAN_PUBLIC_API(2, 0)

   assertion_failure(const char* expr_str, const char* assertion_made, const char* func, const char* file, int line);

/**

* Called when an invalid argument is used

* Throws Invalid_Argument

*/

[[noreturn]] void BOTAN_UNSTABLE_API throw_invalid_argument(const char* message, const char* func, const char* file);

#define BOTAN_ARG_CHECK(expr, msg)                               \

   do {                                                          \

      if(!(expr))                                                \

         Botan::throw_invalid_argument(msg, __func__, __FILE__); \

   } while(0)

/**

* Called when an invalid state is encountered

* Throws Invalid_State

*/

[[noreturn]] void BOTAN_UNSTABLE_API throw_invalid_state(const char* message, const char* func, const char* file);

#define BOTAN_STATE_CHECK(expr)                                 \

   do {                                                         \

      if(!(expr))                                               \

         Botan::throw_invalid_state(#expr, __func__, __FILE__); \

   } while(0)

/**

* Make an assertion

*/

#define BOTAN_ASSERT(expr, assertion_made)                                              \

   do {                                                                                 \

      if(!(expr))                                                                       \

         Botan::assertion_failure(#expr, assertion_made, __func__, __FILE__, __LINE__); \

   } while(0)

/**

* Make an assertion

*/

#define BOTAN_ASSERT_NOMSG(expr)                                            \

   do {                                                                     \

      if(!(expr))                                                           \

         Botan::assertion_failure(#expr, "", __func__, __FILE__, __LINE__); \

   } while(0)

/**

* Assert that value1 == value2

*/

#define BOTAN_ASSERT_EQUAL(expr1, expr2, assertion_made)                                               \

   do {                                                                                                \

      if((expr1) != (expr2))                                                                           \

         Botan::assertion_failure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__); \

   } while(0)

/**

* Assert that expr1 (if true) implies expr2 is also true

*/

#define BOTAN_ASSERT_IMPLICATION(expr1, expr2, msg)                                              \

   do {                                                                                          \

      if((expr1) && !(expr2))                                                                    \

         Botan::assertion_failure(#expr1 " implies " #expr2, msg, __func__, __FILE__, __LINE__); \

   } while(0)

/**

* Assert that a pointer is not null

*/

#define BOTAN_ASSERT_NONNULL(ptr)                                                         \

   do {                                                                                   \

      if((ptr) == nullptr)                                                                \

         Botan::assertion_failure(#ptr " is not null", "", __func__, __FILE__, __LINE__); \

   } while(0)

#if defined(BOTAN_ENABLE_DEBUG_ASSERTS)

   #define BOTAN_DEBUG_ASSERT(expr) BOTAN_ASSERT_NOMSG(expr)

#else

   #define BOTAN_DEBUG_ASSERT(expr) \

      do {                          \

      } while(0)

#endif

/**

* Mark variable as unused.

*

* Takes any number of arguments and marks all as unused, for instance

* BOTAN_UNUSED(a); or BOTAN_UNUSED(x, y, z);

*/

template <typename T>

void ignore_param(T&&) {}

void Botan::ignore_param<unsigned long&>(unsigned long&)

Line

Count

Source

111

762k

void ignore_param(T&&) {}

void Botan::ignore_param<unsigned long const&>(unsigned long const&)

Line

Count

Source

111

9.23k

void ignore_param(T&&) {}

Unexecuted instantiation: void Botan::ignore_param<void*&>(void*&)

template <typename... T>

void ignore_params(T&&... args) {

   (ignore_param(args), ...);

}

void Botan::ignore_params<unsigned long&>(unsigned long&)

Line

Count

Source

114

762k

void ignore_params(T&&... args) {

115

762k

   (ignore_param(args), ...);

116

762k

}

Unexecuted instantiation: void Botan::ignore_params<unsigned long const&, unsigned long const&>(unsigned long const&, unsigned long const&)

void Botan::ignore_params<unsigned long const&>(unsigned long const&)

Line

Count

Source

114

9.23k

void ignore_params(T&&... args) {

115

9.23k

   (ignore_param(args), ...);

116

9.23k

}

Unexecuted instantiation: void Botan::ignore_params<void*&, unsigned long&>(void*&, unsigned long&)

#define BOTAN_UNUSED Botan::ignore_params

/*

* Define Botan::unreachable()

*

* There is a pending WG21 proposal for `std::unreachable()`

*   http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0627r3.pdf

*/

[[noreturn]] BOTAN_FORCE_INLINE void unreachable() {

#if BOTAN_COMPILER_HAS_BUILTIN(__builtin_unreachable)

   __builtin_unreachable();

#elif defined(_MSC_VER)  // MSVC

   __assume(false);

#else

   return;  // undefined behaviour, just like the others...

#endif

}

}  // namespace Botan

#endif