← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_dynrec.c

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_dynrec.c
42
42
static int update_dynamic_record(MI_INFO *info,my_off_t filepos,unsigned char *record,
43
43
                                 ulong reclength);
44
44
static int delete_dynamic_record(MI_INFO *info,my_off_t filepos,
45
 
                                 uint second_read);
 
45
                                 uint32_t second_read);
46
46
static int _mi_cmp_buffer(File file, const unsigned char *buff, my_off_t filepos,
47
 
                          uint length);
 
47
                          uint32_t length);
48
48
 
49
49
/* Play it safe; We have a small stack when using threads */
50
50
#undef my_alloca
240
240
 
241
241
int _mi_update_dynamic_record(MI_INFO *info, my_off_t pos, const unsigned char *record)
242
242
{
243
 
  uint length=_mi_rec_pack(info,info->rec_buff,record);
 
243
  uint32_t length=_mi_rec_pack(info,info->rec_buff,record);
244
244
  return (update_dynamic_record(info,pos,info->rec_buff,length));
245
245
}
246
246
 
518
518
        /* info->rec_cache.seek_not_done is updated in cmp_record */
519
519
 
520
520
static int delete_dynamic_record(MI_INFO *info, my_off_t filepos,
521
 
                                 uint second_read)
 
521
                                 uint32_t second_read)
522
522
{
523
 
  uint length,b_type;
 
523
  uint32_t length,b_type;
524
524
  MI_BLOCK_INFO block_info,del_block;
525
525
  int error;
526
526
  bool remove_next_block;
769
769
                                 ulong reclength)
770
770
{
771
771
  int flag;
772
 
  uint error;
 
772
  uint32_t error;
773
773
  ulong length;
774
774
  MI_BLOCK_INFO block_info;
775
775
 
834
834
      length=(ulong) (block_info.filepos-filepos) + block_info.block_len;
835
835
      if (length < reclength)
836
836
      {
837
 
        uint tmp=MY_ALIGN(reclength - length + 3 +
 
837
        uint32_t tmp=MY_ALIGN(reclength - length + 3 +
838
838
                          test(reclength >= 65520L),MI_DYN_ALIGN_SIZE);
839
839
        /* Don't create a block bigger than MI_MAX_BLOCK_LENGTH */
840
840
        tmp= cmin(length+tmp, MI_MAX_BLOCK_LENGTH)-length;
928
928
 
929
929
        /* Pack a record. Return new reclength */
930
930
 
931
 
uint _mi_rec_pack(MI_INFO *info, register unsigned char *to,
 
931
uint32_t _mi_rec_pack(MI_INFO *info, register unsigned char *to,
932
932
                  register const unsigned char *from)
933
933
{
934
934
  uint          length,new_length,flag,bit,i;
1009
1009
      }
1010
1010
      else if (type == FIELD_VARCHAR)
1011
1011
      {
1012
 
        uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
1013
 
        uint tmp_length;
 
1012
        uint32_t pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
 
1013
        uint32_t tmp_length;
1014
1014
        if (pack_length == 1)
1015
1015
        {
1016
1016
          tmp_length= (uint) *(unsigned char*) from;
1076
1076
    {
1077
1077
      if (type == FIELD_BLOB)
1078
1078
      {
1079
 
        uint blob_length=
 
1079
        uint32_t blob_length=
1080
1080
          _mi_calc_blob_length(length-portable_sizeof_char_ptr,record);
1081
1081
        if (!blob_length && !(flag & bit))
1082
1082
          goto err;
1131
1131
      }
1132
1132
      else if (type == FIELD_VARCHAR)
1133
1133
      {
1134
 
        uint pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
1135
 
        uint tmp_length;
 
1134
        uint32_t pack_length= HA_VARCHAR_PACKLENGTH(rec->length -1);
 
1135
        uint32_t tmp_length;
1136
1136
        if (pack_length == 1)
1137
1137
        {
1138
1138
          tmp_length= (uint) *(unsigned char*) record;
1182
1182
ulong _mi_rec_unpack(register MI_INFO *info, register unsigned char *to, unsigned char *from,
1183
1183
                     ulong found_length)
1184
1184
{
1185
 
  uint flag,bit,length,rec_length,min_pack_length;
 
1185
  uint32_t flag,bit,length,rec_length,min_pack_length;
1186
1186
  enum en_fieldtype type;
1187
1187
  unsigned char *from_end,*to_end,*packpos;
1188
1188
  register MI_COLUMNDEF *rec,*end_field;
1204
1204
    {
1205
1205
      if (type == FIELD_VARCHAR)
1206
1206
      {
1207
 
        uint pack_length= HA_VARCHAR_PACKLENGTH(rec_length-1);
 
1207
        uint32_t pack_length= HA_VARCHAR_PACKLENGTH(rec_length-1);
1208
1208
        if (pack_length == 1)
1209
1209
        {
1210
1210
          length= (uint) *(unsigned char*) from;
1264
1264
      }
1265
1265
      else if (type == FIELD_BLOB)
1266
1266
      {
1267
 
        uint size_length=rec_length- portable_sizeof_char_ptr;
 
1267
        uint32_t size_length=rec_length- portable_sizeof_char_ptr;
1268
1268
        ulong blob_length=_mi_calc_blob_length(size_length,from);
1269
1269
        ulong from_left= (ulong) (from_end - from);
1270
1270
        if (from_left < size_length ||
1328
1328
}
1329
1329
 
1330
1330
 
1331
 
ulong _mi_calc_blob_length(uint length, const unsigned char *pos)
 
1331
ulong _mi_calc_blob_length(uint32_t length, const unsigned char *pos)
1332
1332
{
1333
1333
  switch (length) {
1334
1334
  case 1:
1346
1346
}
1347
1347
 
1348
1348
 
1349
 
void _my_store_blob_length(unsigned char *pos,uint pack_length,uint length)
 
1349
void _my_store_blob_length(unsigned char *pos,uint32_t pack_length,uint32_t length)
1350
1350
{
1351
1351
  switch (pack_length) {
1352
1352
  case 1:
1402
1402
int _mi_read_dynamic_record(MI_INFO *info, my_off_t filepos, unsigned char *buf)
1403
1403
{
1404
1404
  int block_of_record;
1405
 
  uint b_type, left_length= 0;
 
1405
  uint32_t b_type, left_length= 0;
1406
1406
  unsigned char *to= NULL;
1407
1407
  MI_BLOCK_INFO block_info;
1408
1408
  File file;
1448
1448
        goto panic;                     /* Wrong linked record */
1449
1449
      /* copy information that is already read */
1450
1450
      {
1451
 
        uint offset= (uint) (block_info.filepos - filepos);
1452
 
        uint prefetch_len= (sizeof(block_info.header) - offset);
 
1451
        uint32_t offset= (uint) (block_info.filepos - filepos);
 
1452
        uint32_t prefetch_len= (sizeof(block_info.header) - offset);
1453
1453
        filepos+= sizeof(block_info.header);
1454
1454
 
1455
1455
        if (prefetch_len > block_info.data_len)
1532
1532
 
1533
1533
int _mi_cmp_dynamic_record(register MI_INFO *info, register const unsigned char *record)
1534
1534
{
1535
 
  uint flag,reclength,b_type;
 
1535
  uint32_t flag,reclength,b_type;
1536
1536
  my_off_t filepos;
1537
1537
  unsigned char *buffer;
1538
1538
  MI_BLOCK_INFO block_info;
1608
1608
        /* Compare file to buffert */
1609
1609
 
1610
1610
static int _mi_cmp_buffer(File file, const unsigned char *buff, my_off_t filepos,
1611
 
                          uint length)
 
1611
                          uint32_t length)
1612
1612
{
1613
 
  uint next_length;
 
1613
  uint32_t next_length;
1614
1614
  unsigned char temp_buff[IO_SIZE*2];
1615
1615
 
1616
1616
  next_length= IO_SIZE*2 - (uint) (filepos & (IO_SIZE-1));
1672
1672
                                bool skip_deleted_blocks)
1673
1673
{
1674
1674
  int block_of_record, info_read, save_errno;
1675
 
  uint left_len,b_type;
 
1675
  uint32_t left_len,b_type;
1676
1676
  unsigned char *to= NULL;
1677
1677
  MI_BLOCK_INFO block_info;
1678
1678
  MYISAM_SHARE *share=info->s;
1763
1763
 
1764
1764
    /* copy information that is already read */
1765
1765
    {
1766
 
      uint offset=(uint) (block_info.filepos - filepos);
1767
 
      uint tmp_length= (sizeof(block_info.header) - offset);
 
1766
      uint32_t offset=(uint) (block_info.filepos - filepos);
 
1767
      uint32_t tmp_length= (sizeof(block_info.header) - offset);
1768
1768
      filepos=block_info.filepos;
1769
1769
 
1770
1770
      if (tmp_length > block_info.data_len)
1837
1837
 
1838
1838
        /* Read and process header from a dynamic-record-file */
1839
1839
 
1840
 
uint _mi_get_block_info(MI_BLOCK_INFO *info, File file, my_off_t filepos)
 
1840
uint32_t _mi_get_block_info(MI_BLOCK_INFO *info, File file, my_off_t filepos)
1841
1841
{
1842
 
  uint return_val=0;
 
1842
  uint32_t return_val=0;
1843
1843
  unsigned char *header=info->header;
1844
1844
 
1845
1845
  if (file >= 0)