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

Comparing libecb/ecb.h (file contents):
Revision 1.178 by root, Mon Jun 24 22:22:59 2019 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 0x00010006 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;
52 typedef signed char int_fast8_t;
53 typedef unsigned char uint_fast8_t;
50 typedef signed short int16_t; 54 typedef signed short int16_t;
51 typedef unsigned short uint16_t; 55 typedef unsigned short uint16_t;
56 typedef signed int int_fast16_t;
57 typedef unsigned int uint_fast16_t;
52 typedef signed int int32_t; 58 typedef signed int int32_t;
53 typedef unsigned int uint32_t; 59 typedef unsigned int uint32_t;
60 typedef signed int int_fast32_t;
61 typedef unsigned int uint_fast32_t;
54 #if __GNUC__ 62 #if __GNUC__
55 typedef signed long long int64_t; 63 typedef signed long long int64_t;
56 typedef unsigned long long uint64_t; 64 typedef unsigned long long uint64_t;
57 #else /* _MSC_VER || __BORLANDC__ */ 65 #else /* _MSC_VER || __BORLANDC__ */
58 typedef signed __int64 int64_t; 66 typedef signed __int64 int64_t;
59 typedef unsigned __int64 uint64_t; 67 typedef unsigned __int64 uint64_t;
60 #endif 68 #endif
69 typedef int64_t int_fast64_t;
70 typedef uint64_t uint_fast64_t;
61 #ifdef _WIN64 71 #ifdef _WIN64
62 #define ECB_PTRSIZE 8 72 #define ECB_PTRSIZE 8
63 typedef uint64_t uintptr_t; 73 typedef uint64_t uintptr_t;
64 typedef int64_t intptr_t; 74 typedef int64_t intptr_t;
65 #else 75 #else
… …
77#endif 87#endif
78 88
79#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__) 89#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
80#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64) 90#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
81 91
92#ifndef ECB_OPTIMIZE_SIZE
93 #if __OPTIMIZE_SIZE__
94 #define ECB_OPTIMIZE_SIZE 1
95 #else
96 #define ECB_OPTIMIZE_SIZE 0
97 #endif
98#endif
99
82/* work around x32 idiocy by defining proper macros */ 100/* work around x32 idiocy by defining proper macros */
83#if ECB_GCC_AMD64 || ECB_MSVC_AMD64 101#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
84 #if _ILP32 102 #if _ILP32
85 #define ECB_AMD64_X32 1 103 #define ECB_AMD64_X32 1
86 #else 104 #else
87 #define ECB_AMD64 1 105 #define ECB_AMD64 1
88 #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
89#endif 113#endif
90 114
91/* many compilers define _GNUC_ to some versions but then only implement 115/* many compilers define _GNUC_ to some versions but then only implement
92 * what their idiot authors think are the "more important" extensions, 116 * what their idiot authors think are the "more important" extensions,
93 * causing enormous grief in return for some better fake benchmark numbers. 117 * causing enormous grief in return for some better fake benchmark numbers.
… …
224 #if ECB_GCC_VERSION(4,7) 248 #if ECB_GCC_VERSION(4,7)
225 /* see comment below (stdatomic.h) about the C11 memory model. */ 249 /* see comment below (stdatomic.h) about the C11 memory model. */
226 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 250 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
227 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE) 251 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
228 #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
229 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED) 254 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
230 255
231 #elif ECB_CLANG_EXTENSION(c_atomic) 256 #elif ECB_CLANG_EXTENSION(c_atomic)
232 /* see comment below (stdatomic.h) about the C11 memory model. */ 257 /* see comment below (stdatomic.h) about the C11 memory model. */
233 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 258 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
234 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE) 259 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
235 #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
236 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED) 262 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
237 263
238 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 264 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
239 #define ECB_MEMORY_FENCE __sync_synchronize () 265 #define ECB_MEMORY_FENCE __sync_synchronize ()
240 #elif _MSC_VER >= 1500 /* VC++ 2008 */ 266 #elif _MSC_VER >= 1500 /* VC++ 2008 */
… …
592ecb_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); }
593ecb_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); }
594ecb_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); }
595ecb_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); }
596 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
597#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))
598 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16) 662 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
599 #define ecb_bswap16(x) __builtin_bswap16 (x) 663 #define ecb_bswap16(x) __builtin_bswap16 (x)
600 #else 664 #else
601 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16) 665 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
… …
672ecb_inline ecb_const ecb_bool ecb_big_endian (void); 736ecb_inline ecb_const ecb_bool ecb_big_endian (void);
673ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; } 737ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
674ecb_inline ecb_const ecb_bool ecb_little_endian (void); 738ecb_inline ecb_const ecb_bool ecb_little_endian (void);
675ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; } 739ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
676 740
741/*****************************************************************************/
742/* unaligned load/store */
743
744ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
745ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
746ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
747
748ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
749ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
750ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
751
752ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
753ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
754ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
755
756ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
757ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
758ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
759
760ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
761ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
762ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
763
764ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
765ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
766ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
767
768ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
769ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
770ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
771
772ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
773ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
774ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
775
776ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
777ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
778ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
779
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)); }
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)); }
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)); }
783
784#if ECB_CPP
785
786inline uint8_t ecb_bswap (uint8_t v) { return v; }
787inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
788inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
789inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
790
791template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
792template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
793template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
794template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_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)); }
796template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
797template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_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)); }
799
800template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
801template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
802template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
803template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
804template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
805template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (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)); }
807template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
808
809#endif
810
811/*****************************************************************************/
812/* division */
813
677#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 */
678 #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))
679#else 817#else
680 #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)))
681#endif 819#endif
682 820
… …
693 } 831 }
694#else 832#else
695 #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))
696 #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))
697#endif 835#endif
836
837/*****************************************************************************/
838/* array length */
698 839
699#if ecb_cplusplus_does_not_suck 840#if ecb_cplusplus_does_not_suck
700 /* 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) */
701 template<typename T, int N> 842 template<typename T, int N>
702 static inline int ecb_array_length (const T (&arr)[N]) 843 static inline int ecb_array_length (const T (&arr)[N])
… …
704 return N; 845 return N;
705 } 846 }
706#else 847#else
707 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 848 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
708#endif 849#endif
850
851/*****************************************************************************/
852/* IEEE 754-2008 half float conversions */
709 853
710ecb_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);
711ecb_function_ ecb_const uint32_t 855ecb_function_ ecb_const uint32_t
712ecb_binary16_to_binary32 (uint32_t x) 856ecb_binary16_to_binary32 (uint32_t x)
713{ 857{
… …
742ecb_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);
743ecb_function_ ecb_const uint16_t 887ecb_function_ ecb_const uint16_t
744ecb_binary32_to_binary16 (uint32_t x) 888ecb_binary32_to_binary16 (uint32_t x)
745{ 889{
746 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */ 890 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
747 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */ 891 int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
748 unsigned int m = x & 0x007fffff; 892 unsigned int m = x & 0x007fffff;
749 893
750 x &= 0x7fffffff; 894 x &= 0x7fffffff;
751 895
752 /* if it's within range of binary16 normals, use fast path */ 896 /* if it's within range of binary16 normals, use fast path */
… …
799 943
800 /* 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 */
801 m >>= 13; 945 m >>= 13;
802 946
803 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;
804} 1157}
805 1158
806/*******************************************************************************/ 1159/*******************************************************************************/
807/* floating point stuff, can be disabled by defining ECB_NO_LIBM */ 1160/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
808 1161
… …
822 || defined __sh__ \ 1175 || defined __sh__ \
823 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \ 1176 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
824 || (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__)) \
825 || defined __aarch64__ 1178 || defined __aarch64__
826 #define ECB_STDFP 1 1179 #define ECB_STDFP 1
827 #include <string.h> /* for memcpy */
828#else 1180#else
829 #define ECB_STDFP 0 1181 #define ECB_STDFP 0
830#endif 1182#endif
831 1183
832#ifndef ECB_NO_LIBM 1184#ifndef ECB_NO_LIBM

Diff Legend

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