← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innodb_plugin/include/ut0byte.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/******************************************************************//**
 
20
@file include/ut0byte.h
 
21
Utilities for byte operations
 
22
 
 
23
Created 1/20/1994 Heikki Tuuri
 
24
***********************************************************************/
 
25
 
 
26
#ifndef ut0byte_h
 
27
#define ut0byte_h
 
28
 
 
29
 
 
30
#include "univ.i"
 
31
 
 
32
/** Pair of ulint integers. */
 
33
typedef struct dulint_struct    dulint;
 
34
/** Type definition for a 64-bit unsigned integer, which works also
 
35
in 32-bit machines. NOTE! Access the fields only with the accessor
 
36
functions. This definition appears here only for the compiler to
 
37
know the size of a dulint. */
 
38
struct dulint_struct{
 
39
        ulint   high;   /*!< most significant 32 bits */
 
40
        ulint   low;    /*!< least significant 32 bits */
 
41
};
 
42
 
 
43
/** Zero value for a dulint */
 
44
extern const dulint     ut_dulint_zero;
 
45
 
 
46
/** Maximum value for a dulint */
 
47
extern const dulint     ut_dulint_max;
 
48
 
 
49
/*******************************************************//**
 
50
Creates a 64-bit dulint out of two ulints.
 
51
@return created dulint */
 
52
UNIV_INLINE
 
53
dulint
 
54
ut_dulint_create(
 
55
/*=============*/
 
56
        ulint   high,   /*!< in: high-order 32 bits */
 
57
        ulint   low);   /*!< in: low-order 32 bits */
 
58
/*******************************************************//**
 
59
Gets the high-order 32 bits of a dulint.
 
60
@return 32 bits in ulint */
 
61
UNIV_INLINE
 
62
ulint
 
63
ut_dulint_get_high(
 
64
/*===============*/
 
65
        dulint  d);     /*!< in: dulint */
 
66
/*******************************************************//**
 
67
Gets the low-order 32 bits of a dulint.
 
68
@return 32 bits in ulint */
 
69
UNIV_INLINE
 
70
ulint
 
71
ut_dulint_get_low(
 
72
/*==============*/
 
73
        dulint  d);     /*!< in: dulint */
 
74
/*******************************************************//**
 
75
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
 
76
integer type.
 
77
@return value in ib_int64_t type */
 
78
UNIV_INLINE
 
79
ib_int64_t
 
80
ut_conv_dulint_to_longlong(
 
81
/*=======================*/
 
82
        dulint  d);     /*!< in: dulint */
 
83
/*******************************************************//**
 
84
Tests if a dulint is zero.
 
85
@return TRUE if zero */
 
86
UNIV_INLINE
 
87
ibool
 
88
ut_dulint_is_zero(
 
89
/*==============*/
 
90
        dulint  a);     /*!< in: dulint */
 
91
/*******************************************************//**
 
92
Compares two dulints.
 
93
@return -1 if a < b, 0 if a == b, 1 if a > b */
 
94
UNIV_INLINE
 
95
int
 
96
ut_dulint_cmp(
 
97
/*==========*/
 
98
        dulint  a,      /*!< in: dulint */
 
99
        dulint  b);     /*!< in: dulint */
 
100
/*******************************************************//**
 
101
Calculates the max of two dulints.
 
102
@return max(a, b) */
 
103
UNIV_INLINE
 
104
dulint
 
105
ut_dulint_get_max(
 
106
/*==============*/
 
107
        dulint  a,      /*!< in: dulint */
 
108
        dulint  b);     /*!< in: dulint */
 
109
/*******************************************************//**
 
110
Calculates the min of two dulints.
 
111
@return min(a, b) */
 
112
UNIV_INLINE
 
113
dulint
 
114
ut_dulint_get_min(
 
115
/*==============*/
 
116
        dulint  a,      /*!< in: dulint */
 
117
        dulint  b);     /*!< in: dulint */
 
118
/*******************************************************//**
 
119
Adds a ulint to a dulint.
 
120
@return sum a + b */
 
121
UNIV_INLINE
 
122
dulint
 
123
ut_dulint_add(
 
124
/*==========*/
 
125
        dulint  a,      /*!< in: dulint */
 
126
        ulint   b);     /*!< in: ulint */
 
127
/*******************************************************//**
 
128
Subtracts a ulint from a dulint.
 
129
@return a - b */
 
130
UNIV_INLINE
 
131
dulint
 
132
ut_dulint_subtract(
 
133
/*===============*/
 
134
        dulint  a,      /*!< in: dulint */
 
135
        ulint   b);     /*!< in: ulint, b <= a */
 
136
/*******************************************************//**
 
137
Subtracts a dulint from another. NOTE that the difference must be positive
 
138
and smaller that 4G.
 
139
@return a - b */
 
140
UNIV_INLINE
 
141
ulint
 
142
ut_dulint_minus(
 
143
/*============*/
 
144
        dulint  a,      /*!< in: dulint; NOTE a must be >= b and at most
 
145
                        2 to power 32 - 1 greater */
 
146
        dulint  b);     /*!< in: dulint */
 
147
/********************************************************//**
 
148
Rounds a dulint downward to a multiple of a power of 2.
 
149
@return rounded value */
 
150
UNIV_INLINE
 
151
dulint
 
152
ut_dulint_align_down(
 
153
/*=================*/
 
154
        dulint   n,             /*!< in: number to be rounded */
 
155
        ulint    align_no);     /*!< in: align by this number which must be a
 
156
                                power of 2 */
 
157
/********************************************************//**
 
158
Rounds a dulint upward to a multiple of a power of 2.
 
159
@return rounded value */
 
160
UNIV_INLINE
 
161
dulint
 
162
ut_dulint_align_up(
 
163
/*===============*/
 
164
        dulint   n,             /*!< in: number to be rounded */
 
165
        ulint    align_no);     /*!< in: align by this number which must be a
 
166
                                power of 2 */
 
167
/********************************************************//**
 
168
Rounds a dulint downward to a multiple of a power of 2.
 
169
@return rounded value */
 
170
UNIV_INLINE
 
171
ib_uint64_t
 
172
ut_uint64_align_down(
 
173
/*=================*/
 
174
        ib_uint64_t      n,             /*!< in: number to be rounded */
 
175
        ulint            align_no);     /*!< in: align by this number
 
176
                                        which must be a power of 2 */
 
177
/********************************************************//**
 
178
Rounds ib_uint64_t upward to a multiple of a power of 2.
 
179
@return rounded value */
 
180
UNIV_INLINE
 
181
ib_uint64_t
 
182
ut_uint64_align_up(
 
183
/*===============*/
 
184
        ib_uint64_t      n,             /*!< in: number to be rounded */
 
185
        ulint            align_no);     /*!< in: align by this number
 
186
                                        which must be a power of 2 */
 
187
/*******************************************************//**
 
188
Increments a dulint variable by 1. */
 
189
#define UT_DULINT_INC(D)\
 
190
{\
 
191
        if ((D).low == 0xFFFFFFFFUL) {\
 
192
                (D).high = (D).high + 1;\
 
193
                (D).low = 0;\
 
194
        } else {\
 
195
                (D).low = (D).low + 1;\
 
196
        }\
 
197
}
 
198
/*******************************************************//**
 
199
Tests if two dulints are equal. */
 
200
#define UT_DULINT_EQ(D1, D2)    (((D1).low == (D2).low)\
 
201
                                                && ((D1).high == (D2).high))
 
202
#ifdef notdefined
 
203
/************************************************************//**
 
204
Sort function for dulint arrays. */
 
205
UNIV_INTERN
 
206
void
 
207
ut_dulint_sort(
 
208
/*===========*/
 
209
        dulint* arr,    /*!< in/out: array to be sorted */
 
210
        dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */
 
211
        ulint   low,    /*!< in: low bound of sort interval, inclusive */
 
212
        ulint   high);  /*!< in: high bound of sort interval, noninclusive */
 
213
#endif /* notdefined */
 
214
 
 
215
/*********************************************************//**
 
216
The following function rounds up a pointer to the nearest aligned address.
 
217
@return aligned pointer */
 
218
UNIV_INLINE
 
219
void*
 
220
ut_align(
 
221
/*=====*/
 
222
        const void*     ptr,            /*!< in: pointer */
 
223
        ulint           align_no);      /*!< in: align by this number */
 
224
/*********************************************************//**
 
225
The following function rounds down a pointer to the nearest
 
226
aligned address.
 
227
@return aligned pointer */
 
228
UNIV_INLINE
 
229
void*
 
230
ut_align_down(
 
231
/*==========*/
 
232
        const void*     ptr,            /*!< in: pointer */
 
233
        ulint           align_no)       /*!< in: align by this number */
 
234
                __attribute__((const));
 
235
/*********************************************************//**
 
236
The following function computes the offset of a pointer from the nearest
 
237
aligned address.
 
238
@return distance from aligned pointer */
 
239
UNIV_INLINE
 
240
ulint
 
241
ut_align_offset(
 
242
/*============*/
 
243
        const void*     ptr,            /*!< in: pointer */
 
244
        ulint           align_no)       /*!< in: align by this number */
 
245
                        __attribute__((const));
 
246
/*****************************************************************//**
 
247
Gets the nth bit of a ulint.
 
248
@return TRUE if nth bit is 1; 0th bit is defined to be the least significant */
 
249
UNIV_INLINE
 
250
ibool
 
251
ut_bit_get_nth(
 
252
/*===========*/
 
253
        ulint   a,      /*!< in: ulint */
 
254
        ulint   n);     /*!< in: nth bit requested */
 
255
/*****************************************************************//**
 
256
Sets the nth bit of a ulint.
 
257
@return the ulint with the bit set as requested */
 
258
UNIV_INLINE
 
259
ulint
 
260
ut_bit_set_nth(
 
261
/*===========*/
 
262
        ulint   a,      /*!< in: ulint */
 
263
        ulint   n,      /*!< in: nth bit requested */
 
264
        ibool   val);   /*!< in: value for the bit to set */
 
265
 
 
266
#ifndef UNIV_NONINL
 
267
#include "ut0byte.ic"
 
268
#endif
 
269
 
 
270
#endif