← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to include/my_bit.h

  • Committer: Monty Taylor
  • Date: 2008-07-01 14:33:36 UTC
  • mto: (28.1.12 backport_patch)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: monty@inaugust.com-20080701143336-8uihm7dhpu92rt0q
Somehow missed moving password.c. Duh.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/my_bit.h
2
2
  Some useful bit functions
3
3
*/
4
4
 
5
 
#ifdef __cplusplus
6
 
extern "C" {
7
 
#endif
 
5
C_MODE_START
 
6
#ifdef HAVE_INLINE
8
7
 
9
8
extern const char _my_bits_nbits[256];
10
 
extern const unsigned char _my_bits_reverse_table[256];
 
9
extern const uchar _my_bits_reverse_table[256];
11
10
 
12
11
/*
13
12
  Find smallest X in 2^X >= value
14
13
  This can be used to divide a number with value by doing a shift instead
15
14
*/
16
15
 
17
 
static inline uint32_t my_bit_log2(uint32_t value)
 
16
STATIC_INLINE uint my_bit_log2(ulong value)
18
17
{
19
 
  uint32_t bit;
 
18
  uint bit;
20
19
  for (bit=0 ; value > 1 ; value>>=1, bit++) ;
21
20
  return bit;
22
21
}
23
22
 
24
 
static inline uint32_t my_count_bits(uint64_t v)
 
23
STATIC_INLINE uint my_count_bits(ulonglong v)
25
24
{
 
25
#if SIZEOF_LONG_LONG > 4
26
26
  /* The following code is a bit faster on 16 bit machines than if we would
27
27
     only shift v */
28
 
  uint32_t v2=(uint32_t) (v >> 32);
29
 
  return (uint) (unsigned char) (_my_bits_nbits[(unsigned char)  v] +
30
 
                         _my_bits_nbits[(unsigned char) (v >> 8)] +
31
 
                         _my_bits_nbits[(unsigned char) (v >> 16)] +
32
 
                         _my_bits_nbits[(unsigned char) (v >> 24)] +
33
 
                         _my_bits_nbits[(unsigned char) (v2)] +
34
 
                         _my_bits_nbits[(unsigned char) (v2 >> 8)] +
35
 
                         _my_bits_nbits[(unsigned char) (v2 >> 16)] +
36
 
                         _my_bits_nbits[(unsigned char) (v2 >> 24)]);
 
28
  ulong v2=(ulong) (v >> 32);
 
29
  return (uint) (uchar) (_my_bits_nbits[(uchar)  v] +
 
30
                         _my_bits_nbits[(uchar) (v >> 8)] +
 
31
                         _my_bits_nbits[(uchar) (v >> 16)] +
 
32
                         _my_bits_nbits[(uchar) (v >> 24)] +
 
33
                         _my_bits_nbits[(uchar) (v2)] +
 
34
                         _my_bits_nbits[(uchar) (v2 >> 8)] +
 
35
                         _my_bits_nbits[(uchar) (v2 >> 16)] +
 
36
                         _my_bits_nbits[(uchar) (v2 >> 24)]);
 
37
#else
 
38
  return (uint) (uchar) (_my_bits_nbits[(uchar)  v] +
 
39
                         _my_bits_nbits[(uchar) (v >> 8)] +
 
40
                         _my_bits_nbits[(uchar) (v >> 16)] +
 
41
                         _my_bits_nbits[(uchar) (v >> 24)]);
 
42
#endif
37
43
}
38
44
 
39
 
static inline uint32_t my_count_bits_uint16(uint16_t v)
 
45
STATIC_INLINE uint my_count_bits_ushort(ushort v)
40
46
{
41
47
  return _my_bits_nbits[v];
42
48
}
61
67
    Comments shows how this works with 01100000000000000000000000001011
62
68
*/
63
69
 
64
 
static inline uint32_t my_round_up_to_next_power(uint32_t v)
 
70
STATIC_INLINE uint32 my_round_up_to_next_power(uint32 v)
65
71
{
66
72
  v--;                  /* 01100000000000000000000000001010 */
67
73
  v|= v >> 1;           /* 01110000000000000000000000001111 */
72
78
  return v+1;           /* 10000000000000000000000000000000 */
73
79
}
74
80
 
75
 
static inline uint32_t my_clear_highest_bit(uint32_t v)
 
81
STATIC_INLINE uint32 my_clear_highest_bit(uint32 v)
76
82
{
77
 
  uint32_t w=v >> 1;
 
83
  uint32 w=v >> 1;
78
84
  w|= w >> 1;
79
85
  w|= w >> 2;
80
86
  w|= w >> 4;
83
89
  return v & w;
84
90
}
85
91
 
86
 
static inline uint32_t my_reverse_bits(uint32_t key)
 
92
STATIC_INLINE uint32 my_reverse_bits(uint32 key)
87
93
{
88
94
  return
89
95
    (_my_bits_reverse_table[ key      & 255] << 24) |
92
98
     _my_bits_reverse_table[(key>>24)      ];
93
99
}
94
100
 
95
 
#ifdef __cplusplus
96
 
}
97
 
#endif
98
 
 
 
101
#else  /* HAVE_INLINE */
 
102
extern uint my_bit_log2(ulong value);
 
103
extern uint32 my_round_up_to_next_power(uint32 v);
 
104
uint32 my_clear_highest_bit(uint32 v);
 
105
uint32 my_reverse_bits(uint32 key);
 
106
extern uint my_count_bits(ulonglong v);
 
107
extern uint my_count_bits_ushort(ushort v);
 
108
#endif /* HAVE_INLINE */
 
109
C_MODE_END