test-suite-pull-tools-directly-in-20020114
[openafs.git] / src / tests / intNN.h
1 /*
2  * CMUCS AFStools
3  * dumpscan - routines for scanning and manipulating AFS volume dumps
4  *
5  * Copyright (c) 1998 Carnegie Mellon University
6  * All Rights Reserved.
7  * 
8  * Permission to use, copy, modify and distribute this software and its
9  * documentation is hereby granted, provided that both the copyright
10  * notice and this permission notice appear in all copies of the
11  * software, derivative works or modified versions, and any portions
12  * thereof, and that both notices appear in supporting documentation.
13  *
14  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
15  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
16  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17  *
18  * Carnegie Mellon requests users of this software to return to
19  *
20  *  Software Distribution Coordinator  or  Software_Distribution@CS.CMU.EDU
21  *  School of Computer Science
22  *  Carnegie Mellon University
23  *  Pittsburgh PA 15213-3890
24  *
25  * any improvements or extensions that they make and grant Carnegie Mellon
26  * the rights to redistribute these changes.
27  */
28
29 #ifndef _INTNN_H_
30 #define _INTNN_H_
31
32 /* intNN.h - Sized integer types */
33 #include <afs/stds.h>
34 #if 0
35 typedef short afs_int16;
36 typedef unsigned short afs_uint16;
37
38 typedef long afs_int32;
39 typedef unsigned long afs_uint32;
40 #endif
41
42
43 /* Support for 64-bit integers.
44  * Presently, only unsigned 64-bit numbers are supported.
45  */
46 #define INT64_TEST_STR "0x12345678fedcba98"
47 #define INT64_TEST_HI  0x12345678
48 #define INT64_TEST_LO  0xfedcba98
49
50
51 #ifdef NATIVE_INT64
52 typedef unsigned NATIVE_INT64 u_int64;
53
54 /* construct/extract/assign */
55 #define mk64(X,H,L) ((X) = ( ((u_int64)(H) << 32) \
56                            | ((u_int64)(L) & 0xffffffff)))
57 #define hi64(Y)     ((afs_uint32)(((Y) >> 32) & 0xffffffff))
58 #define lo64(Y)     ((afs_uint32)((Y) & 0xffffffff))
59 #define ex64(Y,H,L) ((H) = hi64(Y), (L) = lo64(Y))
60 #define cp64(X,Y)   ((X) = (Y))
61 #define get64(X)    (X)
62 #define set64(X,V)  ((X) = (V))
63
64 /* Comparison */
65 #define eq64(X,Y)   ((X) == (Y))
66 #define ne64(X,Y)   ((X) != (Y))
67 #define lt64(X,Y)   ((X) <  (Y))
68 #define le64(X,Y)   ((X) <= (Y))
69 #define gt64(X,Y)   ((X) >  (Y))
70 #define ge64(X,Y)   ((X) >= (Y))
71 #define zero64(X)   (!(X))
72
73 /* Arithmetic */
74 #define add64_32(X,A,B) ((X) = (A) + (u_int64)(B))
75 #define add64_64(X,A,B) ((X) = (A) + (B))
76 #define sub64_32(X,A,B) ((X) = (A) - (u_int64)(B))
77 #define sub64_64(X,A,B) ((X) = (A) - (B))
78
79 /* Byte-order */
80 #ifdef WORDS_BIGENDIAN
81 #define hton64(X,Y) cp64(X,Y)
82 #define ntoh64(X,Y) cp64(X,Y)
83 #else
84 #define hton64(X,Y) mk64(X,htonl(lo64(Y)),htonl(hi64(Y)))
85 #define ntoh64(X,Y) mk64(X,ntohl(lo64(Y)),ntohl(hi64(Y)))
86 #endif
87
88 #else /* !NATIVE_INT64 */
89 /** We have to provide our own 64-bit integers **/
90 typedef struct { afs_uint32 hi, lo; } u_int64;
91
92 /* construct/extract/assign */
93 #define mk64(X,H,L) ((X).hi = (H), (X).lo = (L))
94 #define ex64(Y,H,L) ((H) = (Y).hi, (L) = (Y).lo)
95 #define hi64(Y)     ((Y).hi)
96 #define lo64(Y)     ((Y).lo)
97 #define cp64(X,Y)   ((X).hi = (Y).hi, (X).lo = (Y).lo)
98 #define get64(X)    ((X).lo)
99 #define set64(X,V)  ((X).hi = 0, (X).lo = (V))
100
101 /* Comparison */
102 #define eq64(A,B) ((A).hi == (B).hi && (A).lo == (B).lo)
103 #define ne64(A,B) ((A).hi != (B).hi || (A).lo != (B).lo)
104 #define lt64(A,B) ((A).hi <  (B).hi || ((A).hi == (B).hi && (A).lo <  (B).lo))
105 #define le64(A,B) ((A).hi <  (B).hi || ((A).hi == (B).hi && (A).lo <= (B).lo))
106 #define gt64(A,B) ((A).hi >  (B).hi || ((A).hi == (B).hi && (A).lo >  (B).lo))
107 #define ge64(A,B) ((A).hi >  (B).hi || ((A).hi == (B).hi && (A).lo >= (B).lo))
108 #define zero64(X) ((X).hi == 0 && (X).lo == 0)
109
110 /* Arithmetic */
111 #define add64_32(X,A,B) (                                              \
112   (X).lo = (A).lo + (B),                                               \
113   (X).hi = (A).hi +                                                    \
114    (((((A).lo & 0x80000000) ^  ((B) & 0x80000000)) && !((X).lo & 0x80000000)) \
115   || (((A).lo & 0x80000000) && ((B) & 0x80000000)))                     \
116   )
117 #define add64_64(X,A,B) (add64_32(X,A,(B).lo), (X).hi += (B).hi)
118
119 #define sub64_32(X,A,B) ((X).lo = (A).lo - (B), \
120                          (X).hi = (A).hi - ((A).lo < (B)))
121 #define sub64_64(X,A,B) (sub64_32(X,A,(B).lo), (X).hi -= (B).hi)
122
123 /* Byte-order */
124 #define hton64(X,Y) mk64(X,htonl(hi64(Y)),htonl(lo64(Y)))
125 #define ntoh64(X,Y) mk64(X,ntohl(hi64(Y)),ntohl(lo64(Y)))
126
127 #endif /* NATIVE_INT64 */
128
129
130 /* The following are too complex to be macros: */
131
132 /* char *hexify_int64(u_int64 a, char *buf)
133  * Produces an ASCII representation of a in hexadecimal, and returns
134  * a pointer to the resulting string.  If buf is non-NULL, it is taken
135  * to be a pointer to the buffer to be used, which must be at least 17
136  * bytes long.  This function is thread-safe iff buf is provided.
137  */
138 extern char *hexify_int64(u_int64 *, char *);
139
140 /* char *decimate_int64(u_int64 a, char *buf)
141  * Produces an ASCII representation of a in decimal, and returns
142  * a pointer to the resulting string.  If buf is non-NULL, it is taken
143  * to be a pointer to the buffer to be used, which must be at least 21
144  * bytes long.  This function is thread-safe iff buf is provided.
145  */
146 extern char *decimate_int64(u_int64 *, char *);
147
148 /* void shift_int64(u_int64 a, int bits)
149  * Shifts the 64-bit integer in a by the specified number of bits.
150  * If bits is positive, the shift is to the left; if negative, the
151  * shift is to the right.
152  */
153 extern void shift_int64(u_int64 *, int);
154
155 #endif /* _INTNN_H_ */