ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libecb/ecb.h
(Generate patch)

Comparing libecb/ecb.h (file contents):
Revision 1.180 by root, Mon Jan 20 13:13:56 2020 UTC vs.
Revision 1.192 by root, Mon Jun 21 23:59:58 2021 UTC

1/* 1/*
2 * libecb - http://software.schmorp.de/pkg/libecb 2 * libecb - http://software.schmorp.de/pkg/libecb
3 * 3 *
4 * Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de> 4 * Copyright (©) 2009-2015,2018-2021 Marc Alexander Lehmann <libecb@schmorp.de>
5 * Copyright (©) 2011 Emanuele Giaquinta 5 * Copyright (©) 2011 Emanuele Giaquinta
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without modifica- 8 * Redistribution and use in source and binary forms, with or without modifica-
9 * tion, are permitted provided that the following conditions are met: 9 * tion, are permitted provided that the following conditions are met:
… …
40 40
41#ifndef ECB_H 41#ifndef ECB_H
42#define ECB_H 42#define ECB_H
43 43
44/* 16 bits major, 16 bits minor */ 44/* 16 bits major, 16 bits minor */
45#define ECB_VERSION 0x00010008 45#define ECB_VERSION 0x00010009
46 46
47#ifdef _WIN32 47#include <string.h> /* for memcpy */
48
49#if defined (_WIN32) && !defined (__MINGW32__)
48 typedef signed char int8_t; 50 typedef signed char int8_t;
49 typedef unsigned char uint8_t; 51 typedef unsigned char uint8_t;
50 typedef signed char int_fast8_t; 52 typedef signed char int_fast8_t;
51 typedef unsigned char uint_fast8_t; 53 typedef unsigned char uint_fast8_t;
52 typedef signed short int16_t; 54 typedef signed short int16_t;
… …
100 #if _ILP32 102 #if _ILP32
101 #define ECB_AMD64_X32 1 103 #define ECB_AMD64_X32 1
102 #else 104 #else
103 #define ECB_AMD64 1 105 #define ECB_AMD64 1
104 #endif 106 #endif
107#endif
108
109#if ECB_PTRSIZE >= 8 || ECB_AMD64_X32
110 #define ECB_64BIT_NATIVE 1
111#else
112 #define ECB_64BIT_NATIVE 0
105#endif 113#endif
106 114
107/* many compilers define _GNUC_ to some versions but then only implement 115/* many compilers define _GNUC_ to some versions but then only implement
108 * what their idiot authors think are the "more important" extensions, 116 * what their idiot authors think are the "more important" extensions,
109 * causing enormous grief in return for some better fake benchmark numbers. 117 * causing enormous grief in return for some better fake benchmark numbers.
… …
240 #if ECB_GCC_VERSION(4,7) 248 #if ECB_GCC_VERSION(4,7)
241 /* see comment below (stdatomic.h) about the C11 memory model. */ 249 /* see comment below (stdatomic.h) about the C11 memory model. */
242 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 250 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
243 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE) 251 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
244 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE) 252 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
253 #undef ECB_MEMORY_FENCE_RELAXED
245 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED) 254 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
246 255
247 #elif ECB_CLANG_EXTENSION(c_atomic) 256 #elif ECB_CLANG_EXTENSION(c_atomic)
248 /* see comment below (stdatomic.h) about the C11 memory model. */ 257 /* see comment below (stdatomic.h) about the C11 memory model. */
249 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 258 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
250 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE) 259 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
251 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE) 260 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
261 #undef ECB_MEMORY_FENCE_RELAXED
252 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED) 262 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
253 263
254 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 264 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
255 #define ECB_MEMORY_FENCE __sync_synchronize () 265 #define ECB_MEMORY_FENCE __sync_synchronize ()
256 #elif _MSC_VER >= 1500 /* VC++ 2008 */ 266 #elif _MSC_VER >= 1500 /* VC++ 2008 */
… …
608ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); } 618ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
609ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); } 619ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
610ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); } 620ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
611ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); } 621ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
612 622
623#if ECB_CPP
624
625inline uint8_t ecb_ctz (uint8_t v) { return ecb_ctz32 (v); }
626inline uint16_t ecb_ctz (uint16_t v) { return ecb_ctz32 (v); }
627inline uint32_t ecb_ctz (uint32_t v) { return ecb_ctz32 (v); }
628inline uint64_t ecb_ctz (uint64_t v) { return ecb_ctz64 (v); }
629
630inline bool ecb_is_pot (uint8_t v) { return ecb_is_pot32 (v); }
631inline bool ecb_is_pot (uint16_t v) { return ecb_is_pot32 (v); }
632inline bool ecb_is_pot (uint32_t v) { return ecb_is_pot32 (v); }
633inline bool ecb_is_pot (uint64_t v) { return ecb_is_pot64 (v); }
634
635inline int ecb_ld (uint8_t v) { return ecb_ld32 (v); }
636inline int ecb_ld (uint16_t v) { return ecb_ld32 (v); }
637inline int ecb_ld (uint32_t v) { return ecb_ld32 (v); }
638inline int ecb_ld (uint64_t v) { return ecb_ld64 (v); }
639
640inline int ecb_popcount (uint8_t v) { return ecb_popcount32 (v); }
641inline int ecb_popcount (uint16_t v) { return ecb_popcount32 (v); }
642inline int ecb_popcount (uint32_t v) { return ecb_popcount32 (v); }
643inline int ecb_popcount (uint64_t v) { return ecb_popcount64 (v); }
644
645inline uint8_t ecb_bitrev (uint8_t v) { return ecb_bitrev8 (v); }
646inline uint16_t ecb_bitrev (uint16_t v) { return ecb_bitrev16 (v); }
647inline uint32_t ecb_bitrev (uint32_t v) { return ecb_bitrev32 (v); }
648
649inline uint8_t ecb_rotl (uint8_t v, unsigned int count) { return ecb_rotl8 (v, count); }
650inline uint16_t ecb_rotl (uint16_t v, unsigned int count) { return ecb_rotl16 (v, count); }
651inline uint32_t ecb_rotl (uint32_t v, unsigned int count) { return ecb_rotl32 (v, count); }
652inline uint64_t ecb_rotl (uint64_t v, unsigned int count) { return ecb_rotl64 (v, count); }
653
654inline uint8_t ecb_rotr (uint8_t v, unsigned int count) { return ecb_rotr8 (v, count); }
655inline uint16_t ecb_rotr (uint16_t v, unsigned int count) { return ecb_rotr16 (v, count); }
656inline uint32_t ecb_rotr (uint32_t v, unsigned int count) { return ecb_rotr32 (v, count); }
657inline uint64_t ecb_rotr (uint64_t v, unsigned int count) { return ecb_rotr64 (v, count); }
658
659#endif
660
613#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64)) 661#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
614 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16) 662 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
615 #define ecb_bswap16(x) __builtin_bswap16 (x) 663 #define ecb_bswap16(x) __builtin_bswap16 (x)
616 #else 664 #else
617 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16) 665 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
… …
731 779
732ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); } 780ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
733ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); } 781ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
734ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); } 782ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
735 783
736#ifdef __cplusplus 784#if ECB_CPP
737 785
738inline uint8_t ecb_bswap (uint8_t v) { return v; } 786inline uint8_t ecb_bswap (uint8_t v) { return v; }
739inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); } 787inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
740inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); } 788inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
741inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); } 789inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
… …
743template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; } 791template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
744template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; } 792template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
745template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; } 793template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
746template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); } 794template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
747template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); } 795template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
748template<typename T> inline T ecb_peek_u (const void *ptr) { T v; std::memcpy (&v, ptr, sizeof (v)); return v; } 796template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
749template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); } 797template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
750template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); } 798template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
751 799
752template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; } 800template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
753template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; } 801template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
754template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; } 802template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
755template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); } 803template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
756template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); } 804template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
757template<typename T> inline void ecb_poke_u (void *ptr, T v) { std::memcpy (ptr, &v, sizeof (v)); } 805template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (v)); }
758template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); } 806template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
759template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); } 807template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
760 808
761#endif 809#endif
762 810
763/*****************************************************************************/ 811/*****************************************************************************/
812/* division */
764 813
765#if ECB_GCC_VERSION(3,0) || ECB_C99 814#if ECB_GCC_VERSION(3,0) || ECB_C99
815 /* C99 tightened the definition of %, so we can use a more efficient version */
766 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0)) 816 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
767#else 817#else
768 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n))) 818 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
769#endif 819#endif
770 820
… …
781 } 831 }
782#else 832#else
783 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div)) 833 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
784 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div)) 834 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
785#endif 835#endif
836
837/*****************************************************************************/
838/* array length */
786 839
787#if ecb_cplusplus_does_not_suck 840#if ecb_cplusplus_does_not_suck
788 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */ 841 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
789 template<typename T, int N> 842 template<typename T, int N>
790 static inline int ecb_array_length (const T (&arr)[N]) 843 static inline int ecb_array_length (const T (&arr)[N])
… …
794#else 847#else
795 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 848 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
796#endif 849#endif
797 850
798/*****************************************************************************/ 851/*****************************************************************************/
852/* IEEE 754-2008 half float conversions */
799 853
800ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x); 854ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
801ecb_function_ ecb_const uint32_t 855ecb_function_ ecb_const uint32_t
802ecb_binary16_to_binary32 (uint32_t x) 856ecb_binary16_to_binary32 (uint32_t x)
803{ 857{
… …
832ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x); 886ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
833ecb_function_ ecb_const uint16_t 887ecb_function_ ecb_const uint16_t
834ecb_binary32_to_binary16 (uint32_t x) 888ecb_binary32_to_binary16 (uint32_t x)
835{ 889{
836 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */ 890 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
837 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */ 891 int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
838 unsigned int m = x & 0x007fffff; 892 unsigned int m = x & 0x007fffff;
839 893
840 x &= 0x7fffffff; 894 x &= 0x7fffffff;
841 895
842 /* if it's within range of binary16 normals, use fast path */ 896 /* if it's within range of binary16 normals, use fast path */
… …
889 943
890 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */ 944 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
891 m >>= 13; 945 m >>= 13;
892 946
893 return s | 0x7c00 | m | !m; 947 return s | 0x7c00 | m | !m;
948}
949
950/*******************************************************************************/
951/* fast integer to ascii */
952
953// simply return a mask with "bits" bits set
954#define ecb_i2a_mask(type,bits) ((((type)1) << (bits)) - 1)
955
956// oputput a single digit. maskvalue is 10**digitidx
957#define ecb_i2a_digit(type,bits,digitmask,maskvalue,digitidx) \
958 if (digitmask >= maskvalue) /* constant, used to decide how many digits to generate */ \
959 { \
960 char digit = x >> (bits - digitidx); /* calculate the topmost digit */ \
961 *ptr = digit + '0'; /* output it */ \
962 nz = (digitmask == maskvalue) || nz || digit; /* first term == always output last digit */ \
963 ptr += nz; /* output digit only if non-zero digit seen */ \
964 x = (x & ecb_i2a_mask (type, bits - digitidx)) * 5; /* *10, but shift decimal point right */ \
965 }
966
967// convert integer to fixed point format and multiply out digits, highest first
968// requires magic constants: max. digits and number of bits after the decimal point
969#define ecb_i2a_def(suffix,ptr,v,type,bits,digitmask,lz) \
970ecb_inline char *ecb_i2a_ ## suffix (char *ptr, uint32_t u) \
971{ \
972 char nz = lz; /* non-zero digit seen? */ \
973 /* convert to x.bits fixed-point */ \
974 type x = u * ((ecb_i2a_mask (type, bits) + digitmask) / digitmask); \
975 /* output up to 10 digits */ \
976 ecb_i2a_digit (type,bits,digitmask, 1, 0); \
977 ecb_i2a_digit (type,bits,digitmask, 10, 1); \
978 ecb_i2a_digit (type,bits,digitmask, 100, 2); \
979 ecb_i2a_digit (type,bits,digitmask, 1000, 3); \
980 ecb_i2a_digit (type,bits,digitmask, 10000, 4); \
981 ecb_i2a_digit (type,bits,digitmask, 100000, 5); \
982 ecb_i2a_digit (type,bits,digitmask, 1000000, 6); \
983 ecb_i2a_digit (type,bits,digitmask, 10000000, 7); \
984 ecb_i2a_digit (type,bits,digitmask, 100000000, 8); \
985 ecb_i2a_digit (type,bits,digitmask, 1000000000, 9); \
986 return ptr; \
987}
988
989// predefined versions of the above, for various digits
990// ecb_i2a_xN = almost N digits, limit defined by macro
991// ecb_i2a_N = up to N digits, leading zeroes suppressed
992// ecb_i2a_0N = exactly N digits, including leading zeroes
993
994// non-leading-zero versions, limited range
995#define ECB_I2A_MAX_X5 59074 // limit for ecb_i2a_x5
996#define ECB_I2A_MAX_X10 2932500665 // limit for ecb_i2a_x10
997ecb_i2a_def ( x5, ptr, v, uint32_t, 26, 10000, 0)
998ecb_i2a_def (x10, ptr, v, uint64_t, 60, 1000000000, 0)
999
1000// non-leading zero versions, all digits, 4 and 9 are optimal for 32/64 bit
1001ecb_i2a_def ( 2, ptr, v, uint32_t, 10, 10, 0)
1002ecb_i2a_def ( 3, ptr, v, uint32_t, 12, 100, 0)
1003ecb_i2a_def ( 4, ptr, v, uint32_t, 26, 1000, 0)
1004ecb_i2a_def ( 5, ptr, v, uint64_t, 30, 10000, 0)
1005ecb_i2a_def ( 6, ptr, v, uint64_t, 36, 100000, 0)
1006ecb_i2a_def ( 7, ptr, v, uint64_t, 44, 1000000, 0)
1007ecb_i2a_def ( 8, ptr, v, uint64_t, 50, 10000000, 0)
1008ecb_i2a_def ( 9, ptr, v, uint64_t, 56, 100000000, 0)
1009
1010// leading-zero versions, all digits, 04 and 09 are optimal for 32/64 bit
1011ecb_i2a_def (02, ptr, v, uint32_t, 10, 10, 1)
1012ecb_i2a_def (03, ptr, v, uint32_t, 12, 100, 1)
1013ecb_i2a_def (04, ptr, v, uint32_t, 26, 1000, 1)
1014ecb_i2a_def (05, ptr, v, uint64_t, 30, 10000, 1)
1015ecb_i2a_def (06, ptr, v, uint64_t, 36, 100000, 1)
1016ecb_i2a_def (07, ptr, v, uint64_t, 44, 1000000, 1)
1017ecb_i2a_def (08, ptr, v, uint64_t, 50, 10000000, 1)
1018ecb_i2a_def (09, ptr, v, uint64_t, 56, 100000000, 1)
1019
1020#define ECB_I2A_I32_DIGITS 11
1021#define ECB_I2A_U32_DIGITS 10
1022#define ECB_I2A_I64_DIGITS 20
1023#define ECB_I2A_U32_DIGITS 21
1024#define ECB_I2A_DIGITS 21
1025
1026ecb_inline char *
1027ecb_i2a_u32 (char *ptr, uint32_t u)
1028{
1029 #if ECB_64BIT_NATIVE
1030 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1031 ptr = ecb_i2a_x10 (ptr, u);
1032 else // x10 almost, but not fully, covers 32 bit
1033 {
1034 uint32_t u1 = u % 1000000000;
1035 uint32_t u2 = u / 1000000000;
1036
1037 *ptr++ = u2 + '0';
1038 ptr = ecb_i2a_09 (ptr, u1);
1039 }
1040 #else
1041 if (ecb_expect_true (u <= ECB_I2A_MAX_X5))
1042 ecb_i2a_x5 (ptr, u);
1043 else if (ecb_expect_true (u <= ECB_I2A_MAX_X5 * 10000))
1044 {
1045 uint32_t u1 = u % 10000;
1046 uint32_t u2 = u / 10000;
1047
1048 ptr = ecb_i2a_x5 (ptr, u2);
1049 ptr = ecb_i2a_04 (ptr, u1);
1050 }
1051 else
1052 {
1053 uint32_t u1 = u % 10000;
1054 uint32_t ua = u / 10000;
1055 uint32_t u2 = ua % 10000;
1056 uint32_t u3 = ua / 10000;
1057
1058 ptr = ecb_i2a_2 (ptr, u3);
1059 ptr = ecb_i2a_04 (ptr, u2);
1060 ptr = ecb_i2a_04 (ptr, u1);
1061 }
1062 #endif
1063
1064 return ptr;
1065}
1066
1067ecb_inline char *
1068ecb_i2a_i32 (char *ptr, int32_t v)
1069{
1070 *ptr = '-'; ptr += v < 0;
1071 uint32_t u = v < 0 ? -(uint32_t)v : v;
1072
1073 #if ECB_64BIT_NATIVE
1074 ptr = ecb_i2a_x10 (ptr, u); // x10 fully covers 31 bit
1075 #else
1076 ptr = ecb_i2a_u32 (ptr, u);
1077 #endif
1078
1079 return ptr;
1080}
1081
1082ecb_inline char *
1083ecb_i2a_u64 (char *ptr, uint64_t u)
1084{
1085 #if ECB_64BIT_NATIVE
1086 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1087 ptr = ecb_i2a_x10 (ptr, u);
1088 else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000))
1089 {
1090 uint64_t u1 = u % 1000000000;
1091 uint64_t u2 = u / 1000000000;
1092
1093 ptr = ecb_i2a_x10 (ptr, u2);
1094 ptr = ecb_i2a_09 (ptr, u1);
1095 }
1096 else
1097 {
1098 uint64_t u1 = u % 1000000000;
1099 uint64_t ua = u / 1000000000;
1100 uint64_t u2 = ua % 1000000000;
1101 uint64_t u3 = ua / 1000000000;
1102
1103 ptr = ecb_i2a_2 (ptr, u3);
1104 ptr = ecb_i2a_09 (ptr, u2);
1105 ptr = ecb_i2a_09 (ptr, u1);
1106 }
1107 #else
1108 if (ecb_expect_true (u <= ECB_I2A_MAX_X5))
1109 ptr = ecb_i2a_x5 (ptr, u);
1110 else
1111 {
1112 uint64_t u1 = u % 10000;
1113 uint64_t u2 = u / 10000;
1114
1115 ptr = ecb_i2a_u64 (ptr, u2);
1116 ptr = ecb_i2a_04 (ptr, u1);
1117 }
1118 #endif
1119
1120 return ptr;
1121}
1122
1123ecb_inline char *
1124ecb_i2a_i64 (char *ptr, int64_t v)
1125{
1126 *ptr = '-'; ptr += v < 0;
1127 uint64_t u = v < 0 ? -(uint64_t)v : v;
1128
1129 #if ECB_64BIT_NATIVE
1130 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1131 ptr = ecb_i2a_x10 (ptr, u);
1132 else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000))
1133 {
1134 uint64_t u1 = u % 1000000000;
1135 uint64_t u2 = u / 1000000000;
1136
1137 ptr = ecb_i2a_x10 (ptr, u2);
1138 ptr = ecb_i2a_09 (ptr, u1);
1139 }
1140 else
1141 {
1142 uint64_t u1 = u % 1000000000;
1143 uint64_t ua = u / 1000000000;
1144 uint64_t u2 = ua % 1000000000;
1145 uint64_t u3 = ua / 1000000000;
1146
1147 // 2**31 is 19 digits, so the top is exactly one digit
1148 *ptr++ = u3 + '0';
1149 ptr = ecb_i2a_09 (ptr, u2);
1150 ptr = ecb_i2a_09 (ptr, u1);
1151 }
1152 #else
1153 ptr = ecb_i2a_u64 (ptr, u);
1154 #endif
1155
1156 return ptr;
894} 1157}
895 1158
896/*******************************************************************************/ 1159/*******************************************************************************/
897/* floating point stuff, can be disabled by defining ECB_NO_LIBM */ 1160/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
898 1161
… …
912 || defined __sh__ \ 1175 || defined __sh__ \
913 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \ 1176 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
914 || (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \ 1177 || (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
915 || defined __aarch64__ 1178 || defined __aarch64__
916 #define ECB_STDFP 1 1179 #define ECB_STDFP 1
917 #include <string.h> /* for memcpy */
918#else 1180#else
919 #define ECB_STDFP 0 1181 #define ECB_STDFP 0
920#endif 1182#endif
921 1183
922#ifndef ECB_NO_LIBM 1184#ifndef ECB_NO_LIBM

Diff Legend

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