mirror of /home/gitosis/repositories/libev.git
*** empty log message ***
Marc Alexander Lehmann
parent
a5f210671e
commit
0682668768
1
Changes
1
Changes
|
|
@ -16,6 +16,7 @@ TODO: possible cb aliasing?
|
|||
TODO: document requirements for function pointers and calling conventions.
|
||||
|
||||
- prefer noexcept over throw () with C++ 11.
|
||||
- update ecb.h due to incompatibilities with c11.
|
||||
|
||||
4.19 Thu Sep 25 08:18:25 CEST 2014
|
||||
- ev.h wasn't valid C++ anymore, which tripped compilers other than
|
||||
|
|
|
|||
232
ev.c
232
ev.c
|
|
@ -493,7 +493,7 @@ struct signalfd_siginfo
|
|||
/*
|
||||
* libecb - http://software.schmorp.de/pkg/libecb
|
||||
*
|
||||
* Copyright (©) 2009-2014 Marc Alexander Lehmann <libecb@schmorp.de>
|
||||
* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
|
||||
* Copyright (©) 2011 Emanuele Giaquinta
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -534,7 +534,7 @@ struct signalfd_siginfo
|
|||
#define ECB_H
|
||||
|
||||
/* 16 bits major, 16 bits minor */
|
||||
#define ECB_VERSION 0x00010003
|
||||
#define ECB_VERSION 0x00010004
|
||||
|
||||
#ifdef _WIN32
|
||||
typedef signed char int8_t;
|
||||
|
|
@ -584,12 +584,24 @@ struct signalfd_siginfo
|
|||
* we try to detect these and simply assume they are not gcc - if they have
|
||||
* an issue with that they should have done it right in the first place.
|
||||
*/
|
||||
#ifndef ECB_GCC_VERSION
|
||||
#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
|
||||
#define ECB_GCC_VERSION(major,minor) 0
|
||||
#else
|
||||
#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
|
||||
#endif
|
||||
#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
|
||||
#define ECB_GCC_VERSION(major,minor) 0
|
||||
#else
|
||||
#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
|
||||
#endif
|
||||
|
||||
#define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
|
||||
|
||||
#if __clang__ && defined __has_builtin
|
||||
#define ECB_CLANG_BUILTIN(x) __has_builtin (x)
|
||||
#else
|
||||
#define ECB_CLANG_BUILTIN(x) 0
|
||||
#endif
|
||||
|
||||
#if __clang__ && defined __has_extension
|
||||
#define ECB_CLANG_EXTENSION(x) __has_extension (x)
|
||||
#else
|
||||
#define ECB_CLANG_EXTENSION(x) 0
|
||||
#endif
|
||||
|
||||
#define ECB_CPP (__cplusplus+0)
|
||||
|
|
@ -683,16 +695,11 @@ struct signalfd_siginfo
|
|||
#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
|
||||
#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
|
||||
|
||||
/* The __has_feature syntax from clang is so misdesigned that we cannot use it
|
||||
* without risking compile time errors with other compilers. We *could*
|
||||
* define our own ecb_clang_has_feature, but I just can't be bothered to work
|
||||
* around this shit time and again.
|
||||
* #elif defined __clang && __has_feature (cxx_atomic)
|
||||
* // see comment below (stdatomic.h) about the C11 memory model.
|
||||
* #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
|
||||
* #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
|
||||
* #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
|
||||
*/
|
||||
#elif ECB_CLANG_EXTENSION(c_atomic)
|
||||
/* see comment below (stdatomic.h) about the C11 memory model. */
|
||||
#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
|
||||
#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
|
||||
#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
|
||||
|
||||
#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
|
||||
#define ECB_MEMORY_FENCE __sync_synchronize ()
|
||||
|
|
@ -765,7 +772,7 @@ struct signalfd_siginfo
|
|||
|
||||
/*****************************************************************************/
|
||||
|
||||
#if __cplusplus
|
||||
#if ECB_CPP
|
||||
#define ecb_inline static inline
|
||||
#elif ECB_GCC_VERSION(2,5)
|
||||
#define ecb_inline static __inline__
|
||||
|
|
@ -792,32 +799,45 @@ typedef int ecb_bool;
|
|||
|
||||
#define ecb_function_ ecb_inline
|
||||
|
||||
#if ECB_GCC_VERSION(3,1)
|
||||
#define ecb_attribute(attrlist) __attribute__(attrlist)
|
||||
#define ecb_is_constant(expr) __builtin_constant_p (expr)
|
||||
#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
|
||||
#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
|
||||
#if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
|
||||
#define ecb_attribute(attrlist) __attribute__ (attrlist)
|
||||
#else
|
||||
#define ecb_attribute(attrlist)
|
||||
#endif
|
||||
|
||||
#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
|
||||
#define ecb_is_constant(expr) __builtin_constant_p (expr)
|
||||
#else
|
||||
/* possible C11 impl for integral types
|
||||
typedef struct ecb_is_constant_struct ecb_is_constant_struct;
|
||||
#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
|
||||
|
||||
#define ecb_is_constant(expr) 0
|
||||
#endif
|
||||
|
||||
#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
|
||||
#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
|
||||
#else
|
||||
#define ecb_expect(expr,value) (expr)
|
||||
#endif
|
||||
|
||||
#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
|
||||
#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
|
||||
#else
|
||||
#define ecb_prefetch(addr,rw,locality)
|
||||
#endif
|
||||
|
||||
/* no emulation for ecb_decltype */
|
||||
#if ECB_GCC_VERSION(4,5)
|
||||
#define ecb_decltype(x) __decltype(x)
|
||||
#elif ECB_GCC_VERSION(3,0)
|
||||
#define ecb_decltype(x) __typeof(x)
|
||||
#if ECB_CPP11
|
||||
// older implementations might have problems with decltype(x)::type, work around it
|
||||
template<class T> struct ecb_decltype_t { typedef T type; };
|
||||
#define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
|
||||
#elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
|
||||
#define ecb_decltype(x) __typeof__ (x)
|
||||
#endif
|
||||
|
||||
#if _MSC_VER >= 1300
|
||||
#define ecb_deprecated __declspec(deprecated)
|
||||
#define ecb_deprecated __declspec (deprecated)
|
||||
#else
|
||||
#define ecb_deprecated ecb_attribute ((__deprecated__))
|
||||
#endif
|
||||
|
|
@ -827,8 +847,9 @@ typedef int ecb_bool;
|
|||
#define ecb_const ecb_attribute ((__const__))
|
||||
#define ecb_pure ecb_attribute ((__pure__))
|
||||
|
||||
/* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx __declspec(noreturn) */
|
||||
#if ECB_C11
|
||||
/* TODO http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx __declspec(noreturn) */
|
||||
#if ECB_C11 || __IBMC_NORETURN
|
||||
/* http://pic.dhe.ibm.com/infocenter/compbg/v121v141/topic/com.ibm.xlcpp121.bg.doc/language_ref/noreturn.html */
|
||||
#define ecb_noreturn _Noreturn
|
||||
#else
|
||||
#define ecb_noreturn ecb_attribute ((__noreturn__))
|
||||
|
|
@ -854,7 +875,10 @@ typedef int ecb_bool;
|
|||
#define ecb_unlikely(expr) ecb_expect_false (expr)
|
||||
|
||||
/* count trailing zero bits and count # of one bits */
|
||||
#if ECB_GCC_VERSION(3,4)
|
||||
#if ECB_GCC_VERSION(3,4) \
|
||||
|| (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
|
||||
&& ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
|
||||
&& ECB_CLANG_BUILTIN(__builtin_popcount))
|
||||
/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
|
||||
#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
|
||||
#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
|
||||
|
|
@ -863,8 +887,8 @@ typedef int ecb_bool;
|
|||
#define ecb_popcount32(x) __builtin_popcount (x)
|
||||
/* no popcountll */
|
||||
#else
|
||||
ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
|
||||
ecb_function_ int
|
||||
ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
|
||||
ecb_function_ ecb_const int
|
||||
ecb_ctz32 (uint32_t x)
|
||||
{
|
||||
int r = 0;
|
||||
|
|
@ -888,16 +912,16 @@ typedef int ecb_bool;
|
|||
return r;
|
||||
}
|
||||
|
||||
ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
|
||||
ecb_function_ int
|
||||
ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
|
||||
ecb_function_ ecb_const int
|
||||
ecb_ctz64 (uint64_t x)
|
||||
{
|
||||
int shift = x & 0xffffffffU ? 0 : 32;
|
||||
return ecb_ctz32 (x >> shift) + shift;
|
||||
}
|
||||
|
||||
ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
|
||||
ecb_function_ int
|
||||
ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
|
||||
ecb_function_ ecb_const int
|
||||
ecb_popcount32 (uint32_t x)
|
||||
{
|
||||
x -= (x >> 1) & 0x55555555;
|
||||
|
|
@ -908,8 +932,8 @@ typedef int ecb_bool;
|
|||
return x >> 24;
|
||||
}
|
||||
|
||||
ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
|
||||
ecb_function_ int ecb_ld32 (uint32_t x)
|
||||
ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
|
||||
ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
|
|
@ -922,8 +946,8 @@ typedef int ecb_bool;
|
|||
return r;
|
||||
}
|
||||
|
||||
ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
|
||||
ecb_function_ int ecb_ld64 (uint64_t x)
|
||||
ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
|
||||
ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
|
|
@ -933,20 +957,20 @@ typedef int ecb_bool;
|
|||
}
|
||||
#endif
|
||||
|
||||
ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
|
||||
ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
|
||||
ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
|
||||
ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
|
||||
ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
|
||||
ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
|
||||
ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
|
||||
ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
|
||||
|
||||
ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
|
||||
ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
|
||||
ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
|
||||
ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
|
||||
{
|
||||
return ( (x * 0x0802U & 0x22110U)
|
||||
| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
|
||||
| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
|
||||
}
|
||||
|
||||
ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;
|
||||
ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
|
||||
ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
|
||||
ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
|
||||
{
|
||||
x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
|
||||
x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
|
||||
|
|
@ -956,8 +980,8 @@ ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
|
|||
return x;
|
||||
}
|
||||
|
||||
ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;
|
||||
ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
|
||||
ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
|
||||
ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
|
||||
{
|
||||
x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
|
||||
x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
|
||||
|
|
@ -970,71 +994,71 @@ ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
|
|||
|
||||
/* popcount64 is only available on 64 bit cpus as gcc builtin */
|
||||
/* so for this version we are lazy */
|
||||
ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
|
||||
ecb_function_ int
|
||||
ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
|
||||
ecb_function_ ecb_const int
|
||||
ecb_popcount64 (uint64_t x)
|
||||
{
|
||||
return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
|
||||
}
|
||||
|
||||
ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
|
||||
ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
|
||||
ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
|
||||
ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
|
||||
|
||||
ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
|
||||
ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
|
||||
ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
|
||||
ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
|
||||
ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
|
||||
ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
|
||||
ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
|
||||
ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
|
||||
ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
|
||||
ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
|
||||
ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
|
||||
ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
|
||||
ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
|
||||
ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
|
||||
ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
|
||||
ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
|
||||
|
||||
#if ECB_GCC_VERSION(4,3)
|
||||
#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
|
||||
#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
|
||||
#define ecb_bswap32(x) __builtin_bswap32 (x)
|
||||
#define ecb_bswap64(x) __builtin_bswap64 (x)
|
||||
#else
|
||||
ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
|
||||
ecb_function_ uint16_t
|
||||
ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
|
||||
ecb_function_ ecb_const uint16_t
|
||||
ecb_bswap16 (uint16_t x)
|
||||
{
|
||||
return ecb_rotl16 (x, 8);
|
||||
}
|
||||
|
||||
ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
|
||||
ecb_function_ uint32_t
|
||||
ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
|
||||
ecb_function_ ecb_const uint32_t
|
||||
ecb_bswap32 (uint32_t x)
|
||||
{
|
||||
return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
|
||||
}
|
||||
|
||||
ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
|
||||
ecb_function_ uint64_t
|
||||
ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
|
||||
ecb_function_ ecb_const uint64_t
|
||||
ecb_bswap64 (uint64_t x)
|
||||
{
|
||||
return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ECB_GCC_VERSION(4,5)
|
||||
#if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
|
||||
#define ecb_unreachable() __builtin_unreachable ()
|
||||
#else
|
||||
/* this seems to work fine, but gcc always emits a warning for it :/ */
|
||||
ecb_inline void ecb_unreachable (void) ecb_noreturn;
|
||||
ecb_inline void ecb_unreachable (void) { }
|
||||
ecb_inline ecb_noreturn void ecb_unreachable (void);
|
||||
ecb_inline ecb_noreturn void ecb_unreachable (void) { }
|
||||
#endif
|
||||
|
||||
/* try to tell the compiler that some condition is definitely true */
|
||||
#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
|
||||
|
||||
ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
|
||||
ecb_inline unsigned char
|
||||
ecb_inline ecb_const unsigned char ecb_byteorder_helper (void);
|
||||
ecb_inline ecb_const unsigned char
|
||||
ecb_byteorder_helper (void)
|
||||
{
|
||||
/* the union code still generates code under pressure in gcc, */
|
||||
|
|
@ -1059,10 +1083,10 @@ ecb_byteorder_helper (void)
|
|||
#endif
|
||||
}
|
||||
|
||||
ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
|
||||
ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
|
||||
ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
|
||||
ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
|
||||
ecb_inline ecb_const ecb_bool ecb_big_endian (void);
|
||||
ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
|
||||
ecb_inline ecb_const ecb_bool ecb_little_endian (void);
|
||||
ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
|
||||
|
||||
#if ECB_GCC_VERSION(3,0) || ECB_C99
|
||||
#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
|
||||
|
|
@ -1070,7 +1094,7 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
|
||||
#endif
|
||||
|
||||
#if __cplusplus
|
||||
#if ECB_CPP
|
||||
template<typename T>
|
||||
static inline T ecb_div_rd (T val, T div)
|
||||
{
|
||||
|
|
@ -1140,17 +1164,23 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
#define ECB_NAN ECB_INFINITY
|
||||
#endif
|
||||
|
||||
#if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
|
||||
#define ecb_ldexpf(x,e) ldexpf ((x), (e))
|
||||
#else
|
||||
#define ecb_ldexpf(x,e) (float) ldexp ((x), (e))
|
||||
#endif
|
||||
|
||||
/* converts an ieee half/binary16 to a float */
|
||||
ecb_function_ float ecb_binary16_to_float (uint16_t x) ecb_const;
|
||||
ecb_function_ float
|
||||
ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
|
||||
ecb_function_ ecb_const float
|
||||
ecb_binary16_to_float (uint16_t x)
|
||||
{
|
||||
int e = (x >> 10) & 0x1f;
|
||||
int m = x & 0x3ff;
|
||||
float r;
|
||||
|
||||
if (!e ) r = ldexpf (m , -24);
|
||||
else if (e != 31) r = ldexpf (m + 0x400, e - 25);
|
||||
if (!e ) r = ecb_ldexpf (m , -24);
|
||||
else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
|
||||
else if (m ) r = ECB_NAN;
|
||||
else r = ECB_INFINITY;
|
||||
|
||||
|
|
@ -1158,8 +1188,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
}
|
||||
|
||||
/* convert a float to ieee single/binary32 */
|
||||
ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
|
||||
ecb_function_ uint32_t
|
||||
ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
|
||||
ecb_function_ ecb_const uint32_t
|
||||
ecb_float_to_binary32 (float x)
|
||||
{
|
||||
uint32_t r;
|
||||
|
|
@ -1198,8 +1228,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
}
|
||||
|
||||
/* converts an ieee single/binary32 to a float */
|
||||
ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
|
||||
ecb_function_ float
|
||||
ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
|
||||
ecb_function_ ecb_const float
|
||||
ecb_binary32_to_float (uint32_t x)
|
||||
{
|
||||
float r;
|
||||
|
|
@ -1219,7 +1249,7 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
e = 1;
|
||||
|
||||
/* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
|
||||
r = ldexpf (x * (0.5f / 0x800000U), e - 126);
|
||||
r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
|
||||
|
||||
r = neg ? -r : r;
|
||||
#endif
|
||||
|
|
@ -1228,8 +1258,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
}
|
||||
|
||||
/* convert a double to ieee double/binary64 */
|
||||
ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
|
||||
ecb_function_ uint64_t
|
||||
ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
|
||||
ecb_function_ ecb_const uint64_t
|
||||
ecb_double_to_binary64 (double x)
|
||||
{
|
||||
uint64_t r;
|
||||
|
|
@ -1268,8 +1298,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
|
|||
}
|
||||
|
||||
/* converts an ieee double/binary64 to a double */
|
||||
ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
|
||||
ecb_function_ double
|
||||
ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
|
||||
ecb_function_ ecb_const double
|
||||
ecb_binary64_to_double (uint64_t x)
|
||||
{
|
||||
double r;
|
||||
|
|
|
|||
Loading…
Reference in New Issue