229 lines
7.8 KiB
C++
229 lines
7.8 KiB
C++
// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
/*
|
|
* Various assert macros based on C++ exceptions and their support code.
|
|
*/
|
|
|
|
/*
|
|
* (c) 2006-2016 Petr Ročkai <code@fixp.eu>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <exception>
|
|
#include <string>
|
|
#include <sstream>
|
|
|
|
#ifndef TEST
|
|
#define TEST(n) void n()
|
|
#define TEST_FAILING(n) void n()
|
|
#endif
|
|
|
|
#ifndef NDEBUG
|
|
|
|
#define BRICK_SHARP_FIRST(x, ...) #x
|
|
#define ASSERT(...) ::brick::_assert::assert_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( BRICK_SHARP_FIRST( __VA_ARGS__, ignored ) ) ), __VA_ARGS__ )
|
|
#define ASSERT_PRED(p, x) ::brick::_assert::assert_pred_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( #p "( " #x " )" ) ), x, p( x ) )
|
|
#define ASSERT_EQ(x, y) ::brick::_assert::assert_eq_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( #x " == " #y ) ), x, y )
|
|
#define ASSERT_LT(x, y) ::brick::_assert::assert_lt_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( #x " < " #y ) ), x, y )
|
|
#define ASSERT_LEQ(x, y) ::brick::_assert::assert_leq_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( #x " <= " #y ) ), x, y )
|
|
#define ASSERT_NEQ(x, y) ::brick::_assert::assert_neq_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( #x " != " #y ) ), x, y )
|
|
#define ASSERT_EQ_IDX(i, x, y) ::brick::_assert::assert_eq_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION_I( #x " == " #y, i ) ), x, y )
|
|
|
|
#else
|
|
|
|
#define ASSERT(...) static_cast< decltype(__VA_ARGS__, void(0)) >(0)
|
|
#define ASSERT_PRED(p, x) static_cast< decltype(p, x, void(0)) >(0)
|
|
#define ASSERT_EQ(x, y) static_cast< decltype(x, y, void(0)) >(0)
|
|
#define ASSERT_LEQ(x, y) static_cast< decltype(x, y, void(0)) >(0)
|
|
#define ASSERT_LT(x, y) static_cast< decltype(x, y, void(0)) >(0)
|
|
#define ASSERT_NEQ(x, y) static_cast< decltype(x, y, void(0)) >(0)
|
|
#define ASSERT_EQ_IDX(i, x, y) static_cast< decltype(i, x, y, void(0)) >(0)
|
|
#endif
|
|
|
|
/* you must #include <brick-string.h> to use ASSERT_UNREACHABLE_F */
|
|
#define UNREACHABLE_F(...) ::brick::_assert::assert_die_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( brick::string::fmtf(__VA_ARGS__) ) ) )
|
|
#define UNREACHABLE(x) ::brick::_assert::assert_die_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( x ) ) )
|
|
#define UNREACHABLE_() ::brick::_assert::assert_die_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( "an unreachable location" ) ) )
|
|
#define NOT_IMPLEMENTED() ::brick::_assert::assert_die_fn( \
|
|
BRICK_LOCWRAP( BRICK_LOCATION( "a missing implementation" ) ) )
|
|
|
|
#ifdef _MSC_VER
|
|
#define DIVINE_UNUSED
|
|
#define noexcept
|
|
#else
|
|
#define DIVINE_UNUSED __attribute__((unused))
|
|
#endif
|
|
|
|
#ifndef BRICK_ASSERT_H
|
|
#define BRICK_ASSERT_H
|
|
|
|
namespace brick {
|
|
namespace _assert {
|
|
|
|
/* discard any number of parameters, taken as const references */
|
|
template< typename... X >
|
|
void unused( const X&... ) { }
|
|
|
|
struct Location {
|
|
int line, iteration;
|
|
std::string file, stmt;
|
|
Location( const char *f, int l, std::string st, int iter = -1 )
|
|
: line( l ), iteration( iter ), file( f ), stmt( st )
|
|
{
|
|
int slashes = 0;
|
|
for ( int i = 0; i < int( file.size() ); ++i )
|
|
if ( file[i] == '/' )
|
|
++ slashes;
|
|
|
|
while ( slashes >= 3 )
|
|
{
|
|
file = std::string( file, file.find( "/" ) + 1, std::string::npos );
|
|
-- slashes;
|
|
}
|
|
if ( f != file )
|
|
file = ".../" + file;
|
|
}
|
|
};
|
|
|
|
#define BRICK_LOCATION(stmt) ::brick::_assert::Location( __FILE__, __LINE__, stmt )
|
|
#define BRICK_LOCATION_I(stmt, i) ::brick::_assert::Location( __FILE__, __LINE__, stmt, i )
|
|
|
|
// lazy location construction in C++11
|
|
#if __cplusplus >= 201103L
|
|
#define BRICK_LOCWRAP(x) [&]{ return (x); }
|
|
#define BRICK_LOCUNWRAP(x) (x)()
|
|
#else
|
|
#define BRICK_LOCWRAP(x) (x)
|
|
#define BRICK_LOCUNWRAP(x) (x)
|
|
#endif
|
|
|
|
struct AssertFailed : std::exception
|
|
{
|
|
std::string str;
|
|
|
|
template< typename X >
|
|
friend inline AssertFailed &operator<<( AssertFailed &f, X x )
|
|
{
|
|
std::stringstream str;
|
|
str << x;
|
|
f.str += str.str();
|
|
return f;
|
|
}
|
|
|
|
AssertFailed( Location l, const char *expected = "expected" )
|
|
{
|
|
(*this) << l.file << ": " << l.line;
|
|
if ( l.iteration != -1 )
|
|
(*this) << " (iteration " << l.iteration << ")";
|
|
(*this) << ":\n " << expected << " " << l.stmt;
|
|
}
|
|
|
|
const char *what() const noexcept override { return str.c_str(); }
|
|
};
|
|
|
|
static inline void format( AssertFailed & ) {}
|
|
|
|
template< typename X, typename... Y >
|
|
void format( AssertFailed &f, X x, Y... y )
|
|
{
|
|
f << x;
|
|
format( f, y... );
|
|
}
|
|
|
|
template< typename Location, typename X, typename... Y >
|
|
void assert_fn( Location l, X x, Y... y )
|
|
{
|
|
if ( x )
|
|
return;
|
|
AssertFailed f( BRICK_LOCUNWRAP( l ) );
|
|
format( f, y... );
|
|
throw f;
|
|
}
|
|
|
|
template< typename Location >
|
|
inline void assert_die_fn( Location l ) __attribute__((noreturn));
|
|
|
|
template< typename Location >
|
|
inline void assert_die_fn( Location l )
|
|
{
|
|
throw AssertFailed( BRICK_LOCUNWRAP( l ), "encountered" );
|
|
}
|
|
|
|
#define ASSERT_FN(name, op, inv) \
|
|
template< typename Location > \
|
|
void assert_ ## name ## _fn( Location l, int64_t x, int64_t y ) \
|
|
{ \
|
|
if ( !( x op y ) ) { \
|
|
AssertFailed f( BRICK_LOCUNWRAP( l ) ); \
|
|
f << "\n but got " \
|
|
<< x << " " #inv " " << y << "\n"; \
|
|
throw f; \
|
|
} \
|
|
} \
|
|
\
|
|
template< typename Location, typename X, typename Y > \
|
|
auto assert_ ## name ## _fn( Location l, X x, Y y ) \
|
|
-> typename std::enable_if< \
|
|
!std::is_integral< X >::value || \
|
|
!std::is_integral< Y >::value >::type \
|
|
{ \
|
|
if ( !( x op y ) ) { \
|
|
AssertFailed f( BRICK_LOCUNWRAP( l ) ); \
|
|
f << "\n but got " \
|
|
<< x << " " #inv " " << y << "\n"; \
|
|
throw f; \
|
|
} \
|
|
}
|
|
|
|
ASSERT_FN(eq, ==, !=)
|
|
ASSERT_FN(leq, <=, >)
|
|
ASSERT_FN(lt, <, >=)
|
|
|
|
template< typename Location, typename X >
|
|
void assert_pred_fn( Location l, X x, bool p )
|
|
{
|
|
if ( !p ) {
|
|
AssertFailed f( BRICK_LOCUNWRAP( l ) );
|
|
f << "\n but got x = " << x << "\n";
|
|
throw f;
|
|
}
|
|
}
|
|
|
|
template< typename Location, typename X, typename Y >
|
|
void assert_neq_fn( Location l, X x, Y y )
|
|
{
|
|
if ( x != y )
|
|
return;
|
|
AssertFailed f( BRICK_LOCUNWRAP( l ) );
|
|
f << "\n but got "
|
|
<< x << " == " << y << "\n";
|
|
throw f;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// vim: syntax=cpp tabstop=4 shiftwidth=4 expandtab
|