← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/ut0byte.h

  • Committer: Brian Aker
  • Date: 2009-07-11 19:23:04 UTC
  • mfrom: (1089.1.14 merge)
  • Revision ID: brian@gaz-20090711192304-ootijyl5yf9jq9kd
Merge Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ut0byte.h
1
 
/**********************************************************************
2
 
Utilities for byte operations
3
 
 
4
 
(c) 1994, 1995 Innobase Oy
5
 
 
6
 
Created 1/20/1994 Heikki Tuuri
7
 
***********************************************************************/
8
 
 
9
 
#ifndef ut0byte_h
10
 
#define ut0byte_h
11
 
 
12
 
 
13
 
#include "univ.i"
14
 
 
15
 
/* Type definition for a 64-bit unsigned integer, which works also
16
 
in 32-bit machines. NOTE! Access the fields only with the accessor
17
 
functions. This definition appears here only for the compiler to
18
 
know the size of a dulint. */
19
 
 
20
 
typedef struct dulint_struct    dulint;
21
 
struct dulint_struct{
22
 
        ulint   high;   /* most significant 32 bits */
23
 
        ulint   low;    /* least significant 32 bits */
24
 
};
25
 
 
26
 
/* Zero value for a dulint */
27
 
extern dulint   ut_dulint_zero;
28
 
 
29
 
/* Maximum value for a dulint */
30
 
extern dulint   ut_dulint_max;
31
 
 
32
 
/***********************************************************
33
 
Creates a 64-bit dulint out of two ulints. */
34
 
UNIV_INLINE
35
 
dulint
36
 
ut_dulint_create(
37
 
/*=============*/
38
 
                        /* out: created dulint */
39
 
        ulint   high,   /* in: high-order 32 bits */
40
 
        ulint   low);   /* in: low-order 32 bits */
41
 
/***********************************************************
42
 
Gets the high-order 32 bits of a dulint. */
43
 
UNIV_INLINE
44
 
ulint
45
 
ut_dulint_get_high(
46
 
/*===============*/
47
 
                        /* out: 32 bits in ulint */
48
 
        dulint  d);     /* in: dulint */
49
 
/***********************************************************
50
 
Gets the low-order 32 bits of a dulint. */
51
 
UNIV_INLINE
52
 
ulint
53
 
ut_dulint_get_low(
54
 
/*==============*/
55
 
                        /* out: 32 bits in ulint */
56
 
        dulint  d);     /* in: dulint */
57
 
/***********************************************************
58
 
Converts a dulint (a struct of 2 ulints) to ib_longlong, which is a 64-bit
59
 
integer type. */
60
 
UNIV_INLINE
61
 
ib_longlong
62
 
ut_conv_dulint_to_longlong(
63
 
/*=======================*/
64
 
                        /* out: value in ib_longlong type */
65
 
        dulint  d);     /* in: dulint */
66
 
/***********************************************************
67
 
Tests if a dulint is zero. */
68
 
UNIV_INLINE
69
 
ibool
70
 
ut_dulint_is_zero(
71
 
/*==============*/
72
 
                        /* out: TRUE if zero */
73
 
        dulint  a);     /* in: dulint */
74
 
/***********************************************************
75
 
Compares two dulints. */
76
 
UNIV_INLINE
77
 
int
78
 
ut_dulint_cmp(
79
 
/*==========*/
80
 
                        /* out: -1 if a < b, 0 if a == b,
81
 
                        1 if a > b */
82
 
        dulint  a,      /* in: dulint */
83
 
        dulint  b);     /* in: dulint */
84
 
/***********************************************************
85
 
Calculates the max of two dulints. */
86
 
UNIV_INLINE
87
 
dulint
88
 
ut_dulint_get_max(
89
 
/*==============*/
90
 
                        /* out: max(a, b) */
91
 
        dulint  a,      /* in: dulint */
92
 
        dulint  b);     /* in: dulint */
93
 
/***********************************************************
94
 
Calculates the min of two dulints. */
95
 
UNIV_INLINE
96
 
dulint
97
 
ut_dulint_get_min(
98
 
/*==============*/
99
 
                        /* out: min(a, b) */
100
 
        dulint  a,      /* in: dulint */
101
 
        dulint  b);     /* in: dulint */
102
 
/***********************************************************
103
 
Adds a ulint to a dulint. */
104
 
UNIV_INLINE
105
 
dulint
106
 
ut_dulint_add(
107
 
/*==========*/
108
 
                        /* out: sum a + b */
109
 
        dulint  a,      /* in: dulint */
110
 
        ulint   b);     /* in: ulint */
111
 
/***********************************************************
112
 
Subtracts a ulint from a dulint. */
113
 
UNIV_INLINE
114
 
dulint
115
 
ut_dulint_subtract(
116
 
/*===============*/
117
 
                        /* out: a - b */
118
 
        dulint  a,      /* in: dulint */
119
 
        ulint   b);     /* in: ulint, b <= a */
120
 
/***********************************************************
121
 
Subtracts a dulint from another. NOTE that the difference must be positive
122
 
and smaller that 4G. */
123
 
UNIV_INLINE
124
 
ulint
125
 
ut_dulint_minus(
126
 
/*============*/
127
 
                        /* out: a - b */
128
 
        dulint  a,      /* in: dulint; NOTE a must be >= b and at most
129
 
                        2 to power 32 - 1 greater */
130
 
        dulint  b);     /* in: dulint */
131
 
/************************************************************
132
 
Rounds a dulint downward to a multiple of a power of 2. */
133
 
UNIV_INLINE
134
 
dulint
135
 
ut_dulint_align_down(
136
 
/*=================*/
137
 
                                /* out: rounded value */
138
 
        dulint   n,             /* in: number to be rounded */
139
 
        ulint    align_no);     /* in: align by this number which must be a
140
 
                                power of 2 */
141
 
/************************************************************
142
 
Rounds a dulint upward to a multiple of a power of 2. */
143
 
UNIV_INLINE
144
 
dulint
145
 
ut_dulint_align_up(
146
 
/*===============*/
147
 
                                /* out: rounded value */
148
 
        dulint   n,             /* in: number to be rounded */
149
 
        ulint    align_no);     /* in: align by this number which must be a
150
 
                                power of 2 */
151
 
/***********************************************************
152
 
Increments a dulint variable by 1. */
153
 
#define UT_DULINT_INC(D)\
154
 
{\
155
 
        if ((D).low == 0xFFFFFFFFUL) {\
156
 
                (D).high = (D).high + 1;\
157
 
                (D).low = 0;\
158
 
        } else {\
159
 
                (D).low = (D).low + 1;\
160
 
        }\
161
 
}
162
 
/***********************************************************
163
 
Tests if two dulints are equal. */
164
 
#define UT_DULINT_EQ(D1, D2)    (((D1).low == (D2).low)\
165
 
                                                && ((D1).high == (D2).high))
166
 
/****************************************************************
167
 
Sort function for dulint arrays. */
168
 
void
169
 
ut_dulint_sort(dulint* arr, dulint* aux_arr, ulint low, ulint high);
170
 
/*===============================================================*/
171
 
/************************************************************
172
 
The following function calculates the value of an integer n rounded
173
 
to the least product of align_no which is >= n. align_no has to be a
174
 
power of 2. */
175
 
UNIV_INLINE
176
 
ulint
177
 
ut_calc_align(
178
 
/*==========*/
179
 
                                /* out: rounded value */
180
 
        ulint    n,             /* in: number to be rounded */
181
 
        ulint    align_no);     /* in: align by this number */
182
 
/************************************************************
183
 
The following function calculates the value of an integer n rounded
184
 
to the biggest product of align_no which is <= n. align_no has to be a
185
 
power of 2. */
186
 
UNIV_INLINE
187
 
ulint
188
 
ut_calc_align_down(
189
 
/*===============*/
190
 
                                /* out: rounded value */
191
 
        ulint    n,             /* in: number to be rounded */
192
 
        ulint    align_no);     /* in: align by this number */
193
 
/*************************************************************
194
 
The following function rounds up a pointer to the nearest aligned address. */
195
 
UNIV_INLINE
196
 
void*
197
 
ut_align(
198
 
/*=====*/
199
 
                                /* out: aligned pointer */
200
 
        const void*     ptr,            /* in: pointer */
201
 
        ulint   align_no);      /* in: align by this number */
202
 
/*************************************************************
203
 
The following function rounds down a pointer to the nearest
204
 
aligned address. */
205
 
UNIV_INLINE
206
 
void*
207
 
ut_align_down(
208
 
/*==========*/
209
 
                                /* out: aligned pointer */
210
 
        const void*     ptr,            /* in: pointer */
211
 
        ulint   align_no)       /* in: align by this number */
212
 
                __attribute__((const));
213
 
/*************************************************************
214
 
The following function computes the offset of a pointer from the nearest
215
 
aligned address. */
216
 
UNIV_INLINE
217
 
ulint
218
 
ut_align_offset(
219
 
/*============*/
220
 
                                        /* out: distance from aligned
221
 
                                        pointer */
222
 
        const void*     ptr,            /* in: pointer */
223
 
        ulint           align_no)       /* in: align by this number */
224
 
                        __attribute__((const));
225
 
/*********************************************************************
226
 
Gets the nth bit of a ulint. */
227
 
UNIV_INLINE
228
 
ibool
229
 
ut_bit_get_nth(
230
 
/*===========*/
231
 
                        /* out: TRUE if nth bit is 1; 0th bit is defined to
232
 
                        be the least significant */
233
 
        ulint   a,      /* in: ulint */
234
 
        ulint   n);     /* in: nth bit requested */
235
 
/*********************************************************************
236
 
Sets the nth bit of a ulint. */
237
 
UNIV_INLINE
238
 
ulint
239
 
ut_bit_set_nth(
240
 
/*===========*/
241
 
                        /* out: the ulint with the bit set as requested */
242
 
        ulint   a,      /* in: ulint */
243
 
        ulint   n,      /* in: nth bit requested */
244
 
        ibool   val);   /* in: value for the bit to set */
245
 
 
246
 
#ifndef UNIV_NONINL
247
 
#include "ut0byte.ic"
248
 
#endif
249
 
 
250
 
#endif