← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/ptr_cmp.cc

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/ptr_cmp.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
16
/*
17
17
  get_ptr_compare(len) returns a pointer to a optimal byte-compare function
19
19
  The bytes are compare as unsigned chars.
20
20
  */
21
21
 
22
 
#include "mysys_priv.h"
23
 
#include <storage/myisam/myisampack.h>
24
 
 
25
 
static int ptr_compare(size_t *compare_length, uchar **a, uchar **b);
26
 
static int ptr_compare_0(size_t *compare_length, uchar **a, uchar **b);
27
 
static int ptr_compare_1(size_t *compare_length, uchar **a, uchar **b);
28
 
static int ptr_compare_2(size_t *compare_length, uchar **a, uchar **b);
29
 
static int ptr_compare_3(size_t *compare_length, uchar **a, uchar **b);
 
22
#include "config.h"
 
23
#include "drizzled/internal/my_sys.h"
 
24
 
 
25
#include <assert.h>
 
26
 
 
27
#include "plugin/myisam/myisampack.h"
 
28
 
 
29
namespace drizzled
 
30
{
 
31
namespace internal
 
32
{
 
33
 
 
34
static int ptr_compare(size_t *compare_length, unsigned char **a, unsigned char **b);
 
35
static int ptr_compare_0(size_t *compare_length, unsigned char **a, unsigned char **b);
 
36
static int ptr_compare_1(size_t *compare_length, unsigned char **a, unsigned char **b);
 
37
static int ptr_compare_2(size_t *compare_length, unsigned char **a, unsigned char **b);
 
38
static int ptr_compare_3(size_t *compare_length, unsigned char **a, unsigned char **b);
30
39
 
31
40
        /* Get a pointer to a optimal byte-compare function for a given size */
32
41
 
51
60
 
52
61
#define cmp(N) if (first[N] != last[N]) return (int) first[N] - (int) last[N]
53
62
 
54
 
static int ptr_compare(size_t *compare_length, uchar **a, uchar **b)
 
63
static int ptr_compare(size_t *compare_length, unsigned char **a, unsigned char **b)
55
64
{
56
65
  register int length= *compare_length;
57
 
  register uchar *first,*last;
 
66
  register unsigned char *first,*last;
58
67
 
59
68
  first= *a; last= *b;
60
69
  while (--length)
66
75
}
67
76
 
68
77
 
69
 
static int ptr_compare_0(size_t *compare_length,uchar **a, uchar **b)
 
78
static int ptr_compare_0(size_t *compare_length,unsigned char **a, unsigned char **b)
70
79
{
71
80
  register int length= *compare_length;
72
 
  register uchar *first,*last;
 
81
  register unsigned char *first,*last;
73
82
 
74
83
  first= *a; last= *b;
75
84
 loop:
87
96
}
88
97
 
89
98
 
90
 
static int ptr_compare_1(size_t *compare_length,uchar **a, uchar **b)
 
99
static int ptr_compare_1(size_t *compare_length,unsigned char **a, unsigned char **b)
91
100
{
92
101
  register int length= *compare_length-1;
93
 
  register uchar *first,*last;
 
102
  register unsigned char *first,*last;
94
103
 
95
104
  first= *a+1; last= *b+1;
96
105
  cmp(-1);
108
117
  return (0);
109
118
}
110
119
 
111
 
static int ptr_compare_2(size_t *compare_length,uchar **a, uchar **b)
 
120
static int ptr_compare_2(size_t *compare_length,unsigned char **a, unsigned char **b)
112
121
{
113
122
  register int length= *compare_length-2;
114
 
  register uchar *first,*last;
 
123
  register unsigned char *first,*last;
115
124
 
116
125
  first= *a +2 ; last= *b +2;
117
126
  cmp(-2);
130
139
  return (0);
131
140
}
132
141
 
133
 
static int ptr_compare_3(size_t *compare_length,uchar **a, uchar **b)
 
142
static int ptr_compare_3(size_t *compare_length,unsigned char **a, unsigned char **b)
134
143
{
135
144
  register int length= *compare_length-3;
136
 
  register uchar *first,*last;
 
145
  register unsigned char *first,*last;
137
146
 
138
147
  first= *a +3 ; last= *b +3;
139
148
  cmp(-3);
153
162
  return (0);
154
163
}
155
164
 
156
 
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos)
 
165
void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos)
157
166
{
158
167
  switch (pack_length) {
159
168
#if SIZEOF_OFF_T > 4
165
174
  case 4: mi_int4store(buff,pos); break;
166
175
  case 3: mi_int3store(buff,pos); break;
167
176
  case 2: mi_int2store(buff,pos); break;
168
 
  case 1: buff[0]= (uchar) pos; break;
 
177
  case 1: buff[0]= (unsigned char) pos; break;
169
178
  default: assert(0);
170
179
  }
171
180
  return;
172
181
}
173
182
 
174
 
my_off_t my_get_ptr(uchar *ptr, size_t pack_length)
 
183
my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length)
175
184
{
176
185
  my_off_t pos;
177
186
  switch (pack_length) {
184
193
  case 4: pos= (my_off_t) mi_uint4korr(ptr); break;
185
194
  case 3: pos= (my_off_t) mi_uint3korr(ptr); break;
186
195
  case 2: pos= (my_off_t) mi_uint2korr(ptr); break;
187
 
  case 1: pos= (my_off_t) *(uchar*) ptr; break;
 
196
  case 1: pos= (my_off_t) *(unsigned char*) ptr; break;
188
197
  default: assert(0); return 0;
189
198
  }
190
199
 return pos;
191
200
}
192
201
 
 
202
} /* namespace internal */
 
203
} /* namespace drizzled */