← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/ut0byte.ic

  • Committer: Marisa Plumb
  • Date: 2010-12-04 02:38:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1984.
  • Revision ID: marisa.plumb@gmail.com-20101204023829-2khzxh30wxi256db
updates to a few sql docs 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/ut0byte.ic
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1994, 2009, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
24
24
*******************************************************************/
25
25
 
26
26
/*******************************************************//**
27
 
Creates a 64-bit integer out of two 32-bit integers.
 
27
Creates a 64-bit dulint out of two ulints.
28
28
@return created dulint */
29
29
UNIV_INLINE
30
 
ib_uint64_t
31
 
ut_ull_create(
32
 
/*==========*/
 
30
dulint
 
31
ut_dulint_create(
 
32
/*=============*/
33
33
        ulint   high,   /*!< in: high-order 32 bits */
34
34
        ulint   low)    /*!< in: low-order 32 bits */
35
35
{
36
 
        ut_ad(high <= ULINT32_MASK);
37
 
        ut_ad(low <= ULINT32_MASK);
38
 
        return(((ib_uint64_t) high) << 32 | low);
39
 
}
40
 
 
41
 
/********************************************************//**
42
 
Rounds a 64-bit integer downward to a multiple of a power of 2.
 
36
        dulint  res;
 
37
 
 
38
        ut_ad(high <= 0xFFFFFFFF);
 
39
        ut_ad(low <= 0xFFFFFFFF);
 
40
 
 
41
        res.high = high;
 
42
        res.low  = low;
 
43
 
 
44
        return(res);
 
45
}
 
46
 
 
47
/*******************************************************//**
 
48
Gets the high-order 32 bits of a dulint.
 
49
@return 32 bits in ulint */
 
50
UNIV_INLINE
 
51
ulint
 
52
ut_dulint_get_high(
 
53
/*===============*/
 
54
        dulint  d)      /*!< in: dulint */
 
55
{
 
56
        return(d.high);
 
57
}
 
58
 
 
59
/*******************************************************//**
 
60
Gets the low-order 32 bits of a dulint.
 
61
@return 32 bits in ulint */
 
62
UNIV_INLINE
 
63
ulint
 
64
ut_dulint_get_low(
 
65
/*==============*/
 
66
        dulint  d)      /*!< in: dulint */
 
67
{
 
68
        return(d.low);
 
69
}
 
70
 
 
71
/*******************************************************//**
 
72
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
 
73
integer type.
 
74
@return value in ib_int64_t type */
 
75
UNIV_INLINE
 
76
ib_int64_t
 
77
ut_conv_dulint_to_longlong(
 
78
/*=======================*/
 
79
        dulint  d)      /*!< in: dulint */
 
80
{
 
81
        return((ib_int64_t)d.low
 
82
               + (((ib_int64_t)d.high) << 32));
 
83
}
 
84
 
 
85
/*******************************************************//**
 
86
Tests if a dulint is zero.
 
87
@return TRUE if zero */
 
88
UNIV_INLINE
 
89
ibool
 
90
ut_dulint_is_zero(
 
91
/*==============*/
 
92
        dulint  a)      /*!< in: dulint */
 
93
{
 
94
        if ((a.low == 0) && (a.high == 0)) {
 
95
 
 
96
                return(TRUE);
 
97
        }
 
98
 
 
99
        return(FALSE);
 
100
}
 
101
 
 
102
/*******************************************************//**
 
103
Compares two dulints.
 
104
@return -1 if a < b, 0 if a == b, 1 if a > b */
 
105
UNIV_INLINE
 
106
int
 
107
ut_dulint_cmp(
 
108
/*==========*/
 
109
        dulint  a,      /*!< in: dulint */
 
110
        dulint  b)      /*!< in: dulint */
 
111
{
 
112
        if (a.high > b.high) {
 
113
                return(1);
 
114
        } else if (a.high < b.high) {
 
115
                return(-1);
 
116
        } else if (a.low > b.low) {
 
117
                return(1);
 
118
        } else if (a.low < b.low) {
 
119
                return(-1);
 
120
        } else {
 
121
                return(0);
 
122
        }
 
123
}
 
124
 
 
125
/*******************************************************//**
 
126
Calculates the max of two dulints.
 
127
@return max(a, b) */
 
128
UNIV_INLINE
 
129
dulint
 
130
ut_dulint_get_max(
 
131
/*==============*/
 
132
        dulint  a,      /*!< in: dulint */
 
133
        dulint  b)      /*!< in: dulint */
 
134
{
 
135
        if (ut_dulint_cmp(a, b) > 0) {
 
136
 
 
137
                return(a);
 
138
        }
 
139
 
 
140
        return(b);
 
141
}
 
142
 
 
143
/*******************************************************//**
 
144
Calculates the min of two dulints.
 
145
@return min(a, b) */
 
146
UNIV_INLINE
 
147
dulint
 
148
ut_dulint_get_min(
 
149
/*==============*/
 
150
        dulint  a,      /*!< in: dulint */
 
151
        dulint  b)      /*!< in: dulint */
 
152
{
 
153
        if (ut_dulint_cmp(a, b) > 0) {
 
154
 
 
155
                return(b);
 
156
        }
 
157
 
 
158
        return(a);
 
159
}
 
160
 
 
161
/*******************************************************//**
 
162
Adds a ulint to a dulint.
 
163
@return sum a + b */
 
164
UNIV_INLINE
 
165
dulint
 
166
ut_dulint_add(
 
167
/*==========*/
 
168
        dulint  a,      /*!< in: dulint */
 
169
        ulint   b)      /*!< in: ulint */
 
170
{
 
171
        if (0xFFFFFFFFUL - b >= a.low) {
 
172
                a.low += b;
 
173
 
 
174
                return(a);
 
175
        }
 
176
 
 
177
        a.low = a.low - (0xFFFFFFFFUL - b) - 1;
 
178
 
 
179
        a.high++;
 
180
 
 
181
        return(a);
 
182
}
 
183
 
 
184
/*******************************************************//**
 
185
Subtracts a ulint from a dulint.
 
186
@return a - b */
 
187
UNIV_INLINE
 
188
dulint
 
189
ut_dulint_subtract(
 
190
/*===============*/
 
191
        dulint  a,      /*!< in: dulint */
 
192
        ulint   b)      /*!< in: ulint, b <= a */
 
193
{
 
194
        if (a.low >= b) {
 
195
                a.low -= b;
 
196
 
 
197
                return(a);
 
198
        }
 
199
 
 
200
        b -= a.low + 1;
 
201
 
 
202
        a.low = 0xFFFFFFFFUL - b;
 
203
 
 
204
        ut_ad(a.high > 0);
 
205
 
 
206
        a.high--;
 
207
 
 
208
        return(a);
 
209
}
 
210
 
 
211
/*******************************************************//**
 
212
Subtracts a dulint from another. NOTE that the difference must be positive
 
213
and smaller that 4G.
 
214
@return a - b */
 
215
UNIV_INLINE
 
216
ulint
 
217
ut_dulint_minus(
 
218
/*============*/
 
219
        dulint  a,      /*!< in: dulint; NOTE a must be >= b and at most
 
220
                        2 to power 32 - 1 greater */
 
221
        dulint  b)      /*!< in: dulint */
 
222
{
 
223
        ulint   diff;
 
224
 
 
225
        if (a.high == b.high) {
 
226
                ut_ad(a.low >= b.low);
 
227
 
 
228
                return(a.low - b.low);
 
229
        }
 
230
 
 
231
        ut_ad(a.high == b.high + 1);
 
232
 
 
233
        diff = (ulint)(0xFFFFFFFFUL - b.low);
 
234
        diff += 1 + a.low;
 
235
 
 
236
        ut_ad(diff > a.low);
 
237
 
 
238
        return(diff);
 
239
}
 
240
 
 
241
/********************************************************//**
 
242
Rounds a dulint downward to a multiple of a power of 2.
 
243
@return rounded value */
 
244
UNIV_INLINE
 
245
dulint
 
246
ut_dulint_align_down(
 
247
/*=================*/
 
248
        dulint   n,             /*!< in: number to be rounded */
 
249
        ulint    align_no)      /*!< in: align by this number which must be a
 
250
                                power of 2 */
 
251
{
 
252
        ulint   low, high;
 
253
 
 
254
        ut_ad(align_no > 0);
 
255
        ut_ad(((align_no - 1) & align_no) == 0);
 
256
 
 
257
        low = ut_dulint_get_low(n);
 
258
        high = ut_dulint_get_high(n);
 
259
 
 
260
        low = low & ~(align_no - 1);
 
261
 
 
262
        return(ut_dulint_create(high, low));
 
263
}
 
264
 
 
265
/********************************************************//**
 
266
Rounds a dulint upward to a multiple of a power of 2.
 
267
@return rounded value */
 
268
UNIV_INLINE
 
269
dulint
 
270
ut_dulint_align_up(
 
271
/*===============*/
 
272
        dulint   n,             /*!< in: number to be rounded */
 
273
        ulint    align_no)      /*!< in: align by this number which must be a
 
274
                                power of 2 */
 
275
{
 
276
        return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no));
 
277
}
 
278
 
 
279
/********************************************************//**
 
280
Rounds ib_uint64_t downward to a multiple of a power of 2.
43
281
@return rounded value */
44
282
UNIV_INLINE
45
283
ib_uint64_t