← 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: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ut0byte.h
24
24
};
25
25
 
26
26
/* Zero value for a dulint */
27
 
extern dulint   ut_dulint_zero;
 
27
extern const dulint     ut_dulint_zero;
28
28
 
29
29
/* Maximum value for a dulint */
30
 
extern dulint   ut_dulint_max;
 
30
extern const dulint     ut_dulint_max;
31
31
 
32
32
/***********************************************************
33
33
Creates a 64-bit dulint out of two ulints. */
55
55
                        /* out: 32 bits in ulint */
56
56
        dulint  d);     /* in: dulint */
57
57
/***********************************************************
58
 
Converts a dulint (a struct of 2 ulints) to ib_longlong, which is a 64-bit
 
58
Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
59
59
integer type. */
60
60
UNIV_INLINE
61
 
ib_longlong
 
61
ib_int64_t
62
62
ut_conv_dulint_to_longlong(
63
63
/*=======================*/
64
 
                        /* out: value in ib_longlong type */
 
64
                        /* out: value in ib_int64_t type */
65
65
        dulint  d);     /* in: dulint */
66
66
/***********************************************************
67
67
Tests if a dulint is zero. */
148
148
        dulint   n,             /* in: number to be rounded */
149
149
        ulint    align_no);     /* in: align by this number which must be a
150
150
                                power of 2 */
 
151
/************************************************************
 
152
Rounds a dulint downward to a multiple of a power of 2. */
 
153
UNIV_INLINE
 
154
ib_uint64_t
 
155
ut_uint64_align_down(
 
156
/*=================*/
 
157
                                        /* out: rounded value */
 
158
        ib_uint64_t      n,             /* in: number to be rounded */
 
159
        ulint            align_no);     /* in: align by this number
 
160
                                        which must be a power of 2 */
 
161
/************************************************************
 
162
Rounds ib_uint64_t upward to a multiple of a power of 2. */
 
163
UNIV_INLINE
 
164
ib_uint64_t
 
165
ut_uint64_align_up(
 
166
/*===============*/
 
167
                                        /* out: rounded value */
 
168
        ib_uint64_t      n,             /* in: number to be rounded */
 
169
        ulint            align_no);     /* in: align by this number
 
170
                                        which must be a power of 2 */
151
171
/***********************************************************
152
172
Increments a dulint variable by 1. */
153
173
#define UT_DULINT_INC(D)\
163
183
Tests if two dulints are equal. */
164
184
#define UT_DULINT_EQ(D1, D2)    (((D1).low == (D2).low)\
165
185
                                                && ((D1).high == (D2).high))
 
186
#ifdef notdefined
166
187
/****************************************************************
167
188
Sort function for dulint arrays. */
 
189
UNIV_INTERN
168
190
void
169
191
ut_dulint_sort(dulint* arr, dulint* aux_arr, ulint low, ulint high);
170
192
/*===============================================================*/
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
#endif /* notdefined */
 
194
 
193
195
/*************************************************************
194
196
The following function rounds up a pointer to the nearest aligned address. */
195
197
UNIV_INLINE
197
199
ut_align(
198
200
/*=====*/
199
201
                                /* out: aligned pointer */
200
 
        const void*     ptr,            /* in: pointer */
 
202
        void*   ptr,            /* in: pointer */
201
203
        ulint   align_no);      /* in: align by this number */
202
204
/*************************************************************
203
205
The following function rounds down a pointer to the nearest
206
208
void*
207
209
ut_align_down(
208
210
/*==========*/
209
 
                                /* out: aligned pointer */
 
211
                                        /* out: aligned pointer */
210
212
        const void*     ptr,            /* in: pointer */
211
 
        ulint   align_no)       /* in: align by this number */
 
213
        ulint           align_no)       /* in: align by this number */
212
214
                __attribute__((const));
213
215
/*************************************************************
214
216
The following function computes the offset of a pointer from the nearest