← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_open.c
16
16
/* open a isam-database */
17
17
 
18
18
#include "myisamdef.h"
19
 
#include <m_ctype.h>
 
19
#include <mystrings/m_ctype.h>
20
20
 
21
21
static void setup_key_functions(MI_KEYDEF *keyinfo);
22
22
#define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \
77
77
  lock_error=1;
78
78
  errpos=0;
79
79
  head_length=sizeof(share_buff.state.header);
80
 
  bzero((uchar*) &info,sizeof(info));
 
80
  memset((uchar*) &info, 0, sizeof(info));
81
81
 
82
82
  my_realpath(name_buff, fn_format(org_name,name,"",MI_NAME_IEXT,
83
83
                                   MY_UNPACK_FILENAME),MYF(0));
85
85
  if (!(old_info=test_if_reopen(name_buff)))
86
86
  {
87
87
    share= &share_buff;
88
 
    bzero((uchar*) &share_buff,sizeof(share_buff));
 
88
    memset((uchar*) &share_buff, 0, sizeof(share_buff));
89
89
    share_buff.state.rec_per_key_part=rec_per_key_part;
90
90
    share_buff.state.key_root=key_root;
91
91
    share_buff.state.key_del=key_del;
507
507
 
508
508
  /* Allocate buffer for one record */
509
509
 
510
 
  /* prerequisites: bzero(info) && info->s=share; are met. */
 
510
  /* prerequisites: memset(info, 0) && info->s=share; are met. */
511
511
  if (!mi_alloc_rec_buff(&info, -1, &info.rec_buff))
512
512
    goto err;
513
 
  bzero(info.rec_buff, mi_get_rec_buff_len(&info, info.rec_buff));
 
513
  memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
514
514
 
515
515
  *m_info=info;
516
516
  thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
564
564
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
565
565
{
566
566
  uint extra;
567
 
  uint32 old_length= 0;
 
567
  uint32_t old_length= 0;
568
568
 
569
569
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
570
570
  {
591
591
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
592
592
                                     MYF(MY_ALLOW_ZERO_PTR))))
593
593
      return newptr;
594
 
    *((uint32 *) newptr)= (uint32) length;
 
594
    *((uint32_t *) newptr)= (uint32_t) length;
595
595
    *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
596
596
  }
597
597
  return *buf;
727
727
  uint  i, keys= (uint) state->header.keys,
728
728
        key_blocks=state->header.max_block_size_index;
729
729
 
730
 
  memcpy_fixed(ptr,&state->header,sizeof(state->header));
 
730
  memcpy(ptr,&state->header,sizeof(state->header));
731
731
  ptr+=sizeof(state->header);
732
732
 
733
733
  /* open_count must be first because of _mi_mark_file_changed ! */
786
786
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
787
787
{
788
788
  uint i,keys,key_parts,key_blocks;
789
 
  memcpy_fixed(&state->header,ptr, sizeof(state->header));
 
789
  memcpy(&state->header,ptr, sizeof(state->header));
790
790
  ptr +=sizeof(state->header);
791
791
  keys=(uint) state->header.keys;
792
792
  key_parts=mi_uint2korr(state->header.key_parts);
889
889
  *ptr++= base->raid_type;
890
890
  mi_int2store(ptr,base->raid_chunks);                  ptr +=2;
891
891
  mi_int4store(ptr,base->raid_chunksize);               ptr +=4;
892
 
  bzero(ptr,6);                                         ptr +=6; /* extra */
 
892
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
893
893
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
894
894
}
895
895
 
1010
1010
   keyseg->null_pos     = mi_uint4korr(ptr);  ptr +=4;
1011
1011
   keyseg->charset=0;                           /* Will be filled in later */
1012
1012
   if (keyseg->null_bit)
1013
 
     keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7));
 
1013
     keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
1014
1014
   else
1015
1015
   {
1016
 
     keyseg->bit_pos= (uint16)keyseg->null_pos;
 
1016
     keyseg->bit_pos= (uint16_t)keyseg->null_pos;
1017
1017
     keyseg->null_pos= 0;
1018
1018
   }
1019
1019
   return ptr;
1063
1063
{
1064
1064
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1065
1065
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1066
 
   recinfo->null_bit= (uint8) *ptr++;
 
1066
   recinfo->null_bit= (uint8_t) *ptr++;
1067
1067
   recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1068
1068
   return ptr;
1069
1069
}