![[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.