← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_search.c

  • Committer: Jim Winstead
  • Date: 2008-07-19 02:56:45 UTC
  • mto: (202.1.8 codestyle)
  • mto: This revision was merged to the branch mainline in revision 207.
  • Revision ID: jimw@mysql.com-20080719025645-w2pwytebgzusjzjb
Various fixes to enable compilation on Mac OS X, and remove the glib dependency.
Temporarily disables tab-completion in the drizzle client until an appropriate
autoconf check can be added/enabled.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_search.c
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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* key handling functions */
17
17
 
18
 
#include "myisam_priv.h"
19
 
#include <drizzled/charset_info.h>
20
 
#include <drizzled/internal/m_string.h>
21
 
#include <drizzled/util/test.h>
22
 
 
23
 
using namespace drizzled;
24
 
 
25
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
26
 
                                unsigned char *key, unsigned char *keypos,
27
 
                                uint32_t *return_key_length);
 
18
#include "myisamdef.h"
 
19
#include "m_ctype.h"
 
20
 
 
21
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
22
                                uchar *key, uchar *keypos,
 
23
                                uint *return_key_length);
28
24
 
29
25
        /* Check index */
30
26
 
34
30
    inx=info->lastinx;
35
31
  if (inx < 0 || ! mi_is_key_active(info->s->state.key_map, inx))
36
32
  {
37
 
    errno=HA_ERR_WRONG_INDEX;
 
33
    my_errno=HA_ERR_WRONG_INDEX;
38
34
    return -1;
39
35
  }
40
36
  if (info->lastinx != inx)             /* Index changed */
58
54
        */
59
55
 
60
56
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
61
 
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register internal::my_off_t pos)
 
57
               uchar *key, uint key_len, uint nextflag, register my_off_t pos)
62
58
{
63
 
  bool last_key;
 
59
  my_bool last_key;
64
60
  int error,flag;
65
 
  uint32_t nod_flag;
66
 
  unsigned char *keypos,*maxpos;
67
 
  unsigned char lastkey[MI_MAX_KEY_BUFF],*buff;
 
61
  uint nod_flag;
 
62
  uchar *keypos,*maxpos;
 
63
  uchar lastkey[MI_MAX_KEY_BUFF],*buff;
68
64
 
69
65
  if (pos == HA_OFFSET_ERROR)
70
66
  {
71
 
    errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
 
67
    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
72
68
    info->lastpos= HA_OFFSET_ERROR;
73
69
    if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
74
70
      return(-1);                          /* Not found ; return error */
109
105
    {
110
106
      if ((error=_mi_search(info,keyinfo,key,key_len,SEARCH_FIND,
111
107
                            _mi_kpos(nod_flag,keypos))) >= 0 ||
112
 
          errno != HA_ERR_KEY_NOT_FOUND)
 
108
          my_errno != HA_ERR_KEY_NOT_FOUND)
113
109
        return(error);
114
110
      info->last_keypage= HA_OFFSET_ERROR;              /* Buffer not in mem */
115
111
    }
116
112
  }
117
113
  if (pos != info->last_keypage)
118
114
  {
119
 
    unsigned char *old_buff=buff;
 
115
    uchar *old_buff=buff;
120
116
    if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,DFLT_INIT_HITS,info->buff,
121
117
                                 test(!(nextflag & SEARCH_SAVE_BUFF)))))
122
118
      goto err;
126
122
 
127
123
  if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
128
124
  {
129
 
    uint32_t not_used[2];
 
125
    uint not_used[2];
130
126
    if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
131
127
                         &info->lastkey_length))
132
128
      goto err;
134
130
        ha_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
135
131
                   not_used))
136
132
    {
137
 
      errno=HA_ERR_KEY_NOT_FOUND;                    /* Didn't find key */
 
133
      my_errno=HA_ERR_KEY_NOT_FOUND;                    /* Didn't find key */
138
134
      goto err;
139
135
    }
140
136
  }
169
165
        /* ret_pos point to where find or bigger key starts */
170
166
        /* ARGSUSED */
171
167
 
172
 
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
173
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
174
 
                   unsigned char *buff, bool *last_key)
 
168
int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
169
                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
 
170
                   uchar *buff __attribute__((unused)), my_bool *last_key)
175
171
{
176
 
  (void)buff;
177
172
  register int start,mid,end,save_end;
178
 
  int flag= 0;
179
 
  uint32_t totlength,nod_flag,not_used[2];
 
173
  int flag;
 
174
  uint totlength,nod_flag,not_used[2];
180
175
 
181
176
  totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
182
177
  start=0; mid=1;
230
225
    < 0         Not found.
231
226
*/
232
227
 
233
 
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
234
 
                   unsigned char *key, uint32_t key_len, uint32_t comp_flag, unsigned char **ret_pos,
235
 
                   unsigned char *buff, bool *last_key)
 
228
int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
229
                   uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
 
230
                   uchar *buff, my_bool *last_key)
236
231
{
237
 
  int flag= 0;
238
 
  uint32_t nod_flag,length=0,not_used[2];
239
 
  unsigned char t_buff[MI_MAX_KEY_BUFF],*end;
 
232
  int flag=0;
 
233
  uint nod_flag,length=0,not_used[2];
 
234
  uchar t_buff[MI_MAX_KEY_BUFF],*end;
240
235
 
241
236
  end= page+mi_getint(page);
242
237
  nod_flag=mi_test_if_nod(page);
249
244
    if (length == 0 || page > end)
250
245
    {
251
246
      mi_print_error(info->s, HA_ERR_CRASHED);
252
 
      errno=HA_ERR_CRASHED;
 
247
      my_errno=HA_ERR_CRASHED;
253
248
      return(MI_FOUND_WRONG_KEY);
254
249
    }
255
250
    if ((flag=ha_key_cmp(keyinfo->seg,t_buff,key,key_len,comp_flag,
265
260
} /* _mi_seq_search */
266
261
 
267
262
 
268
 
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *page,
269
 
                      unsigned char *key, uint32_t key_len, uint32_t nextflag, unsigned char **ret_pos,
270
 
                      unsigned char *buff, bool *last_key)
 
263
int _mi_prefix_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
 
264
                      uchar *key, uint key_len, uint nextflag, uchar **ret_pos,
 
265
                      uchar *buff, my_bool *last_key)
271
266
{
272
267
  /*
273
268
    my_flag is raw comparison result to be changed according to
275
270
    flag is the value returned by ha_key_cmp and as treated as final
276
271
  */
277
272
  int flag=0, my_flag=-1;
278
 
  uint32_t nod_flag, length=0, len, matched, cmplen, kseg_len;
279
 
  uint32_t prefix_len=0,suffix_len;
 
273
  uint nod_flag, length=0, len, matched, cmplen, kseg_len;
 
274
  uint prefix_len=0,suffix_len;
280
275
  int key_len_skip, seg_len_pack=0, key_len_left;
281
 
  unsigned char *end, *kseg, *vseg;
282
 
  unsigned char *sort_order=keyinfo->seg->charset->sort_order;
283
 
  unsigned char tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
284
 
  unsigned char *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
285
 
  uint32_t  saved_length=0, saved_prefix_len=0;
286
 
  uint32_t  length_pack;
 
276
  uchar *end, *kseg, *vseg;
 
277
  uchar *sort_order=keyinfo->seg->charset->sort_order;
 
278
  uchar tt_buff[MI_MAX_KEY_BUFF+2], *t_buff=tt_buff+2;
 
279
  uchar *saved_from=NULL, *saved_to=NULL, *saved_vseg=NULL;
 
280
  uint  saved_length=0, saved_prefix_len=0;
 
281
  uint  length_pack;
287
282
 
288
283
 
289
284
  t_buff[0]=0;                                  /* Avoid bugs */
317
312
 
318
313
  while (page < end)
319
314
  {
320
 
    uint32_t packed= *page & 128;
 
315
    uint packed= *page & 128;
321
316
 
322
317
    vseg=page;
323
318
    if (keyinfo->seg->length >= 127)
360
355
    saved_prefix_len=prefix_len;
361
356
 
362
357
    {
363
 
      unsigned char *from=vseg+suffix_len;
 
358
      uchar *from=vseg+suffix_len;
364
359
      HA_KEYSEG *keyseg;
365
 
      uint32_t l;
 
360
      uint l;
366
361
 
367
362
      for (keyseg=keyinfo->seg+1 ; keyseg->type ; keyseg++ )
368
363
      {
389
384
    if (page > end)
390
385
    {
391
386
      mi_print_error(info->s, HA_ERR_CRASHED);
392
 
      errno=HA_ERR_CRASHED;
 
387
      my_errno=HA_ERR_CRASHED;
393
388
      return(MI_FOUND_WRONG_KEY);
394
389
    }
395
390
 
396
391
    if (matched >= prefix_len)
397
392
    {
398
393
      /* We have to compare. But we can still skip part of the key */
399
 
      uint32_t  left;
400
 
      unsigned char *k=kseg+prefix_len;
 
394
      uint  left;
 
395
      uchar *k=kseg+prefix_len;
401
396
 
402
397
      /*
403
398
        If prefix_len > cmplen then we are in the end-space comparison
443
438
          else
444
439
          {
445
440
            /* We have to compare k and vseg as if they were space extended */
446
 
            unsigned char *k_end= k+ (cmplen - len);
 
441
            uchar *k_end= k+ (cmplen - len);
447
442
            for ( ; k < k_end && *k == ' '; k++) ;
448
443
            if (k == k_end)
449
444
              goto cmp_rest;            /* should never happen */
450
 
            if (*k < (unsigned char) ' ')
 
445
            if (*k < (uchar) ' ')
451
446
            {
452
447
              my_flag= 1;               /* Compared string is smaller */
453
448
              break;
457
452
        }
458
453
        else if (len > cmplen)
459
454
        {
460
 
          unsigned char *vseg_end;
 
455
          uchar *vseg_end;
461
456
          if ((nextflag & SEARCH_PREFIX) && key_len_left == 0)
462
457
            goto fix_flag;
463
458
 
464
459
          /* We have to compare k and vseg as if they were space extended */
465
460
          for (vseg_end= vseg + (len-cmplen) ;
466
 
               vseg < vseg_end && *vseg == (unsigned char) ' ';
 
461
               vseg < vseg_end && *vseg == (uchar) ' ';
467
462
               vseg++, matched++) ;
468
463
          assert(vseg < vseg_end);
469
464
 
470
 
          if (*vseg > (unsigned char) ' ')
 
465
          if (*vseg > (uchar) ' ')
471
466
          {
472
467
            my_flag= 1;                 /* Compared string is smaller */
473
468
            break;
479
474
      cmp_rest:
480
475
          if (key_len_left>0)
481
476
          {
482
 
            uint32_t not_used[2];
 
477
            uint not_used[2];
483
478
            if ((flag = ha_key_cmp(keyinfo->seg+1,vseg,
484
479
                                   k, key_len_left, nextflag, not_used)) >= 0)
485
480
              break;
529
524
 
530
525
        /* Get pos to a key_block */
531
526
 
532
 
internal::my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
 
527
my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
533
528
{
534
529
  after_key-=nod_flag;
535
530
  switch (nod_flag) {
549
544
    after_key++;
550
545
#endif
551
546
  case 4:
552
 
    return ((internal::my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
 
547
    return ((my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
553
548
  case 3:
554
 
    return ((internal::my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
 
549
    return ((my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
555
550
  case 2:
556
 
    return (internal::my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
 
551
    return (my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
557
552
  case 1:
558
553
    return (uint) (*after_key)*MI_MIN_KEY_BLOCK_LENGTH;
559
554
  case 0:                                       /* At leaf page */
565
560
 
566
561
        /* Save pos to a key_block */
567
562
 
568
 
void _mi_kpointer(register MI_INFO *info, register unsigned char *buff, internal::my_off_t pos)
 
563
void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
569
564
{
570
565
  pos/=MI_MIN_KEY_BLOCK_LENGTH;
571
566
  switch (info->s->base.key_reflength) {
584
579
  case 4: mi_int4store(buff,pos); break;
585
580
  case 3: mi_int3store(buff,pos); break;
586
581
  case 2: mi_int2store(buff,(uint) pos); break;
587
 
  case 1: buff[0]= (unsigned char) pos; break;
 
582
  case 1: buff[0]= (uchar) pos; break;
588
583
  default: abort();                             /* impossible */
589
584
  }
590
585
} /* _mi_kpointer */
593
588
        /* Calc pos to a data-record from a key */
594
589
 
595
590
 
596
 
internal::my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
 
591
my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
597
592
{
598
 
  internal::my_off_t pos;
 
593
  my_off_t pos;
599
594
  after_key-=(nod_flag + info->s->rec_reflength);
600
595
  switch (info->s->rec_reflength) {
601
596
#if SIZEOF_OFF_T > 4
602
 
  case 8:  pos= (internal::my_off_t) mi_uint8korr(after_key);  break;
603
 
  case 7:  pos= (internal::my_off_t) mi_uint7korr(after_key);  break;
604
 
  case 6:  pos= (internal::my_off_t) mi_uint6korr(after_key);  break;
605
 
  case 5:  pos= (internal::my_off_t) mi_uint5korr(after_key);  break;
 
597
  case 8:  pos= (my_off_t) mi_uint8korr(after_key);  break;
 
598
  case 7:  pos= (my_off_t) mi_uint7korr(after_key);  break;
 
599
  case 6:  pos= (my_off_t) mi_uint6korr(after_key);  break;
 
600
  case 5:  pos= (my_off_t) mi_uint5korr(after_key);  break;
606
601
#else
607
 
  case 8:  pos= (internal::my_off_t) mi_uint4korr(after_key+4);   break;
608
 
  case 7:  pos= (internal::my_off_t) mi_uint4korr(after_key+3);   break;
609
 
  case 6:  pos= (internal::my_off_t) mi_uint4korr(after_key+2);   break;
610
 
  case 5:  pos= (internal::my_off_t) mi_uint4korr(after_key+1);   break;
 
602
  case 8:  pos= (my_off_t) mi_uint4korr(after_key+4);   break;
 
603
  case 7:  pos= (my_off_t) mi_uint4korr(after_key+3);   break;
 
604
  case 6:  pos= (my_off_t) mi_uint4korr(after_key+2);   break;
 
605
  case 5:  pos= (my_off_t) mi_uint4korr(after_key+1);   break;
611
606
#endif
612
 
  case 4:  pos= (internal::my_off_t) mi_uint4korr(after_key);  break;
613
 
  case 3:  pos= (internal::my_off_t) mi_uint3korr(after_key);  break;
614
 
  case 2:  pos= (internal::my_off_t) mi_uint2korr(after_key);  break;
 
607
  case 4:  pos= (my_off_t) mi_uint4korr(after_key);  break;
 
608
  case 3:  pos= (my_off_t) mi_uint3korr(after_key);  break;
 
609
  case 2:  pos= (my_off_t) mi_uint2korr(after_key);  break;
615
610
  default:
616
611
    pos=0L;                                     /* Shut compiler up */
617
612
  }
623
618
 
624
619
/* Calc position from a record pointer ( in delete link chain ) */
625
620
 
626
 
internal::my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
 
621
my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
627
622
{
628
 
  internal::my_off_t pos;
 
623
  my_off_t pos;
629
624
  switch (s->rec_reflength) {
630
625
#if SIZEOF_OFF_T > 4
631
626
  case 8:
632
 
    pos= (internal::my_off_t) mi_uint8korr(ptr);
 
627
    pos= (my_off_t) mi_uint8korr(ptr);
633
628
    if (pos == HA_OFFSET_ERROR)
634
629
      return HA_OFFSET_ERROR;                   /* end of list */
635
630
    break;
636
631
  case 7:
637
 
    pos= (internal::my_off_t) mi_uint7korr(ptr);
638
 
    if (pos == (((internal::my_off_t) 1) << 56) -1)
 
632
    pos= (my_off_t) mi_uint7korr(ptr);
 
633
    if (pos == (((my_off_t) 1) << 56) -1)
639
634
      return HA_OFFSET_ERROR;                   /* end of list */
640
635
    break;
641
636
  case 6:
642
 
    pos= (internal::my_off_t) mi_uint6korr(ptr);
643
 
    if (pos == (((internal::my_off_t) 1) << 48) -1)
 
637
    pos= (my_off_t) mi_uint6korr(ptr);
 
638
    if (pos == (((my_off_t) 1) << 48) -1)
644
639
      return HA_OFFSET_ERROR;                   /* end of list */
645
640
    break;
646
641
  case 5:
647
 
    pos= (internal::my_off_t) mi_uint5korr(ptr);
648
 
    if (pos == (((internal::my_off_t) 1) << 40) -1)
 
642
    pos= (my_off_t) mi_uint5korr(ptr);
 
643
    if (pos == (((my_off_t) 1) << 40) -1)
649
644
      return HA_OFFSET_ERROR;                   /* end of list */
650
645
    break;
651
646
#else
657
652
    /* fall through */
658
653
#endif
659
654
  case 4:
660
 
    pos= (internal::my_off_t) mi_uint4korr(ptr);
661
 
    if (pos == (internal::my_off_t) UINT32_MAX)
 
655
    pos= (my_off_t) mi_uint4korr(ptr);
 
656
    if (pos == (my_off_t) (uint32) ~0L)
662
657
      return  HA_OFFSET_ERROR;
663
658
    break;
664
659
  case 3:
665
 
    pos= (internal::my_off_t) mi_uint3korr(ptr);
666
 
    if (pos == (internal::my_off_t) (1 << 24) -1)
 
660
    pos= (my_off_t) mi_uint3korr(ptr);
 
661
    if (pos == (my_off_t) (1 << 24) -1)
667
662
      return HA_OFFSET_ERROR;
668
663
    break;
669
664
  case 2:
670
 
    pos= (internal::my_off_t) mi_uint2korr(ptr);
671
 
    if (pos == (internal::my_off_t) (1 << 16) -1)
 
665
    pos= (my_off_t) mi_uint2korr(ptr);
 
666
    if (pos == (my_off_t) (1 << 16) -1)
672
667
      return HA_OFFSET_ERROR;
673
668
    break;
674
669
  default: abort();                             /* Impossible */
681
676
 
682
677
        /* save position to record */
683
678
 
684
 
void _mi_dpointer(MI_INFO *info, unsigned char *buff, internal::my_off_t pos)
 
679
void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
685
680
{
686
681
  if (!(info->s->options &
687
682
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
720
715
 
721
716
        /* same as _mi_get_key but used with fixed length keys */
722
717
 
723
 
uint32_t _mi_get_static_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
724
 
                       register unsigned char **page, register unsigned char *key)
 
718
uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
719
                       register uchar **page, register uchar *key)
725
720
{
726
 
  memcpy(key, *page, keyinfo->keylength+nod_flag);
 
721
  memcpy((uchar*) key,(uchar*) *page,
 
722
         (size_t) (keyinfo->keylength+nod_flag));
727
723
  *page+=keyinfo->keylength+nod_flag;
728
724
  return(keyinfo->keylength);
729
725
} /* _mi_get_static_key */
743
739
    key_length + length of data pointer
744
740
*/
745
741
 
746
 
uint32_t _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
747
 
                      register unsigned char **page_pos, register unsigned char *key)
 
742
uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
743
                      register uchar **page_pos, register uchar *key)
748
744
{
749
745
  register HA_KEYSEG *keyseg;
750
 
  unsigned char *start_key,*page=*page_pos;
751
 
  uint32_t length;
 
746
  uchar *start_key,*page=*page_pos;
 
747
  uint length;
752
748
 
753
749
  start_key=key;
754
750
  for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
756
752
    if (keyseg->flag & HA_PACK_KEY)
757
753
    {
758
754
      /* key with length, packed to previous key */
759
 
      unsigned char *start=key;
760
 
      uint32_t packed= *page & 128,tot_length,rest_length;
 
755
      uchar *start=key;
 
756
      uint packed= *page & 128,tot_length,rest_length;
761
757
      if (keyseg->length >= 127)
762
758
      {
763
759
        length=mi_uint2korr(page) & 32767;
771
767
        if (length > (uint) keyseg->length)
772
768
        {
773
769
          mi_print_error(keyinfo->share, HA_ERR_CRASHED);
774
 
          errno=HA_ERR_CRASHED;
 
770
          my_errno=HA_ERR_CRASHED;
775
771
          return 0;                             /* Error */
776
772
        }
777
773
        if (length == 0)                        /* Same key */
783
779
          if (length > keyseg->length)
784
780
          {
785
781
            mi_print_error(keyinfo->share, HA_ERR_CRASHED);
786
 
            errno=HA_ERR_CRASHED;
 
782
            my_errno=HA_ERR_CRASHED;
787
783
            return 0;
788
784
          }
789
785
          continue;
801
797
        if (tot_length >= 255 && *start != 255)
802
798
        {
803
799
          /* length prefix changed from a length of one to a length of 3 */
804
 
          internal::bmove_upp(key+length+3, key+length+1, length);
 
800
          bmove_upp(key+length+3, key+length+1, length);
805
801
          *key=255;
806
802
          mi_int2store(key+1,tot_length);
807
803
          key+=3+length;
808
804
        }
809
805
        else if (tot_length < 255 && *start == 255)
810
806
        {
811
 
          memmove(key+1,key+3,length);
 
807
          bmove(key+1,key+3,length);
812
808
          *key=tot_length;
813
809
          key+=1+length;
814
810
        }
837
833
      if (length > (uint) keyseg->length)
838
834
      {
839
835
        mi_print_error(keyinfo->share, HA_ERR_CRASHED);
840
 
        errno=HA_ERR_CRASHED;
 
836
        my_errno=HA_ERR_CRASHED;
841
837
        return 0;                               /* Error */
842
838
      }
843
839
      store_key_length_inc(key,length);
852
848
      if (keyseg->flag &
853
849
          (HA_VAR_LENGTH_PART | HA_BLOB_PART | HA_SPACE_PACK))
854
850
      {
855
 
        unsigned char *tmp=page;
 
851
        uchar *tmp=page;
856
852
        get_key_length(length,tmp);
857
853
        length+=(uint) (tmp-page);
858
854
      }
859
855
      else
860
856
        length=keyseg->length;
861
857
    }
862
 
    memcpy(key, page, length);
 
858
    memcpy((uchar*) key,(uchar*) page,(size_t) length);
863
859
    key+=length;
864
860
    page+=length;
865
861
  }
866
862
  length=keyseg->length+nod_flag;
867
 
  memmove(key,page,length);
 
863
  bmove((uchar*) key,(uchar*) page,length);
868
864
  *page_pos= page+length;
869
865
  return ((uint) (key-start_key)+keyseg->length);
870
866
} /* _mi_get_pack_key */
873
869
 
874
870
/* key that is packed relatively to previous */
875
871
 
876
 
uint32_t _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint32_t nod_flag,
877
 
                             register unsigned char **page_pos, register unsigned char *key)
 
872
uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
 
873
                             register uchar **page_pos, register uchar *key)
878
874
{
879
875
  register HA_KEYSEG *keyseg;
880
 
  unsigned char *start_key,*page,*page_end,*from,*from_end;
881
 
  uint32_t length,tmp;
 
876
  uchar *start_key,*page,*page_end,*from,*from_end;
 
877
  uint length,tmp;
882
878
 
883
879
  page= *page_pos;
884
880
  page_end=page+MI_MAX_KEY_BUFF+1;
904
900
    if (length > keyinfo->maxlength)
905
901
    {
906
902
      mi_print_error(keyinfo->share, HA_ERR_CRASHED);
907
 
      errno=HA_ERR_CRASHED;
 
903
      my_errno=HA_ERR_CRASHED;
908
904
      return(0);                                 /* Wrong key */
909
905
    }
910
906
    /* Key is packed against prev key, take prefix from prev key. */
958
954
      length-=tmp;
959
955
      from=page; from_end=page_end;
960
956
    }
961
 
    memmove(key, from, length);
 
957
    memmove((uchar*) key, (uchar*) from, (size_t) length);
962
958
    key+=length;
963
959
    from+=length;
964
960
  }
985
981
    if (from_end != page_end)
986
982
    {
987
983
      mi_print_error(keyinfo->share, HA_ERR_CRASHED);
988
 
      errno=HA_ERR_CRASHED;
 
984
      my_errno=HA_ERR_CRASHED;
989
985
      return(0);                                 /* Error */
990
986
    }
991
987
    /* Copy data pointer and, if appropriate, key block pointer. */
992
 
    memcpy(key, from, length);
 
988
    memcpy((uchar*) key,(uchar*) from,(size_t) length);
993
989
    *page_pos= from+length;
994
990
  }
995
991
  return((uint) (key-start_key)+keyseg->length);
999
995
        /* Get key at position without knowledge of previous key */
1000
996
        /* Returns pointer to next key */
1001
997
 
1002
 
unsigned char *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1003
 
                   unsigned char *key, unsigned char *keypos, uint32_t *return_key_length)
 
998
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
999
                   uchar *key, uchar *keypos, uint *return_key_length)
1004
1000
{
1005
 
  uint32_t nod_flag;
 
1001
  uint nod_flag;
1006
1002
 
1007
1003
  nod_flag=mi_test_if_nod(page);
1008
1004
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1009
1005
  {
1010
 
    memmove(key,keypos,keyinfo->keylength+nod_flag);
 
1006
    bmove((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
1011
1007
    return(keypos+keyinfo->keylength+nod_flag);
1012
1008
  }
1013
1009
  else
1020
1016
      if (*return_key_length == 0)
1021
1017
      {
1022
1018
        mi_print_error(info->s, HA_ERR_CRASHED);
1023
 
        errno=HA_ERR_CRASHED;
 
1019
        my_errno=HA_ERR_CRASHED;
1024
1020
        return(0);
1025
1021
      }
1026
1022
    }
1032
1028
        /* Get key at position without knowledge of previous key */
1033
1029
        /* Returns 0 if ok */
1034
1030
 
1035
 
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1036
 
                                unsigned char *key, unsigned char *keypos,
1037
 
                                uint32_t *return_key_length)
 
1031
static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1032
                                uchar *key, uchar *keypos,
 
1033
                                uint *return_key_length)
1038
1034
{
1039
 
  uint32_t nod_flag;
 
1035
  uint nod_flag;
1040
1036
 
1041
1037
  nod_flag=mi_test_if_nod(page);
1042
1038
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1043
1039
  {
1044
1040
    *return_key_length=keyinfo->keylength;
1045
 
    memmove(key, keypos - *return_key_length-nod_flag, *return_key_length);
 
1041
    bmove((uchar*) key,(uchar*) keypos- *return_key_length-nod_flag,
 
1042
          *return_key_length);
1046
1043
    return(0);
1047
1044
  }
1048
1045
  else
1055
1052
      if (*return_key_length == 0)
1056
1053
      {
1057
1054
        mi_print_error(info->s, HA_ERR_CRASHED);
1058
 
        errno=HA_ERR_CRASHED;
 
1055
        my_errno=HA_ERR_CRASHED;
1059
1056
        return(1);
1060
1057
      }
1061
1058
    }
1068
1065
        /* Get last key from key-page */
1069
1066
        /* Return pointer to where key starts */
1070
1067
 
1071
 
unsigned char *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
1072
 
                        unsigned char *lastkey, unsigned char *endpos, uint32_t *return_key_length)
 
1068
uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
1069
                        uchar *lastkey, uchar *endpos, uint *return_key_length)
1073
1070
{
1074
 
  uint32_t nod_flag;
1075
 
  unsigned char *lastpos;
 
1071
  uint nod_flag;
 
1072
  uchar *lastpos;
1076
1073
 
1077
1074
  nod_flag=mi_test_if_nod(page);
1078
1075
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1080
1077
    lastpos=endpos-keyinfo->keylength-nod_flag;
1081
1078
    *return_key_length=keyinfo->keylength;
1082
1079
    if (lastpos > page)
1083
 
      memmove(lastkey,lastpos,keyinfo->keylength+nod_flag);
 
1080
      bmove((uchar*) lastkey,(uchar*) lastpos,keyinfo->keylength+nod_flag);
1084
1081
  }
1085
1082
  else
1086
1083
  {
1093
1090
      if (*return_key_length == 0)
1094
1091
      {
1095
1092
        mi_print_error(info->s, HA_ERR_CRASHED);
1096
 
        errno=HA_ERR_CRASHED;
 
1093
        my_errno=HA_ERR_CRASHED;
1097
1094
        return(0);
1098
1095
      }
1099
1096
    }
1104
1101
 
1105
1102
        /* Calculate length of key */
1106
1103
 
1107
 
uint32_t _mi_keylength(MI_KEYDEF *keyinfo, register unsigned char *key)
 
1104
uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
1108
1105
{
1109
1106
  register HA_KEYSEG *keyseg;
1110
 
  unsigned char *start;
 
1107
  uchar *start;
1111
1108
 
1112
1109
  if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
1113
1110
    return (keyinfo->keylength);
1120
1117
        continue;
1121
1118
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1122
1119
    {
1123
 
      uint32_t length;
 
1120
      uint length;
1124
1121
      get_key_length(length,key);
1125
1122
      key+=length;
1126
1123
    }
1139
1136
  after '0xDF' but find 'ss'
1140
1137
*/
1141
1138
 
1142
 
uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
 
1139
uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
1143
1140
                        HA_KEYSEG *end)
1144
1141
{
1145
1142
  register HA_KEYSEG *keyseg;
1146
 
  unsigned char *start= key;
 
1143
  uchar *start= key;
1147
1144
 
1148
1145
  for (keyseg=keyinfo->seg ; keyseg != end ; keyseg++)
1149
1146
  {
1152
1149
        continue;
1153
1150
    if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
1154
1151
    {
1155
 
      uint32_t length;
 
1152
      uint length;
1156
1153
      get_key_length(length,key);
1157
1154
      key+=length;
1158
1155
    }
1164
1161
 
1165
1162
        /* Move a key */
1166
1163
 
1167
 
unsigned char *_mi_move_key(MI_KEYDEF *keyinfo, unsigned char *to, unsigned char *from)
 
1164
uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
1168
1165
{
1169
 
  register uint32_t length;
1170
 
  length= _mi_keylength(keyinfo, from);
1171
 
  memcpy(to, from, length);
 
1166
  register uint length;
 
1167
  memcpy((uchar*) to, (uchar*) from,
 
1168
         (size_t) (length=_mi_keylength(keyinfo,from)));
1172
1169
  return to+length;
1173
1170
}
1174
1171
 
1176
1173
        /* This can't be used when database is touched after last read */
1177
1174
 
1178
1175
int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1179
 
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, internal::my_off_t pos)
 
1176
                    uchar *key, uint key_length, uint nextflag, my_off_t pos)
1180
1177
{
1181
1178
  int error;
1182
 
  uint32_t nod_flag;
1183
 
  unsigned char lastkey[MI_MAX_KEY_BUFF];
 
1179
  uint nod_flag;
 
1180
  uchar lastkey[MI_MAX_KEY_BUFF];
1184
1181
 
1185
1182
  /* Force full read if we are at last key or if we are not on a leaf
1186
1183
     and the key tree has changed since we used it last time
1209
1206
 
1210
1207
  if (nextflag & SEARCH_BIGGER)                                 /* Next key */
1211
1208
  {
1212
 
    internal::my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
 
1209
    my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
1213
1210
    if (tmp_pos != HA_OFFSET_ERROR)
1214
1211
    {
1215
1212
      if ((error=_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
1223
1220
  }
1224
1221
  else                                                  /* Previous key */
1225
1222
  {
1226
 
    uint32_t length;
 
1223
    uint length;
1227
1224
    /* Find start of previous key */
1228
1225
    info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
1229
1226
                                      info->int_keypos, &length);
1252
1249
        /* This is stored in info->lastpos */
1253
1250
 
1254
1251
int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1255
 
                     register internal::my_off_t pos)
 
1252
                     register my_off_t pos)
1256
1253
{
1257
 
  uint32_t nod_flag;
1258
 
  unsigned char *page;
 
1254
  uint nod_flag;
 
1255
  uchar *page;
1259
1256
 
1260
1257
  if (pos == HA_OFFSET_ERROR)
1261
1258
  {
1262
 
    errno=HA_ERR_KEY_NOT_FOUND;
 
1259
    my_errno=HA_ERR_KEY_NOT_FOUND;
1263
1260
    info->lastpos= HA_OFFSET_ERROR;
1264
1261
    return(-1);
1265
1262
  }
1294
1291
        /* This is stored in info->lastpos */
1295
1292
 
1296
1293
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1297
 
                    register internal::my_off_t pos)
 
1294
                    register my_off_t pos)
1298
1295
{
1299
 
  uint32_t nod_flag;
1300
 
  unsigned char *buff,*page;
 
1296
  uint nod_flag;
 
1297
  uchar *buff,*page;
1301
1298
 
1302
1299
  if (pos == HA_OFFSET_ERROR)
1303
1300
  {
1304
 
    errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
 
1301
    my_errno=HA_ERR_KEY_NOT_FOUND;                      /* Didn't find key */
1305
1302
    info->lastpos= HA_OFFSET_ERROR;
1306
1303
    return(-1);
1307
1304
  }
1349
1346
/* Static length key */
1350
1347
 
1351
1348
int
1352
 
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1353
 
                           unsigned char *next_pos,
1354
 
                           unsigned char *org_key,
1355
 
                           unsigned char *prev_key,
1356
 
                           unsigned char *key, MI_KEY_PARAM *s_temp)
 
1349
_mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1350
                           uchar *next_pos  __attribute__((unused)),
 
1351
                           uchar *org_key  __attribute__((unused)),
 
1352
                           uchar *prev_key __attribute__((unused)),
 
1353
                           uchar *key, MI_KEY_PARAM *s_temp)
1357
1354
{
1358
 
  (void)next_pos;
1359
 
  (void)org_key;
1360
 
  (void)prev_key;
1361
1355
  s_temp->key=key;
1362
1356
  return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
1363
1357
}
1365
1359
/* Variable length key */
1366
1360
 
1367
1361
int
1368
 
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1369
 
                        unsigned char *next_pos,
1370
 
                        unsigned char *org_key,
1371
 
                        unsigned char *prev_key,
1372
 
                        unsigned char *key, MI_KEY_PARAM *s_temp)
 
1362
_mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
1363
                        uchar *next_pos  __attribute__((unused)),
 
1364
                        uchar *org_key  __attribute__((unused)),
 
1365
                        uchar *prev_key __attribute__((unused)),
 
1366
                        uchar *key, MI_KEY_PARAM *s_temp)
1373
1367
{
1374
 
  (void)next_pos;
1375
 
  (void)org_key;
1376
 
  (void)prev_key;
1377
1368
  s_temp->key=key;
1378
1369
  return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
1379
1370
}
1398
1389
*/
1399
1390
 
1400
1391
int
1401
 
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
1402
 
                             unsigned char *next_key,
1403
 
                             unsigned char *org_key,
1404
 
                             unsigned char *prev_key,
1405
 
                             unsigned char *key,
 
1392
_mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 
1393
                             uchar *org_key, uchar *prev_key, uchar *key,
1406
1394
                             MI_KEY_PARAM *s_temp)
1407
1395
{
1408
1396
  register HA_KEYSEG *keyseg;
1409
1397
  int length;
1410
 
  uint32_t key_length,ref_length,org_key_length=0,
 
1398
  uint key_length,ref_length,org_key_length=0,
1411
1399
       length_pack,new_key_length,diff_flag,pack_marker;
1412
 
  unsigned char *start,*end,*key_end,*sort_order;
1413
 
  bool same_length;
 
1400
  uchar *start,*end,*key_end,*sort_order;
 
1401
  my_bool same_length;
1414
1402
 
1415
1403
  length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
1416
1404
  same_length=0; keyseg=keyinfo->seg;
1525
1513
        /* If something after that hasn't length=0, test if we can combine */
1526
1514
  if ((s_temp->next_key_pos=next_key))
1527
1515
  {
1528
 
    uint32_t packed,n_length;
 
1516
    uint packed,n_length;
1529
1517
 
1530
1518
    packed = *next_key & 128;
1531
1519
    if (diff_flag == 2)
1540
1528
 
1541
1529
    if (n_length || packed)             /* Don't pack 0 length keys */
1542
1530
    {
1543
 
      uint32_t next_length_pack, new_ref_length=s_temp->ref_length;
 
1531
      uint next_length_pack, new_ref_length=s_temp->ref_length;
1544
1532
 
1545
1533
      if (packed)
1546
1534
      {
1608
1596
        }
1609
1597
        if (ref_length+pack_marker > new_ref_length)
1610
1598
        {
1611
 
          uint32_t new_pack_length=new_ref_length-pack_marker;
 
1599
          uint new_pack_length=new_ref_length-pack_marker;
1612
1600
          /* We must copy characters from the original key to the next key */
1613
1601
          s_temp->part_of_prev_key= new_ref_length;
1614
1602
          s_temp->prev_length=      ref_length - new_pack_length;
1626
1614
      }
1627
1615
 
1628
1616
      {
1629
 
        uint32_t tmp_length;
 
1617
        uint tmp_length;
1630
1618
        key=(start+=ref_length);
1631
1619
        if (key+n_length < key_end)             /* Normalize length based */
1632
1620
          key_end=key+n_length;
1673
1661
/* Length of key which is prefix compressed */
1674
1662
 
1675
1663
int
1676
 
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *next_key,
1677
 
                             unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
 
1664
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
 
1665
                             uchar *org_key, uchar *prev_key, uchar *key,
1678
1666
                             MI_KEY_PARAM *s_temp)
1679
1667
{
1680
 
  uint32_t length,key_length,ref_length;
 
1668
  uint length,key_length,ref_length;
1681
1669
 
1682
1670
  s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
1683
 
#ifdef HAVE_VALGRIND
 
1671
#ifdef HAVE_purify
1684
1672
  s_temp->n_length= s_temp->n_ref_length=0;     /* For valgrind */
1685
1673
#endif
1686
1674
  s_temp->key=key;
1692
1680
      As keys may be identical when running a sort in myisamchk, we
1693
1681
      have to guard against the case where keys may be identical
1694
1682
    */
1695
 
    unsigned char *end;
 
1683
    uchar *end;
1696
1684
    end=key+key_length;
1697
1685
    for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
1698
1686
    s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
1707
1695
  if ((s_temp->next_key_pos=next_key))          /* If another key after */
1708
1696
  {
1709
1697
    /* pack key against next key */
1710
 
    uint32_t next_length,next_length_pack;
 
1698
    uint next_length,next_length_pack;
1711
1699
    get_key_pack_length(next_length,next_length_pack,next_key);
1712
1700
 
1713
1701
    /* If first key and next key is packed (only on delete) */
1714
1702
    if (!prev_key && org_key && next_length)
1715
1703
    {
1716
 
      unsigned char *end;
 
1704
      uchar *end;
1717
1705
      for (key= s_temp->key, end=key+next_length ;
1718
1706
           *key == *org_key && key < end;
1719
1707
           key++,org_key++) ;
1754
1742
 
1755
1743
/* store key without compression */
1756
1744
 
1757
 
void _mi_store_static_key(MI_KEYDEF *keyinfo,
1758
 
                          register unsigned char *key_pos,
 
1745
void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
 
1746
                          register uchar *key_pos,
1759
1747
                          register MI_KEY_PARAM *s_temp)
1760
1748
{
1761
 
  (void)keyinfo;
1762
 
  memcpy(key_pos, s_temp->key, s_temp->totlength);
 
1749
  memcpy((uchar*) key_pos,(uchar*) s_temp->key,(size_t) s_temp->totlength);
1763
1750
}
1764
1751
 
1765
1752
 
1766
1753
/* store variable length key with prefix compression */
1767
1754
 
1768
1755
#define store_pack_length(test,pos,length) { \
1769
 
  if (test) { *((pos)++) = (unsigned char) (length); } else \
1770
 
  { *((pos)++) = (unsigned char) ((length) >> 8); *((pos)++) = (unsigned char) (length);  } }
1771
 
 
1772
 
 
1773
 
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,
1774
 
                            register unsigned char *key_pos,
 
1756
  if (test) { *((pos)++) = (uchar) (length); } else \
 
1757
  { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
 
1758
 
 
1759
 
 
1760
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
 
1761
                            register uchar *key_pos,
1775
1762
                            register MI_KEY_PARAM *s_temp)
1776
1763
{
1777
 
  (void)keyinfo;
1778
 
  uint32_t length;
1779
 
  unsigned char *start;
 
1764
  uint length;
 
1765
  uchar *start;
1780
1766
 
1781
1767
  start=key_pos;
1782
1768
 
1793
1779
    /* Not packed against previous key */
1794
1780
    store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->key_length);
1795
1781
  }
1796
 
  assert(key_pos >= start);
1797
 
  length= s_temp->totlength - (key_pos - start);
1798
 
  memmove(key_pos, s_temp->key, length);
 
1782
  bmove((uchar*) key_pos,(uchar*) s_temp->key,
 
1783
        (length=s_temp->totlength-(uint) (key_pos-start)));
1799
1784
 
1800
1785
  if (!s_temp->next_key_pos)                    /* No following key */
1801
1786
    return;
1835
1820
 
1836
1821
/* variable length key with prefix compression */
1837
1822
 
1838
 
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,
1839
 
                            register unsigned char *key_pos,
 
1823
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
 
1824
                            register uchar *key_pos,
1840
1825
                            register MI_KEY_PARAM *s_temp)
1841
1826
{
1842
 
  (void)keyinfo;
1843
 
  assert(s_temp->totlength >= s_temp->ref_length);
1844
1827
  store_key_length_inc(key_pos,s_temp->ref_length);
1845
 
  memcpy(key_pos,s_temp->key+s_temp->ref_length,
1846
 
         s_temp->totlength - s_temp->ref_length);
 
1828
  memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
 
1829
          (size_t) s_temp->totlength-s_temp->ref_length);
1847
1830
 
1848
1831
  if (s_temp->next_key_pos)
1849
1832
  {