ellipsis-contracts.h

Go to the documentation of this file.

#unit ellipsis∷contracts
#once
 
#ifndef DOXYGEN_SPECIAL
 
extern thread_local bool volatile ¤∷⸤ignore⸥∷⸤dynamic⸥;
extern thread_local bool volatile ¤∷⸤proceed⸥∷⸤dynamic⸥;
extern thread_local bool volatile ¤∷⸤verbose⸥∷⸤dynamic⸥;
 
typedef struct ellipsis∷contracts∷is_ice ellipsis∷contracts∷is_ice;
 
#endif
 
%%include <stdio.h>
%%include <stdlib.h>
%%include <stdint.h>
 
#include_directives <ellipsis-contracts-macros.h>
 
// Assert variants always have defined behavior. The expression must
// always parse correctly and generally leads to abortion, if not
// fulfilled. If the arguments are an ICE, the decision is taken at
// compile time; if it is unequal to zero, everything is optimized
// out. But the assertion can also be ignored and the continuation of
// the execution instead of abortion can be forced.
#define ELLIPSIS_CONTRACT_ASSERT_IMPL(CTYPE, COND, CSTR, ...)     \
  ELLIPSIS_CONTRACT(__COUNTER__, COND, abort, true, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__)
 
 
// Assume variants always have undefined behavior if the condition is
// not an ICE and doesn't hold. If the arguments are an ICE, the
// decision is taken at compile time; if it is unequal to zero,
// everything is optimized out. The expression is always evaluated. A
// verbose diagnostic in case of failure can be forced, after that,
// the behavior is UB, regardless.
#define ELLIPSIS_CONTRACT_ASSUME_IMPL(CTYPE, COND, CSTR, ...)     \
  ELLIPSIS_CONTRACT(__COUNTER__, COND, unreachable, false, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__)
 
#ifndef DOXYGEN_SPECIAL
 
%%define STRINGIFY(...) STRINGIFY_(__VA_ARGS__)
%%define STRINGIFY_(...) #__VA_ARGS__
 
%%define ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR, …)       \
({                                                                      \
  static char const contract_format_ ## COUNT[] =                       \
    ⸤__FILE__⸥ ":" ⸤STRINGIFY⸥(⸤__LINE__⸥) ": violation of " CTYPE " `" CSTR "`" __VA_OPT__(", ") __VA_ARGS__ "\n"; \
  (VERB                                                                 \
   ? fputs(contract_format_ ## COUNT, stderr)                           \
   : 0);                                                                \
 })
 
%%define ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE, …) \
((ellipsis_contracts_ignore() ∨ (COND))                                 \
 ? (void)0                                                              \
 : (ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR __VA_OPT__(,) __VA_ARGS__) \
    , (ellipsis_contracts_proceed()                                     \
       ? (void)0                                                        \
       : ACTION())))
 
// if argument is ICE, this is a ICE cast to void*, thus a NPC. The
// intermediate cast to uintptr_t is only here to silence overeager
// diagnostics that this might loose bits.
/* %%ifdef UINTPTR_MAX */
/* %% define CONV_SILENCE (uintptr_t) */
/* %%else */
/* %% define CONV_SILENCE */
/* %%endif */
%%define ELLIPSIS_TO_VOIDS(…) ((void*)((uintptr_t)((__VA_ARGS__)-(__VA_ARGS__))))
// if argument is ICE, this has type is_ice*. Otherwise void* but still is never evaluated.
%%define ELLIPSIS_TEST_ICE(…) (false ? ELLIPSIS_TO_VOIDS(__VA_ARGS__) : (ellipsis∷contracts∷is_ice*)nullptr)
 
// If argument is ICE, return the argument, otherwise return true
%%define ELLIPSIS_CONTRACT_ICE_OR_TRUE(...)                    \
  _Generic(                                                     \
           ELLIPSIS_TEST_ICE(__VA_ARGS__),                      \
           ellipsis∷contracts∷is_ice*: (__VA_ARGS__),    \
           default: true)
 
 
// if arguments are ICE of value 0, complain. Otherwise do never anything.
%%define ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR, ...) \
    ({                                                          \
      static_assert(ELLIPSIS_CONTRACT_ICE_OR_TRUE(COND),        \
                    "compile time violation of " CTYPE " " CSTR \
                    __VA_OPT__(", ") __VA_ARGS__ );             \
    })
 
 
// if arguments are ICE: if value is 0, error out at compile time;
// otherwise do nothing and optimize out. If arguments are not ICE,
// apply MACRO.
%%define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE,  …)  \
ELLIPSIS_MARK_LINE/*^ checking CTYPE CSTR ^*/                           \
  ⸤do {⸥                                                                \
    ⸤_Generic⸥(                                                         \
           ELLIPSIS_TEST_ICE(COND),                                     \
           ⸤ellipsis∷contracts∷is_ice*:⸥ ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR __VA_OPT__(,) __VA_ARGS__), \
           ⸤default:⸥ ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__)); \
    ⸤} while(false)⸥
 
#endif