← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_handler.c

  • Committer: Monty Taylor
  • Date: 2008-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_handler.c
15
15
   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16
16
   MA 02111-1307, USA */
17
17
 
18
 
#include <my_global.h>
19
 
#include <m_ctype.h>
20
 
#include <my_base.h>
 
18
#include "mysys_priv.h"
 
19
 
 
20
#include <mystrings/m_ctype.h>
 
21
#include <drizzled/base.h>
21
22
#include <my_handler.h>
22
23
#include <my_sys.h>
23
24
 
24
 
#include "mysys_priv.h"
25
25
#include "my_handler_errors.h"
26
26
 
27
 
int ha_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
28
 
                    uchar *b, uint b_length, bool part_key,
 
27
/**
 
28
  Swap the contents of two variables.
 
29
 */
 
30
#define swap_variables(TYPE, a, b) \
 
31
  do {                             \
 
32
    TYPE dummy;                    \
 
33
    dummy= a;                      \
 
34
    a= b;                          \
 
35
    b= dummy;                      \
 
36
  } while (0)
 
37
 
 
38
#define CMP_NUM(a,b) (((a) < (b)) ? -1 : ((a) == (b)) ? 0 : 1)
 
39
 
 
40
 
 
41
int ha_compare_text(const CHARSET_INFO * const charset_info, unsigned char *a, uint32_t a_length,
 
42
                    unsigned char *b, uint32_t b_length, bool part_key,
29
43
                    bool skip_end_space)
30
44
{
31
45
  if (!part_key)
36
50
}
37
51
 
38
52
 
39
 
static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
 
53
static int compare_bin(unsigned char *a, uint32_t a_length, unsigned char *b, uint32_t b_length,
40
54
                       bool part_key, bool skip_end_space)
41
55
{
42
 
  uint length= min(a_length,b_length);
43
 
  uchar *end= a+ length;
 
56
  uint32_t length= cmin(a_length,b_length);
 
57
  unsigned char *end= a+ length;
44
58
  int flag;
45
59
 
46
60
  while (a < end)
119
133
 
120
134
#define FCMP(A,B) ((int) (A) - (int) (B))
121
135
 
122
 
int ha_key_cmp(register HA_KEYSEG *keyseg, register uchar *a,
123
 
               register uchar *b, uint key_length, uint nextflag,
124
 
               uint *diff_pos)
 
136
int ha_key_cmp(register HA_KEYSEG *keyseg, register unsigned char *a,
 
137
               register unsigned char *b, uint32_t key_length, uint32_t nextflag,
 
138
               uint32_t *diff_pos)
125
139
{
126
140
  int flag;
127
 
  int16 s_1,s_2;
128
 
  int32 l_1,l_2;
129
 
  uint32 u_1,u_2;
 
141
  int16_t s_1,s_2;
 
142
  int32_t l_1,l_2;
 
143
  uint32_t u_1,u_2;
130
144
  float f_1,f_2;
131
145
  double d_1,d_2;
132
 
  uint next_key_length;
133
 
  uchar *orig_b= b;
 
146
  uint32_t next_key_length;
 
147
  unsigned char *orig_b= b;
134
148
 
135
149
  *diff_pos=0;
136
150
  for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
137
151
  {
138
 
    uchar *end;
139
 
    uint piks=! (keyseg->flag & HA_NO_SORT);
 
152
    unsigned char *end;
 
153
    uint32_t piks=! (keyseg->flag & HA_NO_SORT);
140
154
    (*diff_pos)++;
141
155
    diff_pos[1]= (uint)(b - orig_b);
142
156
 
167
181
        continue;                               /* To next key part */
168
182
      }
169
183
    }
170
 
    end= a+ min(keyseg->length,key_length);
 
184
    end= a+ cmin(keyseg->length,key_length);
171
185
    next_key_length=key_length-keyseg->length;
172
186
 
173
187
    switch ((enum ha_base_keytype) keyseg->type) {
191
205
      }
192
206
      else
193
207
      {
194
 
        uint length=(uint) (end-a), a_length=length, b_length=length;
 
208
        uint32_t length=(uint) (end-a), a_length=length, b_length=length;
195
209
        if (piks &&
196
210
            (flag= ha_compare_text(keyseg->charset, a, a_length, b, b_length,
197
211
                                   (bool) ((nextflag & SEARCH_PREFIX) &&
222
236
      }
223
237
      else
224
238
      {
225
 
        uint length=keyseg->length;
 
239
        uint32_t length=keyseg->length;
226
240
        if (piks &&
227
241
            (flag=compare_bin(a,length,b,length,
228
242
                              (bool) ((nextflag & SEARCH_PREFIX) &&
293
307
      break;
294
308
    case HA_KEYTYPE_USHORT_INT:
295
309
      {
296
 
        uint16 us_1,us_2;
 
310
        uint16_t us_1,us_2;
297
311
        us_1= mi_sint2korr(a);
298
312
        us_2= mi_sint2korr(b);
299
313
        if (piks && (flag = CMP_NUM(us_1,us_2)))
367
381
 
368
382
      if (keyseg->flag & HA_REVERSE_SORT)
369
383
      {
370
 
        swap_variables(uchar*, a, b);
 
384
        swap_variables(unsigned char*, a, b);
371
385
        swap_flag=1;                            /* Remember swap of a & b */
372
386
        end= a+ (int) (end-b);
373
387
      }
392
406
          if (*b != '-')
393
407
            return -1;
394
408
          a++; b++;
395
 
          swap_variables(uchar*, a, b);
 
409
          swap_variables(unsigned char*, a, b);
396
410
          swap_variables(int, alength, blength);
397
411
          swap_flag=1-swap_flag;
398
412
          alength--; blength--;
421
435
      }
422
436
 
423
437
      if (swap_flag)                            /* Restore pointers */
424
 
        swap_variables(uchar*, a, b);
 
438
        swap_variables(unsigned char*, a, b);
425
439
      break;
426
440
    }
427
441
    case HA_KEYTYPE_LONGLONG:
454
468
end:
455
469
  if (!(nextflag & SEARCH_FIND))
456
470
  {
457
 
    uint i;
 
471
    uint32_t i;
458
472
    if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
459
473
      return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
460
474
    flag=0;
497
511
    NULLs.
498
512
*/
499
513
 
500
 
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, uchar *a)
 
514
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, unsigned char *a)
501
515
{
502
516
  for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
503
517
  {
504
 
    uchar *end;
 
518
    unsigned char *end;
505
519
    if (keyseg->null_bit)
506
520
    {
507
521
      if (!*a++)
556
570
      break;
557
571
    case HA_KEYTYPE_END:                        /* purecov: inspected */
558
572
      /* keep compiler happy */
559
 
      DBUG_ASSERT(0);
 
573
      assert(0);
560
574
      break;
561
575
    }
562
576
  }
581
595
    that every HA_ERR_xxx constant has a corresponding error message in
582
596
    handler_error_messages[] list (check mysys/ma_handler_errors.h and
583
597
    include/my_base.h).
 
598
 
 
599
    TODO: Remove fix the handler_error_messages so that this hack isn't 
 
600
          necessary.
584
601
  */
585
 
  compile_time_assert(HA_ERR_FIRST + array_elements(handler_error_messages) ==
586
 
                      HA_ERR_LAST + 1);
 
602
#ifdef __GNUC__
 
603
  char compile_time_assert[(HA_ERR_FIRST +
 
604
                            array_elements(handler_error_messages) ==
 
605
                            HA_ERR_LAST + 1) ? 1 : -1]
 
606
      __attribute__ ((__unused__));
 
607
#endif
587
608
  my_error_register(handler_error_messages, HA_ERR_FIRST,
588
609
                    HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
589
610
}