1 /**************************************************************************/
2 /*                                                                        */
3 /*                                 OCaml                                  */
4 /*                                                                        */
5 /*             Xavier Leroy, projet Cristal, INRIA Rocquencourt           */
6 /*                                                                        */
7 /*   Copyright 1996 Institut National de Recherche en Informatique et     */
8 /*     en Automatique.                                                    */
9 /*                                                                        */
10 /*   All rights reserved.  This file is distributed under the terms of    */
11 /*   the GNU Lesser General Public License version 2.1, with the          */
12 /*   special exception on linking described in the file LICENSE.          */
13 /*                                                                        */
14 /**************************************************************************/
15 
16 /* Swap byte-order in 16, 32, and 64-bit integers or floats */
17 
18 #ifndef CAML_REVERSE_H
19 #define CAML_REVERSE_H
20 
21 #ifdef CAML_INTERNALS
22 
23 #define Reverse_16(dst,src) {                                               \
24   char * _p, * _q;                                                          \
25   char _a;                                                                  \
26   _p = (char *) (src);                                                      \
27   _q = (char *) (dst);                                                      \
28   _a = _p[0];                                                               \
29   _q[0] = _p[1];                                                            \
30   _q[1] = _a;                                                               \
31 }
32 
33 #define Reverse_32(dst,src) {                                               \
34   char * _p, * _q;                                                          \
35   char _a, _b;                                                              \
36   _p = (char *) (src);                                                      \
37   _q = (char *) (dst);                                                      \
38   _a = _p[0];                                                               \
39   _b = _p[1];                                                               \
40   _q[0] = _p[3];                                                            \
41   _q[1] = _p[2];                                                            \
42   _q[3] = _a;                                                               \
43   _q[2] = _b;                                                               \
44 }
45 
46 #define Reverse_64(dst,src) {                                               \
47   char * _p, * _q;                                                          \
48   char _a, _b;                                                              \
49   _p = (char *) (src);                                                      \
50   _q = (char *) (dst);                                                      \
51   _a = _p[0];                                                               \
52   _b = _p[1];                                                               \
53   _q[0] = _p[7];                                                            \
54   _q[1] = _p[6];                                                            \
55   _q[7] = _a;                                                               \
56   _q[6] = _b;                                                               \
57   _a = _p[2];                                                               \
58   _b = _p[3];                                                               \
59   _q[2] = _p[5];                                                            \
60   _q[3] = _p[4];                                                            \
61   _q[5] = _a;                                                               \
62   _q[4] = _b;                                                               \
63 }
64 
65 #define Perm_index(perm,i) ((perm >> (i * 4)) & 0xF)
66 
67 #define Permute_64(dst,perm_dst,src,perm_src) {                             \
68   char * _p;                                                                \
69   char _a, _b, _c, _d, _e, _f, _g, _h;                                      \
70   _p = (char *) (src);                                                      \
71   _a = _p[Perm_index(perm_src, 0)];                                         \
72   _b = _p[Perm_index(perm_src, 1)];                                         \
73   _c = _p[Perm_index(perm_src, 2)];                                         \
74   _d = _p[Perm_index(perm_src, 3)];                                         \
75   _e = _p[Perm_index(perm_src, 4)];                                         \
76   _f = _p[Perm_index(perm_src, 5)];                                         \
77   _g = _p[Perm_index(perm_src, 6)];                                         \
78   _h = _p[Perm_index(perm_src, 7)];                                         \
79   _p = (char *) (dst);                                                      \
80   _p[Perm_index(perm_dst, 0)] = _a;                                         \
81   _p[Perm_index(perm_dst, 1)] = _b;                                         \
82   _p[Perm_index(perm_dst, 2)] = _c;                                         \
83   _p[Perm_index(perm_dst, 3)] = _d;                                         \
84   _p[Perm_index(perm_dst, 4)] = _e;                                         \
85   _p[Perm_index(perm_dst, 5)] = _f;                                         \
86   _p[Perm_index(perm_dst, 6)] = _g;                                         \
87   _p[Perm_index(perm_dst, 7)] = _h;                                         \
88 }
89 
90 #endif /* CAML_INTERNALS */
91 
92 #endif /* CAML_REVERSE_H */
93