← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

  • Committer: Brian Aker
  • Date: 2008-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_open.c
69
69
    key_parts,unique_key_parts,fulltext_keys,uniques;
70
70
  char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
71
71
       data_name[FN_REFLEN];
72
 
  uchar *disk_cache= NULL;
73
 
  uchar *disk_pos, *end_pos;
 
72
  unsigned char *disk_cache= NULL;
 
73
  unsigned char *disk_pos, *end_pos;
74
74
  MI_INFO info,*m_info,*old_info;
75
75
  MYISAM_SHARE share_buff,*share;
76
76
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
93
93
    share_buff.state.rec_per_key_part=rec_per_key_part;
94
94
    share_buff.state.key_root=key_root;
95
95
    share_buff.state.key_del=key_del;
96
 
    share_buff.key_cache= multi_key_cache_search((uchar*) name_buff,
 
96
    share_buff.key_cache= multi_key_cache_search((unsigned char*) name_buff,
97
97
                                                 strlen(name_buff));
98
98
 
99
99
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
143
143
 
144
144
    info_length=mi_uint2korr(share->state.header.header_length);
145
145
    base_pos=mi_uint2korr(share->state.header.base_pos);
146
 
    if (!(disk_cache= (uchar*) malloc(info_length+128)))
 
146
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
147
147
    {
148
148
      my_errno=ENOMEM;
149
149
      goto err;
521
521
    mi_report_error(save_errno, name);
522
522
  switch (errpos) {
523
523
  case 6:
524
 
    free((uchar*) m_info);
 
524
    free((unsigned char*) m_info);
525
525
    /* fall through */
526
526
  case 5:
527
527
    my_close(info.dfile,MYF(0));
529
529
      break;                                    /* Don't remove open table */
530
530
    /* fall through */
531
531
  case 4:
532
 
    free((uchar*) share);
 
532
    free((unsigned char*) share);
533
533
    /* fall through */
534
534
  case 3:
535
535
    /* fall through */
546
546
} /* mi_open */
547
547
 
548
548
 
549
 
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
 
549
unsigned char *mi_alloc_rec_buff(MI_INFO *info, ulong length, unsigned char **buf)
550
550
{
551
551
  uint extra;
552
552
  uint32_t old_length= 0;
553
553
 
554
554
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
555
555
  {
556
 
    uchar *newptr = *buf;
 
556
    unsigned char *newptr = *buf;
557
557
 
558
558
    /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
559
559
    if (length == (ulong) -1)
573
573
            MI_REC_BUFF_OFFSET : 0);
574
574
    if (extra && newptr)
575
575
      newptr-= MI_REC_BUFF_OFFSET;
576
 
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
 
576
    if (!(newptr=(unsigned char*) my_realloc((unsigned char*)newptr, length+extra+8,
577
577
                                     MYF(MY_ALLOW_ZERO_PTR))))
578
578
      return newptr;
579
579
    *((uint32_t *) newptr)= (uint32_t) length;
696
696
 
697
697
uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
698
698
{
699
 
  uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
700
 
  uchar *ptr=buff;
 
699
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
700
  unsigned char *ptr=buff;
701
701
  uint  i, keys= (uint) state->header.keys,
702
702
        key_blocks=state->header.max_block_size_index;
703
703
 
706
706
 
707
707
  /* open_count must be first because of _mi_mark_file_changed ! */
708
708
  mi_int2store(ptr,state->open_count);          ptr +=2;
709
 
  *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
 
709
  *ptr++= (unsigned char)state->changed; *ptr++= state->sortkey;
710
710
  mi_rowstore(ptr,state->state.records);        ptr +=8;
711
711
  mi_rowstore(ptr,state->state.del);            ptr +=8;
712
712
  mi_rowstore(ptr,state->split);                ptr +=8;
757
757
}
758
758
 
759
759
 
760
 
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
 
760
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
761
761
{
762
762
  uint i,keys,key_parts,key_blocks;
763
763
  memcpy(&state->header,ptr, sizeof(state->header));
812
812
 
813
813
uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
814
814
{
815
 
  uchar buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
815
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
816
816
 
817
817
  if (!myisam_single_user)
818
818
  {
835
835
 
836
836
uint mi_base_info_write(File file, MI_BASE_INFO *base)
837
837
{
838
 
  uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
 
838
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
839
839
 
840
840
  mi_sizestore(ptr,base->keystart);                     ptr +=8;
841
841
  mi_sizestore(ptr,base->max_data_file_length);         ptr +=8;
868
868
}
869
869
 
870
870
 
871
 
uchar *my_n_base_info_read(uchar *ptr, MI_BASE_INFO *base)
 
871
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
872
872
{
873
873
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
874
874
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
914
914
 
915
915
uint mi_keydef_write(File file, MI_KEYDEF *keydef)
916
916
{
917
 
  uchar buff[MI_KEYDEF_SIZE];
918
 
  uchar *ptr=buff;
 
917
  unsigned char buff[MI_KEYDEF_SIZE];
 
918
  unsigned char *ptr=buff;
919
919
 
920
 
  *ptr++ = (uchar) keydef->keysegs;
 
920
  *ptr++ = (unsigned char) keydef->keysegs;
921
921
  *ptr++ = keydef->key_alg;                     /* Rtree or Btree */
922
922
  mi_int2store(ptr,keydef->flag);               ptr +=2;
923
923
  mi_int2store(ptr,keydef->block_length);       ptr +=2;
927
927
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
928
928
}
929
929
 
930
 
uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef)
 
930
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
931
931
{
932
932
   keydef->keysegs      = (uint) *ptr++;
933
933
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
949
949
 
950
950
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
951
951
{
952
 
  uchar buff[HA_KEYSEG_SIZE];
953
 
  uchar *ptr=buff;
 
952
  unsigned char buff[HA_KEYSEG_SIZE];
 
953
  unsigned char *ptr=buff;
954
954
  ulong pos;
955
955
 
956
956
  *ptr++= keyseg->type;
970
970
}
971
971
 
972
972
 
973
 
uchar *mi_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg)
 
973
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
974
974
{
975
975
   keyseg->type         = *ptr++;
976
976
   keyseg->language     = *ptr++;
999
999
 
1000
1000
uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
1001
1001
{
1002
 
  uchar buff[MI_UNIQUEDEF_SIZE];
1003
 
  uchar *ptr=buff;
 
1002
  unsigned char buff[MI_UNIQUEDEF_SIZE];
 
1003
  unsigned char *ptr=buff;
1004
1004
 
1005
1005
  mi_int2store(ptr,def->keysegs);               ptr+=2;
1006
 
  *ptr++=  (uchar) def->key;
1007
 
  *ptr++ = (uchar) def->null_are_equal;
 
1006
  *ptr++=  (unsigned char) def->key;
 
1007
  *ptr++ = (unsigned char) def->null_are_equal;
1008
1008
 
1009
1009
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1010
1010
}
1011
1011
 
1012
 
uchar *mi_uniquedef_read(uchar *ptr, MI_UNIQUEDEF *def)
 
1012
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1013
1013
{
1014
1014
   def->keysegs = mi_uint2korr(ptr);
1015
1015
   def->key     = ptr[2];
1023
1023
 
1024
1024
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1025
1025
{
1026
 
  uchar buff[MI_COLUMNDEF_SIZE];
1027
 
  uchar *ptr=buff;
 
1026
  unsigned char buff[MI_COLUMNDEF_SIZE];
 
1027
  unsigned char *ptr=buff;
1028
1028
 
1029
1029
  mi_int2store(ptr,recinfo->type);      ptr +=2;
1030
1030
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1033
1033
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1034
1034
}
1035
1035
 
1036
 
uchar *mi_recinfo_read(uchar *ptr, MI_COLUMNDEF *recinfo)
 
1036
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1037
1037
{
1038
1038
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1039
1039
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;