1 /*  Copyright (c) MediaArea.net SARL. All Rights Reserved.
2  *
3  *  Use of this source code is governed by a zlib-style license that can
4  *  be found in the License.txt file in the root of the source tree.
5  */
6 
7 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8 //
9 // Integer and float manipulation
10 //
11 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12 
13 //---------------------------------------------------------------------------
14 #ifndef ZenUtilsH
15 #define ZenUtilsH
16 //---------------------------------------------------------------------------
17 
18 //---------------------------------------------------------------------------
19 #include "ZenLib/int128u.h"
20 //---------------------------------------------------------------------------
21 
22 namespace ZenLib
23 {
24 
25 //***************************************************************************
26 // Integer transformations
27 //***************************************************************************
28 
29 //---------------------------------------------------------------------------
30 //Little Endians
31 int8s  LittleEndian2int8s  (const char* List);
32 int8u  LittleEndian2int8u  (const char* List);
33 int16s LittleEndian2int16s (const char* List);
34 int16u LittleEndian2int16u (const char* List);
35 int32s LittleEndian2int24s (const char* List);
36 int32u LittleEndian2int24u (const char* List);
37 int32s LittleEndian2int32s (const char* List);
38 int32u LittleEndian2int32u (const char* List);
39 #if (MAXTYPE_INT >= 64)
40 int64s LittleEndian2int40s (const char* List);
41 int64u LittleEndian2int40u (const char* List);
42 int64s LittleEndian2int48s (const char* List);
43 int64u LittleEndian2int48u (const char* List);
44 int64s LittleEndian2int56s (const char* List);
45 int64u LittleEndian2int56u (const char* List);
46 int64s LittleEndian2int64s (const char* List);
47 int64u LittleEndian2int64u (const char* List);
48 int128u LittleEndian2int128u (const char* List);
49 #endif
50 float32 LittleEndian2float16 (const char* List);
51 float32 LittleEndian2float32 (const char* List);
52 float64 LittleEndian2float64 (const char* List);
53 float80 LittleEndian2float80 (const char* List);
54 
55 void   int8s2LittleEndian     (char* List, int8s  Value);
56 void   int8u2LittleEndian     (char* List, int8u  Value);
57 void   int16s2LittleEndian    (char* List, int16s Value);
58 void   int16u2LittleEndian    (char* List, int16u Value);
59 void   int24s2LittleEndian    (char* List, int32s Value);
60 void   int24u2LittleEndian    (char* List, int32u Value);
61 void   int32s2LittleEndian    (char* List, int32s Value);
62 void   int32u2LittleEndian    (char* List, int32u Value);
63 #if (MAXTYPE_INT >= 64)
64 void   int40s2LittleEndian    (char* List, int64s Value);
65 void   int40u2LittleEndian    (char* List, int64u Value);
66 void   int48s2LittleEndian    (char* List, int64s Value);
67 void   int48u2LittleEndian    (char* List, int64u Value);
68 void   int56s2LittleEndian    (char* List, int64s Value);
69 void   int56u2LittleEndian    (char* List, int64u Value);
70 void   int64s2LittleEndian    (char* List, int64s Value);
71 void   int64u2LittleEndian    (char* List, int64u Value);
72 void   int128u2LittleEndian   (char* List, int128u Value);
73 #endif
74 void   float162LittleEndian   (char* List, float32 Value);
75 void   float322LittleEndian   (char* List, float32 Value);
76 void   float642LittleEndian   (char* List, float64 Value);
77 void   float802LittleEndian   (char* List, float80 Value);
78 
79 #ifndef __BORLANDC__
LittleEndian2int8s(const int8u * List)80 inline int8s  LittleEndian2int8s  (const int8u* List) {return LittleEndian2int8s  ((const char*)List);}
LittleEndian2int8u(const int8u * List)81 inline int8u  LittleEndian2int8u  (const int8u* List) {return LittleEndian2int8u  ((const char*)List);}
LittleEndian2int16s(const int8u * List)82 inline int16s LittleEndian2int16s (const int8u* List) {return LittleEndian2int16s ((const char*)List);}
LittleEndian2int16u(const int8u * List)83 inline int16u LittleEndian2int16u (const int8u* List) {return LittleEndian2int16u ((const char*)List);}
LittleEndian2int24s(const int8u * List)84 inline int32s LittleEndian2int24s (const int8u* List) {return LittleEndian2int24s ((const char*)List);}
LittleEndian2int24u(const int8u * List)85 inline int32u LittleEndian2int24u (const int8u* List) {return LittleEndian2int24u ((const char*)List);}
LittleEndian2int32s(const int8u * List)86 inline int32s LittleEndian2int32s (const int8u* List) {return LittleEndian2int32s ((const char*)List);}
LittleEndian2int32u(const int8u * List)87 inline int32u LittleEndian2int32u (const int8u* List) {return LittleEndian2int32u ((const char*)List);}
88 #if (MAXTYPE_INT >= 64)
LittleEndian2int40s(const int8u * List)89 inline int64s LittleEndian2int40s (const int8u* List) {return LittleEndian2int40s ((const char*)List);}
LittleEndian2int40u(const int8u * List)90 inline int64u LittleEndian2int40u (const int8u* List) {return LittleEndian2int40u ((const char*)List);}
LittleEndian2int48s(const int8u * List)91 inline int64s LittleEndian2int48s (const int8u* List) {return LittleEndian2int48s ((const char*)List);}
LittleEndian2int48u(const int8u * List)92 inline int64u LittleEndian2int48u (const int8u* List) {return LittleEndian2int48u ((const char*)List);}
LittleEndian2int56s(const int8u * List)93 inline int64s LittleEndian2int56s (const int8u* List) {return LittleEndian2int56s ((const char*)List);}
LittleEndian2int56u(const int8u * List)94 inline int64u LittleEndian2int56u (const int8u* List) {return LittleEndian2int56u ((const char*)List);}
LittleEndian2int64s(const int8u * List)95 inline int64s LittleEndian2int64s (const int8u* List) {return LittleEndian2int64s ((const char*)List);}
LittleEndian2int64u(const int8u * List)96 inline int64u LittleEndian2int64u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
LittleEndian2int128u(const int8u * List)97 inline int128u LittleEndian2int128u (const int8u* List) {return LittleEndian2int64u ((const char*)List);}
98 #endif
LittleEndian2float16(const int8u * List)99 inline float32 LittleEndian2float16 (const int8u* List) {return LittleEndian2float16 ((const char*)List);}
LittleEndian2float32(const int8u * List)100 inline float32 LittleEndian2float32 (const int8u* List) {return LittleEndian2float32 ((const char*)List);}
LittleEndian2float64(const int8u * List)101 inline float64 LittleEndian2float64 (const int8u* List) {return LittleEndian2float64 ((const char*)List);}
LittleEndian2float80(const int8u * List)102 inline float80 LittleEndian2float80 (const int8u* List) {return LittleEndian2float80 ((const char*)List);}
103 
int8s2LittleEndian(int8u * List,int8s Value)104 inline void   int8s2LittleEndian     (int8u* List, int8s  Value) {return int8s2LittleEndian    ((char*)List, Value);}
int8u2LittleEndian(int8u * List,int8u Value)105 inline void   int8u2LittleEndian     (int8u* List, int8u  Value) {return int8u2LittleEndian    ((char*)List, Value);}
int16s2LittleEndian(int8u * List,int16s Value)106 inline void   int16s2LittleEndian    (int8u* List, int16s Value) {return int16s2LittleEndian   ((char*)List, Value);}
int16u2LittleEndian(int8u * List,int16u Value)107 inline void   int16u2LittleEndian    (int8u* List, int16u Value) {return int16u2LittleEndian   ((char*)List, Value);}
int24s2LittleEndian(int8u * List,int32s Value)108 inline void   int24s2LittleEndian    (int8u* List, int32s Value) {return int24s2LittleEndian   ((char*)List, Value);}
int24u2LittleEndian(int8u * List,int32u Value)109 inline void   int24u2LittleEndian    (int8u* List, int32u Value) {return int24u2LittleEndian   ((char*)List, Value);}
int32s2LittleEndian(int8u * List,int32s Value)110 inline void   int32s2LittleEndian    (int8u* List, int32s Value) {return int32s2LittleEndian   ((char*)List, Value);}
int32u2LittleEndian(int8u * List,int32u Value)111 inline void   int32u2LittleEndian    (int8u* List, int32u Value) {return int32u2LittleEndian   ((char*)List, Value);}
112 #if (MAXTYPE_INT >= 64)
int40s2LittleEndian(int8u * List,int64s Value)113 inline void   int40s2LittleEndian    (int8u* List, int64s Value) {return int40s2LittleEndian   ((char*)List, Value);}
int40u2LittleEndian(int8u * List,int64u Value)114 inline void   int40u2LittleEndian    (int8u* List, int64u Value) {return int40u2LittleEndian   ((char*)List, Value);}
int48s2LittleEndian(int8u * List,int64s Value)115 inline void   int48s2LittleEndian    (int8u* List, int64s Value) {return int48s2LittleEndian   ((char*)List, Value);}
int48u2LittleEndian(int8u * List,int64u Value)116 inline void   int48u2LittleEndian    (int8u* List, int64u Value) {return int48u2LittleEndian   ((char*)List, Value);}
int56s2LittleEndian(int8u * List,int64s Value)117 inline void   int56s2LittleEndian    (int8u* List, int64s Value) {return int56s2LittleEndian   ((char*)List, Value);}
int56u2LittleEndian(int8u * List,int64u Value)118 inline void   int56u2LittleEndian    (int8u* List, int64u Value) {return int56u2LittleEndian   ((char*)List, Value);}
int64s2LittleEndian(int8u * List,int64s Value)119 inline void   int64s2LittleEndian    (int8u* List, int64s Value) {return int64s2LittleEndian   ((char*)List, Value);}
int64u2LittleEndian(int8u * List,int64u Value)120 inline void   int64u2LittleEndian    (int8u* List, int64u Value) {return int64u2LittleEndian   ((char*)List, Value);}
int128u2LittleEndian(int8u * List,int128u Value)121 inline void   int128u2LittleEndian   (int8u* List, int128u Value) {return int128u2LittleEndian ((char*)List, Value);}
122 #endif
float162LittleEndian(int8u * List,float32 Value)123 inline void   float162LittleEndian   (int8u* List, float32 Value) {return float162LittleEndian ((char*)List, Value);}
float322LittleEndian(int8u * List,float32 Value)124 inline void   float322LittleEndian   (int8u* List, float32 Value) {return float322LittleEndian ((char*)List, Value);}
float642LittleEndian(int8u * List,float64 Value)125 inline void   float642LittleEndian   (int8u* List, float64 Value) {return float642LittleEndian ((char*)List, Value);}
float802LittleEndian(int8u * List,float80 Value)126 inline void   float802LittleEndian   (int8u* List, float80 Value) {return float802LittleEndian ((char*)List, Value);}
127 #endif //__BORLANDC__
128 
129 //---------------------------------------------------------------------------
130 //Big Endians
131 int8s  BigEndian2int8s     (const char* List);
132 int8u  BigEndian2int8u     (const char* List);
133 int16s BigEndian2int16s    (const char* List);
134 int16u BigEndian2int16u    (const char* List);
135 int32s BigEndian2int24s    (const char* List);
136 int32u BigEndian2int24u    (const char* List);
137 int32s BigEndian2int32s    (const char* List);
138 int32u BigEndian2int32u    (const char* List);
139 #if (MAXTYPE_INT >= 64)
140 int64s BigEndian2int40s    (const char* List);
141 int64u BigEndian2int40u    (const char* List);
142 int64s BigEndian2int48s    (const char* List);
143 int64u BigEndian2int48u    (const char* List);
144 int64s BigEndian2int56s    (const char* List);
145 int64u BigEndian2int56u    (const char* List);
146 int64s BigEndian2int64s    (const char* List);
147 int64u BigEndian2int64u    (const char* List);
148 int128u BigEndian2int128u  (const char* List);
149 #endif
150 float32 BigEndian2float16  (const char* List);
151 float32 BigEndian2float32  (const char* List);
152 float64 BigEndian2float64  (const char* List);
153 float80 BigEndian2float80  (const char* List);
154 
155 void   int8s2BigEndian     (char* List, int8s  Value);
156 void   int8u2BigEndian     (char* List, int8u  Value);
157 void   int16s2BigEndian    (char* List, int16s Value);
158 void   int16u2BigEndian    (char* List, int16u Value);
159 void   int24s2BigEndian    (char* List, int32s Value);
160 void   int24u2BigEndian    (char* List, int32u Value);
161 void   int32s2BigEndian    (char* List, int32s Value);
162 void   int32u2BigEndian    (char* List, int32u Value);
163 #if (MAXTYPE_INT >= 64)
164 void   int40s2BigEndian    (char* List, int64s Value);
165 void   int40u2BigEndian    (char* List, int64u Value);
166 void   int48s2BigEndian    (char* List, int64s Value);
167 void   int48u2BigEndian    (char* List, int64u Value);
168 void   int56s2BigEndian    (char* List, int64s Value);
169 void   int56u2BigEndian    (char* List, int64u Value);
170 void   int64s2BigEndian    (char* List, int64s Value);
171 void   int64u2BigEndian    (char* List, int64u Value);
172 void   int128u2BigEndian   (char* List, int128u Value);
173 #endif
174 void   float162BigEndian   (char* List, float32 Value);
175 void   float322BigEndian   (char* List, float32 Value);
176 void   float642BigEndian   (char* List, float64 Value);
177 void   float802BigEndian   (char* List, float80 Value);
178 
179 #ifndef __BORLANDC__
BigEndian2int8s(const int8u * List)180 inline int8s  BigEndian2int8s     (const int8u* List) {return BigEndian2int8s     ((const char*)List);}
BigEndian2int8u(const int8u * List)181 inline int8u  BigEndian2int8u     (const int8u* List) {return BigEndian2int8u     ((const char*)List);}
BigEndian2int16s(const int8u * List)182 inline int16s BigEndian2int16s    (const int8u* List) {return BigEndian2int16s    ((const char*)List);}
BigEndian2int16u(const int8u * List)183 inline int16u BigEndian2int16u    (const int8u* List) {return BigEndian2int16u    ((const char*)List);}
BigEndian2int32s(const int8u * List)184 inline int32s BigEndian2int32s    (const int8u* List) {return BigEndian2int32s    ((const char*)List);}
BigEndian2int24u(const int8u * List)185 inline int32u BigEndian2int24u    (const int8u* List) {return BigEndian2int24u    ((const char*)List);}
BigEndian2int24s(const int8u * List)186 inline int32s BigEndian2int24s    (const int8u* List) {return BigEndian2int24s    ((const char*)List);}
BigEndian2int32u(const int8u * List)187 inline int32u BigEndian2int32u    (const int8u* List) {return BigEndian2int32u    ((const char*)List);}
188 #if (MAXTYPE_INT >= 64)
BigEndian2int40s(const int8u * List)189 inline int64s BigEndian2int40s    (const int8u* List) {return BigEndian2int40s    ((const char*)List);}
BigEndian2int40u(const int8u * List)190 inline int64u BigEndian2int40u    (const int8u* List) {return BigEndian2int40u    ((const char*)List);}
BigEndian2int48s(const int8u * List)191 inline int64s BigEndian2int48s    (const int8u* List) {return BigEndian2int48s    ((const char*)List);}
BigEndian2int48u(const int8u * List)192 inline int64u BigEndian2int48u    (const int8u* List) {return BigEndian2int48u    ((const char*)List);}
BigEndian2int56s(const int8u * List)193 inline int64s BigEndian2int56s    (const int8u* List) {return BigEndian2int56s    ((const char*)List);}
BigEndian2int56u(const int8u * List)194 inline int64u BigEndian2int56u    (const int8u* List) {return BigEndian2int56u    ((const char*)List);}
BigEndian2int64s(const int8u * List)195 inline int64s BigEndian2int64s    (const int8u* List) {return BigEndian2int64s    ((const char*)List);}
BigEndian2int64u(const int8u * List)196 inline int64u BigEndian2int64u    (const int8u* List) {return BigEndian2int64u    ((const char*)List);}
BigEndian2int128u(const int8u * List)197 inline int128u BigEndian2int128u  (const int8u* List) {return BigEndian2int128u   ((const char*)List);}
198 #endif
BigEndian2float16(const int8u * List)199 inline float32 BigEndian2float16  (const int8u* List) {return BigEndian2float16   ((const char*)List);}
BigEndian2float32(const int8u * List)200 inline float32 BigEndian2float32  (const int8u* List) {return BigEndian2float32   ((const char*)List);}
BigEndian2float64(const int8u * List)201 inline float64 BigEndian2float64  (const int8u* List) {return BigEndian2float64   ((const char*)List);}
BigEndian2float80(const int8u * List)202 inline float80 BigEndian2float80  (const int8u* List) {return BigEndian2float80   ((const char*)List);}
203 
int8s2BigEndian(int8u * List,int8s Value)204 inline void   int8s2BigEndian     (int8u* List, int8s  Value) {return int8s2BigEndian    ((char*)List, Value);}
int8u2BigEndian(int8u * List,int8u Value)205 inline void   int8u2BigEndian     (int8u* List, int8u  Value) {return int8u2BigEndian    ((char*)List, Value);}
int16s2BigEndian(int8u * List,int16s Value)206 inline void   int16s2BigEndian    (int8u* List, int16s Value) {return int16s2BigEndian   ((char*)List, Value);}
int16u2BigEndian(int8u * List,int16u Value)207 inline void   int16u2BigEndian    (int8u* List, int16u Value) {return int16u2BigEndian   ((char*)List, Value);}
int24s2BigEndian(int8u * List,int32s Value)208 inline void   int24s2BigEndian    (int8u* List, int32s Value) {return int24s2BigEndian   ((char*)List, Value);}
int24u2BigEndian(int8u * List,int32u Value)209 inline void   int24u2BigEndian    (int8u* List, int32u Value) {return int24u2BigEndian   ((char*)List, Value);}
int32s2BigEndian(int8u * List,int32s Value)210 inline void   int32s2BigEndian    (int8u* List, int32s Value) {return int32s2BigEndian   ((char*)List, Value);}
int32u2BigEndian(int8u * List,int32u Value)211 inline void   int32u2BigEndian    (int8u* List, int32u Value) {return int32u2BigEndian   ((char*)List, Value);}
212 #if (MAXTYPE_INT >= 64)
int40s2BigEndian(int8u * List,int64s Value)213 inline void   int40s2BigEndian    (int8u* List, int64s Value) {return int40s2BigEndian   ((char*)List, Value);}
int40u2BigEndian(int8u * List,int64u Value)214 inline void   int40u2BigEndian    (int8u* List, int64u Value) {return int40u2BigEndian   ((char*)List, Value);}
int48s2BigEndian(int8u * List,int64s Value)215 inline void   int48s2BigEndian    (int8u* List, int64s Value) {return int48s2BigEndian   ((char*)List, Value);}
int48u2BigEndian(int8u * List,int64u Value)216 inline void   int48u2BigEndian    (int8u* List, int64u Value) {return int48u2BigEndian   ((char*)List, Value);}
int56s2BigEndian(int8u * List,int64s Value)217 inline void   int56s2BigEndian    (int8u* List, int64s Value) {return int56s2BigEndian   ((char*)List, Value);}
int56u2BigEndian(int8u * List,int64u Value)218 inline void   int56u2BigEndian    (int8u* List, int64u Value) {return int56u2BigEndian   ((char*)List, Value);}
int64s2BigEndian(int8u * List,int64s Value)219 inline void   int64s2BigEndian    (int8u* List, int64s Value) {return int64s2BigEndian   ((char*)List, Value);}
int64u2BigEndian(int8u * List,int64u Value)220 inline void   int64u2BigEndian    (int8u* List, int64u Value) {return int64u2BigEndian   ((char*)List, Value);}
int128u2BigEndian(int8u * List,int128u Value)221 inline void   int128u2BigEndian   (int8u* List, int128u Value) {return int128u2BigEndian ((char*)List, Value);}
222 #endif
float162BigEndian(int8u * List,float32 Value)223 inline void   float162BigEndian   (int8u* List, float32 Value) {return float162BigEndian ((char*)List, Value);}
float322BigEndian(int8u * List,float32 Value)224 inline void   float322BigEndian   (int8u* List, float32 Value) {return float322BigEndian ((char*)List, Value);}
float642BigEndian(int8u * List,float64 Value)225 inline void   float642BigEndian   (int8u* List, float64 Value) {return float642BigEndian ((char*)List, Value);}
float802BigEndian(int8u * List,float80 Value)226 inline void   float802BigEndian   (int8u* List, float80 Value) {return float802BigEndian ((char*)List, Value);}
227 #endif //__BORLANDC__
228 
229 //---------------------------------------------------------------------------
230 // int32 - int64
231 int64s int32s_int64s (                int32s  High, int32u  Low);
232 int64u int32u_int64u (                int32u  High, int32u  Low);
233 void   int32s_int64s (int64s &BigInt, int32s  High, int32u  Low);
234 void   int32u_int64u (int64s &BigInt, int32u  High, int32u  Low);
235 void   int64s_int32s (int64s  BigInt, int32s &High, int32u &Low);
236 void   int64u_int32u (int64u  BigInt, int32u &High, int32u &Low);
237 
238 //---------------------------------------------------------------------------
239 // Floats and ints
240 int32s float32_int32s  (float32 F, bool Rounded=true);
241 int64s float32_int64s  (float32 F, bool Rounded=true);
242 int32s float64_int32s  (float64 F, bool Rounded=true);
243 int64s float64_int64s  (float64 F, bool Rounded=true);
244 
245 // These functions are used because MSVC6 isn't able to convert an unsigned int64 to a floating-point value, and I couldn't think of a cleaner way to handle it.
246 #if defined(_MSC_VER) && _MSC_VER<=1200
int64u_float32(int64u v)247     inline float32 int64u_float32 (int64u v) {return static_cast<float32>(static_cast<int64s>(v>>1))*2.0f + static_cast<float32>(static_cast<int64s>(v & 1));}
int64u_float64(int64u v)248     inline float64 int64u_float64 (int64u v) {return static_cast<float64>(static_cast<int64s>(v>>1))*2.0f + static_cast<float32>(static_cast<int64s>(v & 1));}
249 #else
int64u_float32(int64u v)250     inline float32 int64u_float32 (int64u v) {return (float32)v;}
int64u_float64(int64u v)251     inline float64 int64u_float64 (int64u v) {return (float64)v;}
252 #endif // defined(_MSC_VER) && _MSC_VER<=1200
253 
254 //---------------------------------------------------------------------------
255 // CC (often used in all containers to identify a stream
CC8(const char * C)256 inline int64u CC8(const char*  C) {return BigEndian2int64u(C);}
CC7(const char * C)257 inline int64u CC7(const char*  C) {return BigEndian2int56u(C);}
CC6(const char * C)258 inline int64u CC6(const char*  C) {return BigEndian2int48u(C);}
CC5(const char * C)259 inline int64u CC5(const char*  C) {return BigEndian2int40u(C);}
CC4(const char * C)260 inline int32u CC4(const char*  C) {return BigEndian2int32u(C);}
CC3(const char * C)261 inline int32u CC3(const char*  C) {return BigEndian2int24u(C);}
CC2(const char * C)262 inline int16u CC2(const char*  C) {return BigEndian2int16u(C);}
CC1(const char * C)263 inline int8u  CC1(const char*  C) {return BigEndian2int8u (C);}
264 #ifndef __BORLANDC__
CC8(const int8u * C)265 inline int64u CC8(const int8u* C) {return BigEndian2int64u(C);}
CC7(const int8u * C)266 inline int64u CC7(const int8u* C) {return BigEndian2int56u(C);}
CC6(const int8u * C)267 inline int64u CC6(const int8u* C) {return BigEndian2int48u(C);}
CC5(const int8u * C)268 inline int64u CC5(const int8u* C) {return BigEndian2int40u(C);}
CC4(const int8u * C)269 inline int32u CC4(const int8u* C) {return BigEndian2int32u(C);}
CC3(const int8u * C)270 inline int32u CC3(const int8u* C) {return BigEndian2int24u(C);}
CC2(const int8u * C)271 inline int16u CC2(const int8u* C) {return BigEndian2int16u(C);}
CC1(const int8u * C)272 inline int8u  CC1(const int8u* C) {return BigEndian2int8u (C);}
273 #endif // __BORLANDC__
274 
275 //---------------------------------------------------------------------------
276 // turn a numeric literal into a hex constant
277 // (avoids problems with leading zeroes)
278 // 8-bit constants max value 0x11111111, always fits in unsigned long
279 #define HEX__(n) 0x##n##LU
280 
281 // 8-bit conversion function
282 #define B8__(x) ((x&0x0000000FLU)?0x01:0) \
283                +((x&0x000000F0LU)?0x02:0) \
284                +((x&0x00000F00LU)?0x04:0) \
285                +((x&0x0000F000LU)?0x08:0) \
286                +((x&0x000F0000LU)?0x10:0) \
287                +((x&0x00F00000LU)?0x20:0) \
288                +((x&0x0F000000LU)?0x40:0) \
289                +((x&0xF0000000LU)?0x80:0)
290 
291 // for upto 8-bit binary constants
292 #define B8(d) ((int8u)B8__(HEX__(d)))
293 
294 // for upto 16-bit binary constants, MSB first
295 #define B16(dmsb, dlsb) (((int16u)B8(dmsb)<<8) \
296                        + ((int16u)B8(dlsb)<<0))
297 
298 // for upto 32-bit binary constants, MSB first
299 #define B32(dmsb, db2, db3, dlsb) (((int32u)B8(dmsb)<<24) \
300                                  + ((int32u)B8( db2)<<16) \
301                                  + ((int32u)B8( db3)<< 8) \
302                                  + ((int32u)B8(dlsb)<< 0))
303 
304 } //namespace ZenLib
305 #endif
306