[ViewVC] Diff of: cvs/libecb/ecb.h

Comparing libecb/ecb.h (file contents):
Revision 1.209 by root, Fri Mar 25 15:23:14 2022 UTC vs.
Revision 1.213 by root, Fri Mar 25 15:34:12 2022 UTC

 #define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
 #define ECB_STRINGIFY_(a) # a
 #define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
 #define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
+/* This marks larger functions that do not neccessarily need to be inlined */
+/* The idea is to possibly compile the header twice, */
+/* once exposing only the declarations, another time to define external functions */
+/* TODO: possibly static would be best for these at the moment? */
 #define ecb_function_ ecb_inline
 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
   #define ecb_attribute(attrlist)        __attribute__ (attrlist)
 #else
   #define ecb_ld64(x)       (ecb_clz64 (x) ^ 63)
   #define ecb_popcount32(x) __builtin_popcount (x)
   /* ecb_popcount64 is more difficult, see below */
 #else
   ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
-  ecb_function_ ecb_const int
+  ecb_function_ ecb_const int ecb_ctz32 (uint32_t x)
-  ecb_ctz32 (uint32_t x)
   {
 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
     unsigned long r;
     _BitScanForward (&r, x);
     return (int)r;
     return r;
 #endif
   }
   ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
-  ecb_function_ ecb_const int
+  ecb_function_ ecb_const int ecb_ctz64 (uint64_t x)
-  ecb_ctz64 (uint64_t x)
   {
 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
     unsigned long r;
     _BitScanForward64 (&r, x);
     return (int)r;
     return ecb_ctz32 (x >> shift) + shift;
 #endif
   }
   ecb_function_ ecb_const int ecb_clz32 (uint32_t x);
-  ecb_function_ ecb_const int
+  ecb_function_ ecb_const int ecb_clz32 (uint32_t x)
-  ecb_clz32 (uint32_t x)
   {
 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
     unsigned long r;
     _BitScanReverse (&r, x);
     return (int)r;
     return table [x >> 26];
 #endif
   }
   ecb_function_ ecb_const int ecb_clz64 (uint64_t x);
-  ecb_function_ ecb_const int
+  ecb_function_ ecb_const int ecb_clz64 (uint64_t x)
-  ecb_clz64 (uint64_t x)
   {
 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
     unsigned long r;
     _BitScanReverse64 (&r, x);
     return (int)r;
   return x;
 }
 ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
-ecb_function_ ecb_const int
+ecb_function_ ecb_const int ecb_popcount64 (uint64_t x)
-ecb_popcount64 (uint64_t x)
 {
   /* popcount64 is only available on 64 bit cpus as gcc builtin. */
   /* also, gcc/clang make this surprisingly difficult to use */
 #if (__SIZEOF_LONG__ == 8) && (ECB_GCC_VERSION(3,4) || ECB_CLANG_BUILTIN (__builtin_popcountl))
   return __builtin_popcountl (x);
   #define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
   #define ecb_bswap32(x) ((uint32_t)_byteswap_ulong  ((uint32_t)(x)))
   #define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
 #else
   ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
-  ecb_function_ ecb_const uint16_t
+  ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x)
-  ecb_bswap16 (uint16_t x)
   {
     return ecb_rotl16 (x, 8);
   }
   ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
-  ecb_function_ ecb_const uint32_t
+  ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x)
-  ecb_bswap32 (uint32_t x)
   {
     return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
   }
   ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
-  ecb_function_ ecb_const uint64_t
+  ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x)
-  ecb_bswap64 (uint64_t x)
   {
     return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
   }
 #endif
 /* try to tell the compiler that some condition is definitely true */
 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
 ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
-ecb_inline ecb_const uint32_t
+ecb_inline ecb_const uint32_t ecb_byteorder_helper (void)
-ecb_byteorder_helper (void)
 {
   /* the union code still generates code under pressure in gcc, */
   /* but less than using pointers, and always seems to */
   /* successfully return a constant. */
   /* the reason why we have this horrible preprocessor mess */
 #endif
 /*****************************************************************************/
 /* gray code */
-ecb_function_ uint_fast8_t  ecb_gray8_encode  (uint_fast8_t  b) { return b ^ (b >> 1); }
+ecb_inline uint_fast8_t  ecb_gray_encode8  (uint_fast8_t  b) { return b ^ (b >> 1); }
-ecb_function_ uint_fast16_t ecb_gray16_encode (uint_fast16_t b) { return b ^ (b >> 1); }
+ecb_inline uint_fast16_t ecb_gray_encode16 (uint_fast16_t b) { return b ^ (b >> 1); }
-ecb_function_ uint_fast32_t ecb_gray32_encode (uint_fast32_t b) { return b ^ (b >> 1); }
+ecb_inline uint_fast32_t ecb_gray_encode32 (uint_fast32_t b) { return b ^ (b >> 1); }
-ecb_function_ uint_fast64_t ecb_gray64_encode (uint_fast64_t b) { return b ^ (b >> 1); }
+ecb_inline uint_fast64_t ecb_gray_encode64 (uint_fast64_t b) { return b ^ (b >> 1); }
+ecb_function_ uint8_t ecb_gray_decode8 (uint8_t g);
-ecb_function_ uint8_t ecb_gray8_decode (uint8_t g)
+ecb_function_ uint8_t ecb_gray_decode8 (uint8_t g)
 {
   g ^= g >>  1;
   g ^= g >>  2;
   g ^= g >>  4;
   return g;
 }
+ecb_function_ uint16_t ecb_gray_decode16 (uint16_t g);
-ecb_function_ uint16_t ecb_gray16_decode (uint16_t g)
+ecb_function_ uint16_t ecb_gray_decode16 (uint16_t g)
 {
   g ^= g >>  1;
   g ^= g >>  2;
   g ^= g >>  4;
   g ^= g >>  8;
   return g;
 }
+ecb_function_ uint32_t ecb_gray_decode32 (uint32_t g);
-ecb_function_ uint32_t ecb_gray32_decode (uint32_t g)
+ecb_function_ uint32_t ecb_gray_decode32 (uint32_t g)
 {
   g ^= g >>  1;
   g ^= g >>  2;
   g ^= g >>  4;
   g ^= g >>  8;
   g ^= g >> 16;
   return g;
 }
+ecb_function_ uint64_t ecb_gray_decode64 (uint64_t g);
-ecb_function_ uint64_t ecb_gray64_decode (uint64_t g)
+ecb_function_ uint64_t ecb_gray_decode64 (uint64_t g)
 {
   g ^= g >>  1;
   g ^= g >>  2;
   g ^= g >>  4;
   g ^= g >>  8;
   return g;
 }
 #if ECB_CPP
-ecb_function_ uint8_t  ecb_gray_encode  (uint8_t  b) { return ecb_gray8_encode  (b); }
+ecb_inline uint8_t  ecb_gray_encode (uint8_t  b) { return ecb_gray_encode8  (b); }
-ecb_function_ uint16_t ecb_gray_encode  (uint16_t b) { return ecb_gray16_encode (b); }
+ecb_inline uint16_t ecb_gray_encode (uint16_t b) { return ecb_gray_encode16 (b); }
-ecb_function_ uint32_t ecb_gray_encode  (uint32_t b) { return ecb_gray32_encode (b); }
+ecb_inline uint32_t ecb_gray_encode (uint32_t b) { return ecb_gray_encode32 (b); }
-ecb_function_ uint64_t ecb_gray_encode  (uint64_t b) { return ecb_gray64_encode (b); }
+ecb_inline uint64_t ecb_gray_encode (uint64_t b) { return ecb_gray_encode64 (b); }
-ecb_function_ uint8_t  ecb_gray_decode  (uint8_t  g) { return ecb_gray8_decode  (g); }
+ecb_inline uint8_t  ecb_gray_decode (uint8_t  g) { return ecb_gray_decode8  (g); }
-ecb_function_ uint16_t ecb_gray_decode  (uint16_t g) { return ecb_gray16_decode (g); }
+ecb_inline uint16_t ecb_gray_decode (uint16_t g) { return ecb_gray_decode16 (g); }
-ecb_function_ uint32_t ecb_gray_decode  (uint32_t g) { return ecb_gray32_decode (g); }
+ecb_inline uint32_t ecb_gray_decode (uint32_t g) { return ecb_gray_decode32 (g); }
-ecb_function_ uint64_t ecb_gray_decode  (uint64_t g) { return ecb_gray64_decode (g); }
+ecb_inline uint64_t ecb_gray_decode (uint64_t g) { return ecb_gray_decode64 (g); }
 #endif
 /*****************************************************************************/
 /* 2d hilbert curves */
 /* algorithm from the book Hacker's Delight, modified to not */
 /* run into undefined behaviour for n==16 */
-static uint32_t
+static uint32_t ecb_hilbert2d_index_to_coord32 (int n, uint32_t s);
-ecb_hilbert2d_index_to_coord32 (int n, uint32_t s)
+static uint32_t ecb_hilbert2d_index_to_coord32 (int n, uint32_t s)
 {
   uint32_t comp, swap, cs, t, sr;
   /* pad s on the left (unused) bits with 01 (no change groups) */
   s |= 0x55555555U << n << n;
   /* now s contains two 16-bit coordinates */
   return s;
 }
 /* 64 bit, a straightforward extension to the 32 bit case */
-static uint64_t
+static uint64_t ecb_hilbert2d_index_to_coord64 (int n, uint64_t s);
-ecb_hilbert2d_index_to_coord64 (int n, uint64_t s)
+static uint64_t ecb_hilbert2d_index_to_coord64 (int n, uint64_t s)
 {
   uint64_t comp, swap, cs, t, sr;
   /* pad s on the left (unused) bits with 01 (no change groups) */
   s |= 0x5555555555555555U << n << n;
 }
 /* algorithm from the book Hacker's Delight, but a similar algorithm*/
 /* is given in https://doi.org/10.1002/spe.4380160103 */
 /* this has been slightly improved over the original version */
-ecb_function_ uint32_t
+ecb_function_ uint32_t ecb_hilbert2d_coord_to_index32 (int n, uint32_t xy);
-ecb_hilbert2d_coord_to_index32 (int n, uint32_t xy)
+ecb_function_ uint32_t ecb_hilbert2d_coord_to_index32 (int n, uint32_t xy)
 {
   uint32_t row;
   uint32_t state = 0;
   uint32_t s = 0;
   return s;
 }
 /* 64 bit, essentially the same as 32 bit */
-ecb_function_ uint64_t
+ecb_function_ uint64_t ecb_hilbert2d_coord_to_index64 (int n, uint64_t xy);
-ecb_hilbert2d_coord_to_index64 (int n, uint64_t xy)
+ecb_function_ uint64_t ecb_hilbert2d_coord_to_index64 (int n, uint64_t xy)
 {
   uint32_t row;
   uint32_t state = 0;
   uint64_t s = 0;
 /*****************************************************************************/
 /* IEEE 754-2008 half float conversions */
 ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
-ecb_function_ ecb_const uint32_t
+ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x)
-ecb_binary16_to_binary32 (uint32_t x)
 {
   unsigned int s = (x & 0x8000) << (31 - 15);
   int          e = (x >> 10) & 0x001f;
   unsigned int m =  x        & 0x03ff;
   return s | (e << 23) | (m << (23 - 10));
 }
 ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
-ecb_function_ ecb_const uint16_t
+ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x)
-ecb_binary32_to_binary16 (uint32_t x)
 {
   unsigned int s =  (x >> 16) & 0x00008000; /* sign bit, the easy part */
   int          e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
   unsigned int m =   x        & 0x007fffff;
 #define ECB_I2A_U32_DIGITS 10
 #define ECB_I2A_I64_DIGITS 20
 #define ECB_I2A_U64_DIGITS 21
 #define ECB_I2A_MAX_DIGITS 21
-ecb_inline char *
-ecb_i2a_u32 (char *ptr, uint32_t u)
+ecb_function_ char * ecb_i2a_u32 (char *ptr, uint32_t u)
+ecb_function_ char * ecb_i2a_u32 (char *ptr, uint32_t u)
 {
   #if ECB_64BIT_NATIVE
     if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
       ptr = ecb_i2a_x10 (ptr, u);
     else /* x10 almost, but not fully, covers 32 bit */
   #endif
   return ptr;
 }
-ecb_inline char *
+ecb_function_ char * ecb_i2a_i32 (char *ptr, int32_t v);
-ecb_i2a_i32 (char *ptr, int32_t v)
+ecb_function_ char * ecb_i2a_i32 (char *ptr, int32_t v)
 {
   *ptr = '-'; ptr += v < 0;
   uint32_t u = v < 0 ? -(uint32_t)v : v;
   #if ECB_64BIT_NATIVE
   #endif
   return ptr;
 }
-ecb_inline char *
+ecb_function_ char * ecb_i2a_u64 (char *ptr, uint64_t u);
-ecb_i2a_u64 (char *ptr, uint64_t u)
+ecb_function_ char * ecb_i2a_u64 (char *ptr, uint64_t u)
 {
   #if ECB_64BIT_NATIVE
     if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
       ptr = ecb_i2a_x10 (ptr, u);
     else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000))
   #endif
   return ptr;
 }
-ecb_inline char *
-ecb_i2a_i64 (char *ptr, int64_t v)
+ecb_function_ char * ecb_i2a_i64 (char *ptr, int64_t v)
+ecb_function_ char * ecb_i2a_i64 (char *ptr, int64_t v)
 {
   *ptr = '-'; ptr += v < 0;
   uint64_t u = v < 0 ? -(uint64_t)v : v;
   #if ECB_64BIT_NATIVE
     #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
   #endif
   /* convert a float to ieee single/binary32 */
   ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
-  ecb_function_ ecb_const uint32_t
+  ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x)
-  ecb_float_to_binary32 (float x)
   {
     uint32_t r;
     #if ECB_STDFP
       memcpy (&r, &x, 4);
     return r;
   }
   /* converts an ieee single/binary32 to a float */
   ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
-  ecb_function_ ecb_const float
+  ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x)
-  ecb_binary32_to_float (uint32_t x)
   {
     float r;
     #if ECB_STDFP
       memcpy (&r, &x, 4);
     return r;
   }
   /* convert a double to ieee double/binary64 */
   ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
-  ecb_function_ ecb_const uint64_t
+  ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x)
-  ecb_double_to_binary64 (double x)
   {
     uint64_t r;
     #if ECB_STDFP
       memcpy (&r, &x, 8);
     return r;
   }
   /* converts an ieee double/binary64 to a double */
   ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
-  ecb_function_ ecb_const double
+  ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x)
-  ecb_binary64_to_double (uint64_t x)
   {
     double r;
     #if ECB_STDFP
       memcpy (&r, &x, 8);
     return r;
   }
   /* convert a float to ieee half/binary16 */
   ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
-  ecb_function_ ecb_const uint16_t
+  ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x)
-  ecb_float_to_binary16 (float x)
   {
     return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
   }
   /* convert an ieee half/binary16 to float */
   ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
-  ecb_function_ ecb_const float
+  ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x)
-  ecb_binary16_to_float (uint16_t x)
   {
     return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
   }
 #endif

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libecb/ecb.h (file contents): Revision 1.209 by root, Fri Mar 25 15:23:14 2022 UTC vs. Revision 1.213 by root, Fri Mar 25 15:34:12 2022 UTC

Diff Legend

Comparing libecb/ecb.h (file contents):
Revision 1.209 by root, Fri Mar 25 15:23:14 2022 UTC vs.
Revision 1.213 by root, Fri Mar 25 15:34:12 2022 UTC