home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / DEV.Z / NSByteOrder.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-11  |  14.2 KB  |  591 lines
  1. /*    NSByteOrder.h
  2.     Definitions for low-level byte swapping
  3.     Copyright 1995-1996, NeXT Software, Inc.  All rights reserved.
  4. */
  5.  
  6. #if !defined(STRICT_OPENSTEP)
  7.  
  8. enum NSByteOrder {
  9.     NS_UnknownByteOrder,
  10.     NS_LittleEndian,
  11.     NS_BigEndian
  12. };
  13.  
  14. typedef unsigned long NSSwappedFloat;
  15. typedef unsigned long long NSSwappedDouble;
  16.  
  17. static __inline__ enum NSByteOrder NSHostByteOrder(void) {
  18.     unsigned int _x;
  19.     _x = (NS_BigEndian << 24) | NS_LittleEndian;
  20.     return ((enum NSByteOrder)*((unsigned char *)&_x));
  21. }
  22.  
  23. /****************    Basic arch-dependent swapping    ****************/
  24.  
  25. #if defined(m68k)
  26.  
  27. static __inline__ unsigned short NSSwapShort(unsigned short inv) {
  28.     union sconv {
  29.     unsigned short us;
  30.     unsigned char uc[2];
  31.     } *inp, outv;
  32.     inp = (union sconv *)&inv;
  33.     outv.uc[0] = inp->uc[1];
  34.     outv.uc[1] = inp->uc[0];
  35.     return (outv.us);
  36. }
  37.  
  38. static __inline__ unsigned int NSSwapInt(unsigned int inv) {
  39.     union iconv {
  40.     unsigned int ui;
  41.     unsigned char uc[4];
  42.     } *inp, outv;
  43.     inp = (union iconv *)&inv;
  44.     outv.uc[0] = inp->uc[3];
  45.     outv.uc[1] = inp->uc[2];
  46.     outv.uc[2] = inp->uc[1];
  47.     outv.uc[3] = inp->uc[0];
  48.     return (outv.ui);
  49. }
  50.  
  51. static __inline__ unsigned long NSSwapLong(unsigned long inv) {
  52.     union lconv {
  53.     unsigned long ul;
  54.     unsigned char uc[4];
  55.     } *inp, outv;
  56.     inp = (union lconv *)&inv;
  57.     outv.uc[0] = inp->uc[3];
  58.     outv.uc[1] = inp->uc[2];
  59.     outv.uc[2] = inp->uc[1];
  60.     outv.uc[3] = inp->uc[0];
  61.     return (outv.ul);
  62. }
  63.  
  64. static __inline__ unsigned long long NSSwapLongLong(unsigned long long inv) {
  65.     union llconv {
  66.     unsigned long long ull;
  67.     unsigned char uc[8];
  68.     } *inp, outv;
  69.     inp = (union llconv *)&inv;
  70.     outv.uc[0] = inp->uc[7];
  71.     outv.uc[1] = inp->uc[6];
  72.     outv.uc[2] = inp->uc[5];
  73.     outv.uc[3] = inp->uc[4];
  74.     outv.uc[4] = inp->uc[3];
  75.     outv.uc[5] = inp->uc[2];
  76.     outv.uc[6] = inp->uc[1];
  77.     outv.uc[7] = inp->uc[0];
  78.     return (outv.ull);
  79. }
  80.  
  81. static __inline__ NSSwappedFloat NSConvertHostFloatToSwapped(float x) {
  82.     union fconv {
  83.     float number;
  84.     NSSwappedFloat sf;
  85.     };
  86.     return ((union fconv *)&x)->sf;
  87. }
  88.  
  89. static __inline__ float NSConvertSwappedFloatToHost(NSSwappedFloat x) {
  90.     union fconv {
  91.     float number;
  92.     NSSwappedFloat sf;
  93.     };
  94.     return ((union fconv *)&x)->number;
  95. }
  96.  
  97. static __inline__ NSSwappedDouble NSConvertHostDoubleToSwapped(double x) {
  98.     union dconv {
  99.     double number;
  100.     NSSwappedDouble sd;
  101.     };
  102.     return ((union dconv *)&x)->sd;
  103. }
  104.  
  105. static __inline__ double NSConvertSwappedDoubleToHost(NSSwappedDouble x) {
  106.     union dconv {
  107.     double number;
  108.     NSSwappedDouble sd;
  109.     };
  110.     return ((union dconv *)&x)->number;
  111. }
  112.  
  113. static __inline__ NSSwappedFloat NSSwapFloat(NSSwappedFloat x) {
  114.     return NSSwapLong(x);
  115. }
  116.  
  117. static __inline__ NSSwappedDouble NSSwapDouble(NSSwappedDouble x) {
  118.     return NSSwapLongLong(x);
  119. }
  120.  
  121. #elif defined(i386)
  122.  
  123. static __inline__ unsigned short NSSwapShort (unsigned short inv) {
  124.     unsigned short outv;
  125.     __asm__ volatile("rorw $8,%0" : "=r" (outv) : "0" (inv));
  126.     return (outv);
  127. }
  128.  
  129. static __inline__ unsigned int NSSwapInt (unsigned int inv) {
  130.     unsigned int outv;
  131.     __asm__ volatile("bswap %0" : "=r" (outv) : "0" (inv));
  132.     return (outv);
  133. }
  134.  
  135. static __inline__ unsigned long NSSwapLong(unsigned long inv) {
  136.     unsigned long outv;
  137.     __asm__ volatile("bswap %0" : "=r" (outv) : "0" (inv));
  138.     return (outv);
  139. }
  140.  
  141. static __inline__ unsigned long long NSSwapLongLong(unsigned long long inv) {
  142.     union llconv {
  143.     unsigned long long ull;
  144.     unsigned long ul[2];
  145.     } *inp, outv;
  146.     inp = (union llconv *)&inv;
  147.     outv.ul[0] = NSSwapLong(inp->ul[1]);
  148.     outv.ul[1] = NSSwapLong(inp->ul[0]);
  149.     return (outv.ull);
  150. }
  151.  
  152. static __inline__ NSSwappedFloat NSConvertHostFloatToSwapped(float x) {
  153.     union fconv {
  154.     float number;
  155.     NSSwappedFloat sf;
  156.     };
  157.     return ((union fconv *)&x)->sf;
  158. }
  159.  
  160. static __inline__ float NSConvertSwappedFloatToHost(NSSwappedFloat x) {
  161.     union fconv {
  162.     float number;
  163.     NSSwappedFloat sf;
  164.     };
  165.     return ((union fconv *)&x)->number;
  166. }
  167.  
  168. static __inline__ NSSwappedDouble NSConvertHostDoubleToSwapped(double x) {
  169.     union dconv {
  170.     double number;
  171.     NSSwappedDouble sd;
  172.     };
  173.     return ((union dconv *)&x)->sd;
  174. }
  175.  
  176. static __inline__ double NSConvertSwappedDoubleToHost(NSSwappedDouble x) {
  177.     union dconv {
  178.     double number;
  179.     NSSwappedDouble sd;
  180.     };
  181.     return ((union dconv *)&x)->number;
  182. }
  183.  
  184. static __inline__ NSSwappedFloat NSSwapFloat(NSSwappedFloat x) {
  185.     return NSSwapLong(x);
  186. }
  187.  
  188. static __inline__ NSSwappedDouble NSSwapDouble(NSSwappedDouble x) {
  189.     return NSSwapLongLong(x);
  190. }
  191.  
  192. #elif defined(hppa)
  193.  
  194. static __inline__ unsigned short NSSwapShort(unsigned short inv) {
  195.     union sconv {
  196.     unsigned short us;
  197.     unsigned char uc[2];
  198.     } *inp, outv;
  199.     inp = (union sconv *)&inv;
  200.     outv.uc[0] = inp->uc[1];
  201.     outv.uc[1] = inp->uc[0];
  202.     return (outv.us);
  203. }
  204.  
  205. static __inline__ unsigned int NSSwapInt(unsigned int inv) {
  206.     union iconv {
  207.     unsigned int ui;
  208.     unsigned char uc[4];
  209.     } *inp, outv;
  210.     inp = (union iconv *)&inv;
  211.     outv.uc[0] = inp->uc[3];
  212.     outv.uc[1] = inp->uc[2];
  213.     outv.uc[2] = inp->uc[1];
  214.     outv.uc[3] = inp->uc[0];
  215.     return (outv.ui);
  216. }
  217.  
  218. static __inline__ unsigned long NSSwapLong(unsigned long inv) {
  219.     union lconv {
  220.     unsigned long ul;
  221.     unsigned char uc[4];
  222.     } *inp, outv;
  223.     inp = (union lconv *)&inv;
  224.     outv.uc[0] = inp->uc[3];
  225.     outv.uc[1] = inp->uc[2];
  226.     outv.uc[2] = inp->uc[1];
  227.     outv.uc[3] = inp->uc[0];
  228.     return (outv.ul);
  229. }
  230.  
  231. static __inline__ unsigned long long NSSwapLongLong(unsigned long long inv) {
  232.     union llconv {
  233.     unsigned long long ull;
  234.     unsigned char uc[8];
  235.     } *inp, outv;
  236.     inp = (union llconv *)&inv;
  237.     outv.uc[0] = inp->uc[7];
  238.     outv.uc[1] = inp->uc[6];
  239.     outv.uc[2] = inp->uc[5];
  240.     outv.uc[3] = inp->uc[4];
  241.     outv.uc[4] = inp->uc[3];
  242.     outv.uc[5] = inp->uc[2];
  243.     outv.uc[6] = inp->uc[1];
  244.     outv.uc[7] = inp->uc[0];
  245.     return (outv.ull);
  246. }
  247.  
  248. static __inline__ NSSwappedFloat NSConvertHostFloatToSwapped(float x) {
  249.     union fconv {
  250.     float number;
  251.     NSSwappedFloat sf;
  252.     };
  253.     return ((union fconv *)&x)->sf;
  254. }
  255.  
  256. static __inline__ float NSConvertSwappedFloatToHost(NSSwappedFloat x) {
  257.     union fconv {
  258.     float number;
  259.     NSSwappedFloat sf;
  260.     };
  261.     return ((union fconv *)&x)->number;
  262. }
  263.  
  264. static __inline__ NSSwappedDouble NSConvertHostDoubleToSwapped(double x) {
  265.     union dconv {
  266.     double number;
  267.     NSSwappedDouble sd;
  268.     };
  269.     return ((union dconv *)&x)->sd;
  270. }
  271.  
  272. static __inline__ double NSConvertSwappedDoubleToHost(NSSwappedDouble x) {
  273.     union dconv {
  274.     double number;
  275.     NSSwappedDouble sd;
  276.     };
  277.     return ((union dconv *)&x)->number;
  278. }
  279.  
  280. static __inline__ NSSwappedFloat NSSwapFloat(NSSwappedFloat x) {
  281.     return NSSwapLong(x);
  282. }
  283.  
  284. static __inline__ NSSwappedDouble NSSwapDouble(NSSwappedDouble x) {
  285.     return NSSwapLongLong(x);
  286. }
  287.  
  288. #elif defined(sparc)
  289.  
  290. static __inline__ unsigned short NSSwapShort(unsigned short inv) {
  291.     union sconv {
  292.     unsigned short us;
  293.     unsigned char uc[2];
  294.     } *inp, outv;
  295.     inp = (union sconv *)&inv;
  296.     outv.uc[0] = inp->uc[1];
  297.     outv.uc[1] = inp->uc[0];
  298.     return (outv.us);
  299. }
  300.  
  301. static __inline__ unsigned int NSSwapInt(unsigned int inv) {
  302.     union iconv {
  303.     unsigned int ui;
  304.     unsigned char uc[4];
  305.     } *inp, outv;
  306.     inp = (union iconv *)&inv;
  307.     outv.uc[0] = inp->uc[3];
  308.     outv.uc[1] = inp->uc[2];
  309.     outv.uc[2] = inp->uc[1];
  310.     outv.uc[3] = inp->uc[0];
  311.     return (outv.ui);
  312. }
  313.  
  314. static __inline__ unsigned long NSSwapLong(unsigned long inv) {
  315.     union lconv {
  316.     unsigned long ul;
  317.     unsigned char uc[4];
  318.     } *inp, outv;
  319.     inp = (union lconv *)&inv;
  320.     outv.uc[0] = inp->uc[3];
  321.     outv.uc[1] = inp->uc[2];
  322.     outv.uc[2] = inp->uc[1];
  323.     outv.uc[3] = inp->uc[0];
  324.     return (outv.ul);
  325. }
  326.  
  327. static __inline__ unsigned long long NSSwapLongLong(unsigned long long inv) {
  328.     union llconv {
  329.     unsigned long long ull;
  330.     unsigned char uc[8];
  331.     } *inp, outv;
  332.     inp = (union llconv *)&inv;
  333.     outv.uc[0] = inp->uc[7];
  334.     outv.uc[1] = inp->uc[6];
  335.     outv.uc[2] = inp->uc[5];
  336.     outv.uc[3] = inp->uc[4];
  337.     outv.uc[4] = inp->uc[3];
  338.     outv.uc[5] = inp->uc[2];
  339.     outv.uc[6] = inp->uc[1];
  340.     outv.uc[7] = inp->uc[0];
  341.     return (outv.ull);
  342. }
  343.  
  344. static __inline__ NSSwappedFloat NSConvertHostFloatToSwapped(float x) {
  345.     union fconv {
  346.     float number;
  347.     NSSwappedFloat sf;
  348.     };
  349.     return ((union fconv *)&x)->sf;
  350. }
  351.  
  352. static __inline__ float NSConvertSwappedFloatToHost(NSSwappedFloat x) {
  353.     union fconv {
  354.     float number;
  355.     NSSwappedFloat sf;
  356.     };
  357.     return ((union fconv *)&x)->number;
  358. }
  359.  
  360. static __inline__ NSSwappedDouble NSConvertHostDoubleToSwapped(double x) {
  361.     union dconv {
  362.     double number;
  363.     NSSwappedDouble sd;
  364.     };
  365.     return ((union dconv *)&x)->sd;
  366. }
  367.  
  368. static __inline__ double NSConvertSwappedDoubleToHost(NSSwappedDouble x) {
  369.     union dconv {
  370.     double number;
  371.     NSSwappedDouble sd;
  372.     };
  373.     return ((union dconv *)&x)->number;
  374. }
  375.  
  376. static __inline__ NSSwappedFloat NSSwapFloat(NSSwappedFloat x) {
  377.     return NSSwapLong(x);
  378. }
  379.  
  380. static __inline__ NSSwappedDouble NSSwapDouble(NSSwappedDouble x) {
  381.     return NSSwapLongLong(x);
  382. }
  383.  
  384. #else
  385. #error Do not know how to byte order this architecture
  386. #endif
  387.  
  388. /*************** Swapping to big/little endian ***************/
  389.  
  390. #if defined(__BIG_ENDIAN__)
  391.  
  392. static __inline__ unsigned short NSSwapBigShortToHost(unsigned short x) {
  393.     return (x);
  394. }
  395.  
  396. static __inline__ unsigned int NSSwapBigIntToHost(unsigned int x) {
  397.     return (x);
  398. }
  399.  
  400. static __inline__ unsigned long NSSwapBigLongToHost(unsigned long x) {
  401.     return (x);
  402. }
  403.  
  404. static __inline__ unsigned long long NSSwapBigLongLongToHost(unsigned long long x) {
  405.     return (x);
  406. }
  407.  
  408. static __inline__ double NSSwapBigDoubleToHost(NSSwappedDouble x) {
  409.     return NSConvertSwappedDoubleToHost(x);
  410. }
  411.  
  412. static __inline__ float NSSwapBigFloatToHost(NSSwappedFloat x) {
  413.     return NSConvertSwappedFloatToHost(x);
  414. }
  415.  
  416. static __inline__ unsigned short NSSwapHostShortToBig(unsigned short x) {
  417.     return (x);
  418. }
  419.  
  420. static __inline__ unsigned int NSSwapHostIntToBig(unsigned int x) {
  421.     return (x);
  422. }
  423.  
  424. static __inline__ unsigned long NSSwapHostLongToBig(unsigned long x) {
  425.     return (x);
  426. }
  427.  
  428. static __inline__ unsigned long long NSSwapHostLongLongToBig(unsigned long long x) {
  429.     return (x);
  430. }
  431.  
  432. static __inline__ NSSwappedDouble NSSwapHostDoubleToBig(double x) {
  433.     return NSConvertHostDoubleToSwapped(x);
  434. }
  435.  
  436. static __inline__ NSSwappedFloat NSSwapHostFloatToBig(float x) {
  437.     return NSConvertHostFloatToSwapped(x);
  438. }
  439.  
  440. static __inline__ unsigned short NSSwapLittleShortToHost(unsigned short x) {
  441.     return NSSwapShort(x);
  442. }
  443.  
  444. static __inline__ unsigned int NSSwapLittleIntToHost(unsigned int x) {
  445.     return NSSwapInt(x);
  446. }
  447.  
  448. static __inline__ unsigned long NSSwapLittleLongToHost(unsigned long x) {
  449.     return NSSwapLong(x);
  450. }
  451.  
  452. static __inline__ unsigned long long NSSwapLittleLongLongToHost(unsigned long long x) {
  453.     return NSSwapLongLong(x);
  454. }
  455.  
  456. static __inline__ double NSSwapLittleDoubleToHost(NSSwappedDouble x) {
  457.     return NSConvertSwappedDoubleToHost(NSSwapDouble(x));
  458. }
  459.  
  460. static __inline__ float NSSwapLittleFloatToHost(NSSwappedFloat x) {
  461.     return NSConvertSwappedFloatToHost(NSSwapFloat(x));
  462. }
  463.  
  464. static __inline__ unsigned short NSSwapHostShortToLittle(unsigned short x) {
  465.     return NSSwapShort(x);
  466. }
  467.  
  468. static __inline__ unsigned int NSSwapHostIntToLittle(unsigned int x) {
  469.     return NSSwapInt(x);
  470. }
  471.  
  472. static __inline__ unsigned long NSSwapHostLongToLittle(unsigned long x) {
  473.     return NSSwapLong(x);
  474. }
  475.  
  476. static __inline__ unsigned long long NSSwapHostLongLongToLittle(unsigned long long x) {
  477.     return NSSwapLongLong(x);
  478. }
  479.  
  480. static __inline__ NSSwappedDouble NSSwapHostDoubleToLittle(double x) {
  481.     return NSSwapDouble(NSConvertHostDoubleToSwapped(x));
  482. }
  483.  
  484. static __inline__ NSSwappedFloat NSSwapHostFloatToLittle(float x) {
  485.     return NSSwapFloat(NSConvertHostFloatToSwapped(x));
  486. }
  487.  
  488. #elif defined(__LITTLE_ENDIAN__)
  489.  
  490. static __inline__ unsigned short NSSwapBigShortToHost(unsigned short x) {
  491.     return NSSwapShort(x);
  492. }
  493.  
  494. static __inline__ unsigned int NSSwapBigIntToHost(unsigned int x) {
  495.     return NSSwapInt(x);
  496. }
  497.  
  498. static __inline__ unsigned long NSSwapBigLongToHost(unsigned long x) {
  499.     return NSSwapLong(x);
  500. }
  501.  
  502. static __inline__ unsigned long long NSSwapBigLongLongToHost(unsigned long long x) {
  503.     return NSSwapLongLong(x);
  504. }
  505.  
  506. static __inline__ double NSSwapBigDoubleToHost(NSSwappedDouble x) {
  507.     return NSConvertSwappedDoubleToHost(NSSwapDouble(x));
  508. }
  509.  
  510. static __inline__ float NSSwapBigFloatToHost(NSSwappedFloat x) {
  511.     return NSConvertSwappedFloatToHost(NSSwapFloat(x));
  512. }
  513.  
  514. static __inline__ unsigned short NSSwapHostShortToBig(unsigned short x) {
  515.     return NSSwapShort(x);
  516. }
  517.  
  518. static __inline__ unsigned int NSSwapHostIntToBig(unsigned int x) {
  519.     return NSSwapInt(x);
  520. }
  521.  
  522. static __inline__ unsigned long NSSwapHostLongToBig(unsigned long x) {
  523.     return NSSwapLong(x);
  524. }
  525.  
  526. static __inline__ unsigned long long NSSwapHostLongLongToBig(unsigned long long x) {
  527.     return NSSwapLongLong(x);
  528. }
  529.  
  530. static __inline__ NSSwappedDouble NSSwapHostDoubleToBig(double x) {
  531.     return NSSwapDouble(NSConvertHostDoubleToSwapped(x));
  532. }
  533.  
  534. static __inline__ NSSwappedFloat NSSwapHostFloatToBig(float x) {
  535.     return NSSwapFloat(NSConvertHostFloatToSwapped(x));
  536. }
  537.  
  538. static __inline__ unsigned short NSSwapLittleShortToHost(unsigned short x) {
  539.     return (x);
  540. }
  541.  
  542. static __inline__ unsigned int NSSwapLittleIntToHost(unsigned int x) {
  543.     return (x);
  544. }
  545.  
  546. static __inline__ unsigned long NSSwapLittleLongToHost(unsigned long x) {
  547.     return (x);
  548. }
  549.  
  550. static __inline__ unsigned long long NSSwapLittleLongLongToHost(unsigned long long x) {
  551.     return (x);
  552. }
  553.  
  554. static __inline__ double NSSwapLittleDoubleToHost(NSSwappedDouble x) {
  555.     return NSConvertSwappedDoubleToHost(x);
  556. }
  557.  
  558. static __inline__ float NSSwapLittleFloatToHost(NSSwappedFloat x) {
  559.     return NSConvertSwappedFloatToHost(x);
  560. }
  561.  
  562. static __inline__ unsigned short NSSwapHostShortToLittle(unsigned short x) {
  563.     return (x);
  564. }
  565.  
  566. static __inline__ unsigned int NSSwapHostIntToLittle(unsigned int x) {
  567.     return (x);
  568. }
  569.  
  570. static __inline__ unsigned long NSSwapHostLongToLittle(unsigned long x) {
  571.     return (x);
  572. }
  573.  
  574. static __inline__ unsigned long long NSSwapHostLongLongToLittle(unsigned long long x) {
  575.     return (x);
  576. }
  577.  
  578. static __inline__ NSSwappedDouble NSSwapHostDoubleToLittle(double x) {
  579.     return NSConvertHostDoubleToSwapped(x);
  580. }
  581.  
  582. static __inline__ NSSwappedFloat NSSwapHostFloatToLittle(float x) {
  583.     return NSConvertHostFloatToSwapped(x);
  584. }
  585.  
  586. #else
  587. #error Do not endianess of this architecture
  588. #endif
  589.  
  590. #endif /* !STRICT_OPENSTEP */
  591.