1/*
2 * Copyright (c) 1999-2002 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7 * Reserved. This file contains Original Code and/or Modifications of
8 * Original Code as defined in and that are subject to the Apple Public
9 * Source License Version 1.0 (the 'License'). You may not use this file
10 * except in compliance with the License. Please obtain a copy of the
11 * License at http://www.apple.com/publicsource and read it before using
12 * this file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19 * License for the specific language governing rights and limitations
20 * under the License."
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24/*
25 * Copyright (c) 1992 NeXT Computer, Inc.
26 *
27 * Byte ordering conversion.
28 *
29 */
30
31#ifndef _ARCHITECTURE_BYTE_ORDER_H_
32#define _ARCHITECTURE_BYTE_ORDER_H_
33
34#include <libkern/OSByteOrder.h>
35
36typedef unsigned long NXSwappedFloat;
37typedef unsigned long long NXSwappedDouble;
38
39static __inline__
40unsigned short
41NXSwapShort(
42 unsigned short inv
43)
44{
45 return (unsigned short)OSSwapInt16((uint16_t)inv);
46}
47
48static __inline__
49unsigned int
50NXSwapInt(
51 unsigned int inv
52)
53{
54 return (unsigned int)OSSwapInt32((uint32_t)inv);
55}
56
57static __inline__
58unsigned long
59NXSwapLong(
60 unsigned long inv
61)
62{
63 return (unsigned long)OSSwapInt32((uint32_t)inv);
64}
65
66static __inline__
67unsigned long long
68NXSwapLongLong(
69 unsigned long long inv
70)
71{
72 return (unsigned long long)OSSwapInt64((uint64_t)inv);
73}
74
75static __inline__ NXSwappedFloat
76NXConvertHostFloatToSwapped(float x)
77{
78 union fconv {
79 float number;
80 NXSwappedFloat sf;
81 } u;
82 u.number = x;
83 return u.sf;
84}
85
86static __inline__ float
87NXConvertSwappedFloatToHost(NXSwappedFloat x)
88{
89 union fconv {
90 float number;
91 NXSwappedFloat sf;
92 } u;
93 u.sf = x;
94 return u.number;
95}
96
97static __inline__ NXSwappedDouble
98NXConvertHostDoubleToSwapped(double x)
99{
100 union dconv {
101 double number;
102 NXSwappedDouble sd;
103 } u;
104 u.number = x;
105 return u.sd;
106}
107
108static __inline__ double
109NXConvertSwappedDoubleToHost(NXSwappedDouble x)
110{
111 union dconv {
112 double number;
113 NXSwappedDouble sd;
114 } u;
115 u.sd = x;
116 return u.number;
117}
118
119static __inline__ NXSwappedFloat
120NXSwapFloat(NXSwappedFloat x)
121{
122 return (NXSwappedFloat)OSSwapInt32((uint32_t)x);
123}
124
125static __inline__ NXSwappedDouble
126NXSwapDouble(NXSwappedDouble x)
127{
128 return (NXSwappedDouble)OSSwapInt64((uint64_t)x);
129}
130
131/*
132 * Identify the byte order
133 * of the current host.
134 */
135
136enum NXByteOrder {
137 NX_UnknownByteOrder,
138 NX_LittleEndian,
139 NX_BigEndian
140};
141
142static __inline__
143enum NXByteOrder
144NXHostByteOrder(void)
145{
146#if defined(__LITTLE_ENDIAN__)
147 return NX_LittleEndian;
148#elif defined(__BIG_ENDIAN__)
149 return NX_BigEndian;
150#else
151 return NX_UnknownByteOrder;
152#endif
153}
154
155static __inline__
156unsigned short
157NXSwapBigShortToHost(
158 unsigned short x
159)
160{
161 return (unsigned short)OSSwapBigToHostInt16((uint16_t)x);
162}
163
164static __inline__
165unsigned int
166NXSwapBigIntToHost(
167 unsigned int x
168)
169{
170 return (unsigned int)OSSwapBigToHostInt32((uint32_t)x);
171}
172
173static __inline__
174unsigned long
175NXSwapBigLongToHost(
176 unsigned long x
177)
178{
179 return (unsigned long)OSSwapBigToHostInt32((uint32_t)x);
180}
181
182static __inline__
183unsigned long long
184NXSwapBigLongLongToHost(
185 unsigned long long x
186)
187{
188 return (unsigned long long)OSSwapBigToHostInt64((uint64_t)x);
189}
190
191static __inline__
192double
193NXSwapBigDoubleToHost(
194 NXSwappedDouble x
195)
196{
197 return NXConvertSwappedDoubleToHost(x: (NXSwappedDouble)OSSwapBigToHostInt64((uint64_t)x));
198}
199
200static __inline__
201float
202NXSwapBigFloatToHost(
203 NXSwappedFloat x
204)
205{
206 return NXConvertSwappedFloatToHost(x: (NXSwappedFloat)OSSwapBigToHostInt32((uint32_t)x));
207}
208
209static __inline__
210unsigned short
211NXSwapHostShortToBig(
212 unsigned short x
213)
214{
215 return (unsigned short)OSSwapHostToBigInt16((uint16_t)x);
216}
217
218static __inline__
219unsigned int
220NXSwapHostIntToBig(
221 unsigned int x
222)
223{
224 return (unsigned int)OSSwapHostToBigInt32((uint32_t)x);
225}
226
227static __inline__
228unsigned long
229NXSwapHostLongToBig(
230 unsigned long x
231)
232{
233 return (unsigned long)OSSwapHostToBigInt32((uint32_t)x);
234}
235
236static __inline__
237unsigned long long
238NXSwapHostLongLongToBig(
239 unsigned long long x
240)
241{
242 return (unsigned long long)OSSwapHostToBigInt64((uint64_t)x);
243}
244
245static __inline__
246NXSwappedDouble
247NXSwapHostDoubleToBig(
248 double x
249)
250{
251 return (NXSwappedDouble)OSSwapHostToBigInt64((uint64_t)NXConvertHostDoubleToSwapped(x));
252}
253
254static __inline__
255NXSwappedFloat
256NXSwapHostFloatToBig(
257 float x
258)
259{
260 return (NXSwappedFloat)OSSwapHostToBigInt32((uint32_t)NXConvertHostFloatToSwapped(x));
261}
262
263static __inline__
264unsigned short
265NXSwapLittleShortToHost(
266 unsigned short x
267)
268{
269 return (unsigned short)OSSwapLittleToHostInt16((uint16_t)x);
270}
271
272static __inline__
273unsigned int
274NXSwapLittleIntToHost(
275 unsigned int x
276)
277{
278 return (unsigned int)OSSwapLittleToHostInt32((uint32_t)x);
279}
280
281static __inline__
282unsigned long
283NXSwapLittleLongToHost(
284 unsigned long x
285)
286{
287 return (unsigned long)OSSwapLittleToHostInt32((uint32_t)x);
288}
289
290static __inline__
291unsigned long long
292NXSwapLittleLongLongToHost(
293 unsigned long long x
294)
295{
296 return (unsigned long long)OSSwapLittleToHostInt64((uint64_t)x);
297}
298
299static __inline__
300double
301NXSwapLittleDoubleToHost(
302 NXSwappedDouble x
303)
304{
305 return NXConvertSwappedDoubleToHost(x: (NXSwappedDouble)OSSwapLittleToHostInt64((uint64_t)x));
306}
307
308static __inline__
309float
310NXSwapLittleFloatToHost(
311 NXSwappedFloat x
312)
313{
314 return NXConvertSwappedFloatToHost(x: (NXSwappedFloat)OSSwapLittleToHostInt32((uint32_t)x));
315}
316
317static __inline__
318unsigned short
319NXSwapHostShortToLittle(
320 unsigned short x
321)
322{
323 return (unsigned short)OSSwapHostToLittleInt16((uint16_t)x);
324}
325
326static __inline__
327unsigned int
328NXSwapHostIntToLittle(
329 unsigned int x
330)
331{
332 return (unsigned int)OSSwapHostToLittleInt32((uint32_t)x);
333}
334
335static __inline__
336unsigned long
337NXSwapHostLongToLittle(
338 unsigned long x
339)
340{
341 return (unsigned long)OSSwapHostToLittleInt32((uint32_t)x);
342}
343
344static __inline__
345unsigned long long
346NXSwapHostLongLongToLittle(
347 unsigned long long x
348)
349{
350 return (unsigned long long)OSSwapHostToLittleInt64((uint64_t)x);
351}
352
353static __inline__
354NXSwappedDouble
355NXSwapHostDoubleToLittle(
356 double x
357)
358{
359 return (NXSwappedDouble)OSSwapHostToLittleInt64((uint64_t)NXConvertHostDoubleToSwapped(x));
360}
361
362static __inline__
363NXSwappedFloat
364NXSwapHostFloatToLittle(
365 float x
366)
367{
368 return (NXSwappedFloat)OSSwapHostToLittleInt32((uint32_t)NXConvertHostFloatToSwapped(x));
369}
370
371#endif /* _ARCHITECTURE_BYTE_ORDER_H_ */
372