← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/ut0ut.ic

  • Committer: Monty Taylor
  • Date: 2009-08-12 06:25:19 UTC
  • mto: (1114.1.1 innodb-plugin-merge)
  • mto: This revision was merged to the branch mainline in revision 1183.
  • Revision ID: mordred@inaugust.com-20090812062519-cij02mrrunvnxblt
Tags: innodb-plugin-1.0.4
InnoDB Plugin 1.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ut0ut.ic
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/******************************************************************
 
19
/**************************************************************//**
 
20
@file include/ut0ut.ic
20
21
Various utilities
21
22
 
22
23
Created 5/30/1994 Heikki Tuuri
23
24
*******************************************************************/
24
25
 
25
 
/**********************************************************
26
 
Calculates the minimum of two ulints. */
 
26
/******************************************************//**
 
27
Calculates the minimum of two ulints.
 
28
@return minimum */
27
29
UNIV_INLINE
28
30
ulint
29
31
ut_min(
30
32
/*===*/
31
 
                        /* out: minimum */
32
 
        ulint    n1,    /* in: first number */
33
 
        ulint    n2)    /* in: second number */
 
33
        ulint    n1,    /*!< in: first number */
 
34
        ulint    n2)    /*!< in: second number */
34
35
{
35
36
        return((n1 <= n2) ? n1 : n2);
36
37
}
37
38
 
38
 
/**********************************************************
39
 
Calculates the maximum of two ulints. */
 
39
/******************************************************//**
 
40
Calculates the maximum of two ulints.
 
41
@return maximum */
40
42
UNIV_INLINE
41
43
ulint
42
44
ut_max(
43
45
/*===*/
44
 
                        /* out: maximum */
45
 
        ulint    n1,    /* in: first number */
46
 
        ulint    n2)    /* in: second number */
 
46
        ulint    n1,    /*!< in: first number */
 
47
        ulint    n2)    /*!< in: second number */
47
48
{
48
49
        return((n1 <= n2) ? n2 : n1);
49
50
}
50
51
 
51
 
/********************************************************************
 
52
/****************************************************************//**
52
53
Calculates minimum of two ulint-pairs. */
53
54
UNIV_INLINE
54
55
void
55
56
ut_pair_min(
56
57
/*========*/
57
 
        ulint*  a,      /* out: more significant part of minimum */
58
 
        ulint*  b,      /* out: less significant part of minimum */
59
 
        ulint   a1,     /* in: more significant part of first pair */
60
 
        ulint   b1,     /* in: less significant part of first pair */
61
 
        ulint   a2,     /* in: more significant part of second pair */
62
 
        ulint   b2)     /* in: less significant part of second pair */
 
58
        ulint*  a,      /*!< out: more significant part of minimum */
 
59
        ulint*  b,      /*!< out: less significant part of minimum */
 
60
        ulint   a1,     /*!< in: more significant part of first pair */
 
61
        ulint   b1,     /*!< in: less significant part of first pair */
 
62
        ulint   a2,     /*!< in: more significant part of second pair */
 
63
        ulint   b2)     /*!< in: less significant part of second pair */
63
64
{
64
65
        if (a1 == a2) {
65
66
                *a = a1;
73
74
        }
74
75
}
75
76
 
76
 
/**********************************************************
77
 
Compares two ulints. */
 
77
/******************************************************//**
 
78
Compares two ulints.
 
79
@return 1 if a > b, 0 if a == b, -1 if a < b */
78
80
UNIV_INLINE
79
81
int
80
82
ut_ulint_cmp(
81
83
/*=========*/
82
 
                        /* out: 1 if a > b, 0 if a == b, -1 if a < b */
83
 
        ulint   a,      /* in: ulint */
84
 
        ulint   b)      /* in: ulint */
 
84
        ulint   a,      /*!< in: ulint */
 
85
        ulint   b)      /*!< in: ulint */
85
86
{
86
87
        if (a < b) {
87
88
                return(-1);
92
93
        }
93
94
}
94
95
 
95
 
/***********************************************************
96
 
Compares two pairs of ulints. */
 
96
/*******************************************************//**
 
97
Compares two pairs of ulints.
 
98
@return -1 if a < b, 0 if a == b, 1 if a > b */
97
99
UNIV_INLINE
98
100
int
99
101
ut_pair_cmp(
100
102
/*========*/
101
 
                        /* out: -1 if a < b, 0 if a == b, 1 if a > b */
102
 
        ulint   a1,     /* in: more significant part of first pair */
103
 
        ulint   a2,     /* in: less significant part of first pair */
104
 
        ulint   b1,     /* in: more significant part of second pair */
105
 
        ulint   b2)     /* in: less significant part of second pair */
 
103
        ulint   a1,     /*!< in: more significant part of first pair */
 
104
        ulint   a2,     /*!< in: less significant part of first pair */
 
105
        ulint   b1,     /*!< in: more significant part of second pair */
 
106
        ulint   b2)     /*!< in: less significant part of second pair */
106
107
{
107
108
        if (a1 > b1) {
108
109
                return(1);
117
118
        }
118
119
}
119
120
 
120
 
/*****************************************************************
 
121
/*************************************************************//**
121
122
Calculates fast the 2-logarithm of a number, rounded upward to an
122
 
integer. */
 
123
integer.
 
124
@return logarithm in the base 2, rounded upward */
123
125
UNIV_INLINE
124
126
ulint
125
127
ut_2_log(
126
128
/*=====*/
127
 
                        /* out: logarithm in the base 2, rounded upward */
128
 
        ulint   n)      /* in: number != 0 */
 
129
        ulint   n)      /*!< in: number != 0 */
129
130
{
130
131
        ulint   res;
131
132
 
148
149
        return(res + 1);
149
150
}
150
151
 
151
 
/*****************************************************************
152
 
Calculates 2 to power n. */
 
152
/*************************************************************//**
 
153
Calculates 2 to power n.
 
154
@return 2 to power n */
153
155
UNIV_INLINE
154
156
ulint
155
157
ut_2_exp(
156
158
/*=====*/
157
 
                        /* out: 2 to power n */
158
 
        ulint   n)      /* in: number */
 
159
        ulint   n)      /*!< in: number */
159
160
{
160
161
        return((ulint) 1 << n);
161
162
}