![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to byte_order.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / EXTERNAL_HEADERS / architecture|
Return to byte_order.h CVS log | Up to [Apple XNU] / XNU / EXTERNAL_HEADERS / architecture |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1992 NeXT Computer, Inc.
24: *
25: * Byte ordering conversion.
26: *
27: * HISTORY
28: *
29: * 20 October 1992 ? at NeXT
30: * Added #ifdef wrapper to prevent multiple inclusions of this file.
31: *
32: * 8 October 1992 ? at NeXT
33: * Converted to NXxxx versions. Condensed history.
34: *
35: * 18 May 1992 ? at NeXT
36: * Created.
37: */
38:
39: #ifndef _ARCHITECTURE_BYTE_ORDER_H_
40: #define _ARCHITECTURE_BYTE_ORDER_H_
41:
42: typedef unsigned long NXSwappedFloat;
43: typedef unsigned long long NXSwappedDouble;
44:
45: #if defined (__ppc__)
46: #include "architecture/ppc/byte_order.h"
47: #elif defined (__i386__)
48: #include "architecture/i386/byte_order.h"
49: #else
50: #error architecture not supported
51: #endif
52:
53: /*
54: * Identify the byte order
55: * of the current host.
56: */
57:
58: enum NXByteOrder {
59: NX_UnknownByteOrder,
60: NX_LittleEndian,
61: NX_BigEndian
62: };
63:
64: static __inline__
65: enum NXByteOrder
66: NXHostByteOrder(void)
67: {
68: unsigned int _x;
69:
70: _x = (NX_BigEndian << 24) | NX_LittleEndian;
71:
72: return ((enum NXByteOrder)*((unsigned char *)&_x));
73: }
74:
75: /*
76: * The predicated versions
77: * are defined here in terms
78: * of the unpredicated ones.
79: */
80:
81: #if __BIG_ENDIAN__
82:
83: static __inline__
84: unsigned short
85: NXSwapBigShortToHost(
86: unsigned short x
87: )
88: {
89: return (x);
90: }
91:
92: static __inline__
93: unsigned int
94: NXSwapBigIntToHost(
95: unsigned int x
96: )
97: {
98: return (x);
99: }
100:
101: static __inline__
102: unsigned long
103: NXSwapBigLongToHost(
104: unsigned long x
105: )
106: {
107: return (x);
108: }
109:
110: static __inline__
111: unsigned long long
112: NXSwapBigLongLongToHost(
113: unsigned long long x
114: )
115: {
116: return (x);
117: }
118:
119: #ifndef KERNEL
120:
121: static __inline__
122: double
123: NXSwapBigDoubleToHost(
124: NXSwappedDouble x
125: )
126: {
127: return NXConvertSwappedDoubleToHost(x);
128: }
129:
130: static __inline__
131: float
132: NXSwapBigFloatToHost(
133: NXSwappedFloat x
134: )
135: {
136: return NXConvertSwappedFloatToHost(x);
137: }
138:
139: #endif /* KERNEL */
140:
141: static __inline__
142: unsigned short
143: NXSwapHostShortToBig(
144: unsigned short x
145: )
146: {
147: return (x);
148: }
149:
150: static __inline__
151: unsigned int
152: NXSwapHostIntToBig(
153: unsigned int x
154: )
155: {
156: return (x);
157: }
158:
159: static __inline__
160: unsigned long
161: NXSwapHostLongToBig(
162: unsigned long x
163: )
164: {
165: return (x);
166: }
167:
168: static __inline__
169: unsigned long long
170: NXSwapHostLongLongToBig(
171: unsigned long long x
172: )
173: {
174: return (x);
175: }
176:
177: #ifndef KERNEL
178:
179: static __inline__
180: NXSwappedDouble
181: NXSwapHostDoubleToBig(
182: double x
183: )
184: {
185: return NXConvertHostDoubleToSwapped(x);
186: }
187:
188: static __inline__
189: NXSwappedFloat
190: NXSwapHostFloatToBig(
191: float x
192: )
193: {
194: return NXConvertHostFloatToSwapped(x);
195: }
196:
197: #endif /* KERNEL */
198:
199: static __inline__
200: unsigned short
201: NXSwapLittleShortToHost(
202: unsigned short x
203: )
204: {
205: return (NXSwapShort(x));
206: }
207:
208: static __inline__
209: unsigned int
210: NXSwapLittleIntToHost(
211: unsigned int x
212: )
213: {
214: return (NXSwapInt(x));
215: }
216:
217: static __inline__
218: unsigned long
219: NXSwapLittleLongToHost(
220: unsigned long x
221: )
222: {
223: return (NXSwapLong(x));
224: }
225:
226: static __inline__
227: unsigned long long
228: NXSwapLittleLongLongToHost(
229: unsigned long long x
230: )
231: {
232: return (NXSwapLongLong(x));
233: }
234:
235: #ifndef KERNEL
236:
237: static __inline__
238: double
239: NXSwapLittleDoubleToHost(
240: NXSwappedDouble x
241: )
242: {
243: return NXConvertSwappedDoubleToHost(NXSwapDouble(x));
244: }
245:
246: static __inline__
247: float
248: NXSwapLittleFloatToHost(
249: NXSwappedFloat x
250: )
251: {
252: return NXConvertSwappedFloatToHost(NXSwapFloat(x));
253: }
254:
255: #endif /* KERNEL */
256:
257: static __inline__
258: unsigned short
259: NXSwapHostShortToLittle(
260: unsigned short x
261: )
262: {
263: return (NXSwapShort(x));
264: }
265:
266: static __inline__
267: unsigned int
268: NXSwapHostIntToLittle(
269: unsigned int x
270: )
271: {
272: return (NXSwapInt(x));
273: }
274:
275: static __inline__
276: unsigned long
277: NXSwapHostLongToLittle(
278: unsigned long x
279: )
280: {
281: return (NXSwapLong(x));
282: }
283:
284: static __inline__
285: unsigned long long
286: NXSwapHostLongLongToLittle(
287: unsigned long long x
288: )
289: {
290: return (NXSwapLongLong(x));
291: }
292:
293: #ifndef KERNEL
294:
295: static __inline__
296: NXSwappedDouble
297: NXSwapHostDoubleToLittle(
298: double x
299: )
300: {
301: return NXSwapDouble(NXConvertHostDoubleToSwapped(x));
302: }
303:
304: static __inline__
305: NXSwappedFloat
306: NXSwapHostFloatToLittle(
307: float x
308: )
309: {
310: return NXSwapFloat(NXConvertHostFloatToSwapped(x));
311: }
312:
313: #endif /* KERNEL */
314: #endif /*__BIG_ENDIAN__ */
315:
316: #if __LITTLE_ENDIAN__
317:
318: static __inline__
319: unsigned short
320: NXSwapBigShortToHost(
321: unsigned short x
322: )
323: {
324: return (NXSwapShort(x));
325: }
326:
327: static __inline__
328: unsigned int
329: NXSwapBigIntToHost(
330: unsigned int x
331: )
332: {
333: return (NXSwapInt(x));
334: }
335:
336: static __inline__
337: unsigned long
338: NXSwapBigLongToHost(
339: unsigned long x
340: )
341: {
342: return (NXSwapLong(x));
343: }
344:
345: static __inline__
346: unsigned long long
347: NXSwapBigLongLongToHost(
348: unsigned long long x
349: )
350: {
351: return (NXSwapLongLong(x));
352: }
353:
354: static __inline__
355: double
356: NXSwapBigDoubleToHost(
357: NXSwappedDouble x
358: )
359: {
360: return NXConvertSwappedDoubleToHost(NXSwapDouble(x));
361: }
362:
363: static __inline__
364: float
365: NXSwapBigFloatToHost(
366: NXSwappedFloat x
367: )
368: {
369: return NXConvertSwappedFloatToHost(NXSwapFloat(x));
370: }
371:
372: static __inline__
373: unsigned short
374: NXSwapHostShortToBig(
375: unsigned short x
376: )
377: {
378: return (NXSwapShort(x));
379: }
380:
381: static __inline__
382: unsigned int
383: NXSwapHostIntToBig(
384: unsigned int x
385: )
386: {
387: return (NXSwapInt(x));
388: }
389:
390: static __inline__
391: unsigned long
392: NXSwapHostLongToBig(
393: unsigned long x
394: )
395: {
396: return (NXSwapLong(x));
397: }
398:
399: static __inline__
400: unsigned long long
401: NXSwapHostLongLongToBig(
402: unsigned long long x
403: )
404: {
405: return (NXSwapLongLong(x));
406: }
407:
408: static __inline__
409: NXSwappedDouble
410: NXSwapHostDoubleToBig(
411: double x
412: )
413: {
414: return (NXSwapDouble(NXConvertHostDoubleToSwapped(x)));
415: }
416:
417: static __inline__
418: NXSwappedFloat
419: NXSwapHostFloatToBig(
420: float x
421: )
422: {
423: return (NXSwapFloat(NXConvertHostFloatToSwapped(x)));
424: }
425:
426: static __inline__
427: unsigned short
428: NXSwapLittleShortToHost(
429: unsigned short x
430: )
431: {
432: return (x);
433: }
434:
435: static __inline__
436: unsigned int
437: NXSwapLittleIntToHost(
438: unsigned int x
439: )
440: {
441: return (x);
442: }
443:
444: static __inline__
445: unsigned long
446: NXSwapLittleLongToHost(
447: unsigned long x
448: )
449: {
450: return (x);
451: }
452:
453: static __inline__
454: unsigned long long
455: NXSwapLittleLongLongToHost(
456: unsigned long long x
457: )
458: {
459: return (x);
460: }
461:
462: static __inline__
463: double
464: NXSwapLittleDoubleToHost(
465: NXSwappedDouble x
466: )
467: {
468: return NXConvertSwappedDoubleToHost(x);
469: }
470:
471: static __inline__
472: float
473: NXSwapLittleFloatToHost(
474: NXSwappedFloat x
475: )
476: {
477: return NXConvertSwappedFloatToHost(x);
478: }
479:
480: static __inline__
481: unsigned short
482: NXSwapHostShortToLittle(
483: unsigned short x
484: )
485: {
486: return (x);
487: }
488:
489: static __inline__
490: unsigned int
491: NXSwapHostIntToLittle(
492: unsigned int x
493: )
494: {
495: return (x);
496: }
497:
498: static __inline__
499: unsigned long
500: NXSwapHostLongToLittle(
501: unsigned long x
502: )
503: {
504: return (x);
505: }
506:
507: static __inline__
508: unsigned long long
509: NXSwapHostLongLongToLittle(
510: unsigned long long x
511: )
512: {
513: return (x);
514: }
515:
516: static __inline__
517: NXSwappedDouble
518: NXSwapHostDoubleToLittle(
519: double x
520: )
521: {
522: return NXConvertHostDoubleToSwapped(x);
523: }
524:
525: static __inline__
526: NXSwappedFloat
527: NXSwapHostFloatToLittle(
528: float x
529: )
530: {
531: return NXConvertHostFloatToSwapped(x);
532: }
533:
534: #endif /* __LITTLE_ENDIAN__ */
535:
536: #endif /* _ARCHITECTURE_BYTE_ORDER_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.