← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_packrec.c

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_packrec.c
44
44
  { bits-=(bit+1); break; } \
45
45
  pos+= *pos
46
46
 
47
 
/* Size in uint16 of a Huffman tree for byte compression of 256 byte values. */
 
47
/* Size in uint16_t of a Huffman tree for byte compression of 256 byte values. */
48
48
#define OFFSET_TABLE_SIZE 512
49
49
 
50
50
static uint read_huff_table(MI_BIT_BUFF *bit_buff,MI_DECODE_TREE *decode_tree,
51
 
                            uint16 **decode_table,uchar **intervall_buff,
52
 
                            uint16 *tmp_buff);
53
 
static void make_quick_table(uint16 *to_table,uint16 *decode_table,
 
51
                            uint16_t **decode_table,uchar **intervall_buff,
 
52
                            uint16_t *tmp_buff);
 
53
static void make_quick_table(uint16_t *to_table,uint16_t *decode_table,
54
54
                             uint *next_free,uint value,uint bits,
55
55
                             uint max_bits);
56
 
static void fill_quick_table(uint16 *table,uint bits, uint max_bits,
 
56
static void fill_quick_table(uint16_t *table,uint bits, uint max_bits,
57
57
                             uint value);
58
 
static uint copy_decode_table(uint16 *to_pos,uint offset,
59
 
                              uint16 *decode_table);
60
 
static uint find_longest_bitstream(uint16 *table, uint16 *end);
 
58
static uint copy_decode_table(uint16_t *to_pos,uint offset,
 
59
                              uint16_t *decode_table);
 
60
static uint find_longest_bitstream(uint16_t *table, uint16_t *end);
61
61
static void (*get_unpack_function(MI_COLUMNDEF *rec))(MI_COLUMNDEF *field,
62
62
                                                    MI_BIT_BUFF *buff,
63
63
                                                    uchar *to,
134
134
  File file;
135
135
  int diff_length;
136
136
  uint i,trees,huff_tree_bits,rec_reflength,length;
137
 
  uint16 *decode_table,*tmp_buff;
 
137
  uint16_t *decode_table,*tmp_buff;
138
138
  ulong elements,intervall_length;
139
139
  uchar *disk_cache;
140
140
  uchar *intervall_buff;
198
198
    This segment will be reallocated after construction of the tables.
199
199
  */
200
200
  length=(uint) (elements*2+trees*(1 << myisam_quick_table_bits));
201
 
  if (!(share->decode_tables=(uint16*)
202
 
        my_malloc((length + OFFSET_TABLE_SIZE) * sizeof(uint16) +
 
201
  if (!(share->decode_tables=(uint16_t*)
 
202
        my_malloc((length + OFFSET_TABLE_SIZE) * sizeof(uint16_t) +
203
203
                  (uint) (share->pack.header_length - sizeof(header)),
204
204
                  MYF(MY_WME | MY_ZEROFILL))))
205
205
    goto err1;
235
235
                        &intervall_buff,tmp_buff))
236
236
      goto err3;
237
237
  /* Reallocate the decoding tables to the used size. */
238
 
  decode_table=(uint16*)
 
238
  decode_table=(uint16_t*)
239
239
    my_realloc((uchar*) share->decode_tables,
240
240
               (uint) ((uchar*) decode_table - (uchar*) share->decode_tables),
241
241
               MYF(MY_HOLD_ON_ERROR));
245
245
    share->decode_tables=decode_table;
246
246
    for (i=0 ; i < trees ; i++)
247
247
      share->decode_trees[i].table=ADD_TO_PTR(share->decode_trees[i].table,
248
 
                                              diff, uint16*);
 
248
                                              diff, uint16_t*);
249
249
  }
250
250
 
251
251
  /* Fix record-ref-length for keys */
254
254
    for (i=0 ; i < share->base.keys ; i++)
255
255
    {
256
256
      MI_KEYDEF *keyinfo= &share->keyinfo[i];
257
 
      keyinfo->keylength+= (uint16) diff_length;
258
 
      keyinfo->minlength+= (uint16) diff_length;
259
 
      keyinfo->maxlength+= (uint16) diff_length;
260
 
      keyinfo->seg[keyinfo->keysegs].length= (uint16) rec_reflength;
 
257
      keyinfo->keylength+= (uint16_t) diff_length;
 
258
      keyinfo->minlength+= (uint16_t) diff_length;
 
259
      keyinfo->maxlength+= (uint16_t) diff_length;
 
260
      keyinfo->seg[keyinfo->keysegs].length= (uint16_t) rec_reflength;
261
261
    }
262
262
    if (share->ft2_keyinfo.seg)
263
263
    {
264
264
      MI_KEYDEF *ft2_keyinfo= &share->ft2_keyinfo;
265
 
      ft2_keyinfo->keylength+= (uint16) diff_length;
266
 
      ft2_keyinfo->minlength+= (uint16) diff_length;
267
 
      ft2_keyinfo->maxlength+= (uint16) diff_length;
 
265
      ft2_keyinfo->keylength+= (uint16_t) diff_length;
 
266
      ft2_keyinfo->minlength+= (uint16_t) diff_length;
 
267
      ft2_keyinfo->maxlength+= (uint16_t) diff_length;
268
268
    }
269
269
  }
270
270
 
303
303
*/
304
304
 
305
305
static uint read_huff_table(MI_BIT_BUFF *bit_buff, MI_DECODE_TREE *decode_tree,
306
 
                            uint16 **decode_table, uchar **intervall_buff,
307
 
                            uint16 *tmp_buff)
 
306
                            uint16_t **decode_table, uchar **intervall_buff,
 
307
                            uint16_t *tmp_buff)
308
308
{
309
309
  uint min_chr,elements,char_bits,offset_bits,size,intervall_length,table_bits,
310
310
  next_free_offset;
311
 
  uint16 *ptr,*end;
 
311
  uint16_t *ptr,*end;
312
312
 
313
313
  if (!get_bits(bit_buff,1))
314
314
  {
341
341
  {
342
342
    if (get_bit(bit_buff))
343
343
    {
344
 
      *ptr= (uint16) get_bits(bit_buff,offset_bits);
 
344
      *ptr= (uint16_t) get_bits(bit_buff,offset_bits);
345
345
      if ((ptr + *ptr >= end) || !*ptr)
346
346
      {
347
347
        return(1);
348
348
      }
349
349
    }
350
350
    else
351
 
      *ptr= (uint16) (IS_CHAR + (get_bits(bit_buff,char_bits) + min_chr));
 
351
      *ptr= (uint16_t) (IS_CHAR + (get_bits(bit_buff,char_bits) + min_chr));
352
352
  }
353
353
  skip_to_next_byte(bit_buff);
354
354
 
428
428
    void
429
429
*/
430
430
 
431
 
static void make_quick_table(uint16 *to_table, uint16 *decode_table,
 
431
static void make_quick_table(uint16_t *to_table, uint16_t *decode_table,
432
432
                             uint *next_free_offset, uint value, uint bits,
433
433
                             uint max_bits)
434
434
{
442
442
      Remaining left  Huffman tree segment starts behind quick table.
443
443
      Remaining right Huffman tree segment starts behind left segment.
444
444
    */
445
 
    to_table[value]= (uint16) *next_free_offset;
 
445
    to_table[value]= (uint16_t) *next_free_offset;
446
446
    /*
447
447
      Re-construct the remaining Huffman tree segment at
448
448
      next_free_offset in to_table.
516
516
    void
517
517
*/
518
518
 
519
 
static void fill_quick_table(uint16 *table, uint bits, uint max_bits,
 
519
static void fill_quick_table(uint16_t *table, uint bits, uint max_bits,
520
520
                             uint value)
521
521
{
522
 
  uint16 *end;
 
522
  uint16_t *end;
523
523
 
524
524
  /*
525
525
    Bits 1..8 of value represent the decoded byte value.
530
530
 
531
531
  for (end= table + ((my_ptrdiff_t) 1 << bits); table < end; table++)
532
532
  {
533
 
    *table= (uint16) value;
 
533
    *table= (uint16_t) value;
534
534
  }
535
535
  return;
536
536
}
552
552
    next free offset from to_pos.
553
553
*/
554
554
 
555
 
static uint copy_decode_table(uint16 *to_pos, uint offset,
556
 
                              uint16 *decode_table)
 
555
static uint copy_decode_table(uint16_t *to_pos, uint offset,
 
556
                              uint16_t *decode_table)
557
557
{
558
558
  uint prev_offset= offset;
559
559
 
578
578
  if (!(*decode_table & IS_CHAR))
579
579
  {
580
580
    /* Set a pointer to the next free target node. */
581
 
    to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
 
581
    to_pos[prev_offset+1]=(uint16_t) (offset-prev_offset-1);
582
582
    /* Copy the right hand subtree to the entry of that node. */
583
583
    offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
584
584
  }
615
615
    >= OFFSET_TABLE_SIZE    Error, broken tree. It does not end before 'end'.
616
616
*/
617
617
 
618
 
static uint find_longest_bitstream(uint16 *table, uint16 *end)
 
618
static uint find_longest_bitstream(uint16_t *table, uint16_t *end)
619
619
{
620
620
  uint length= 1;
621
621
  uint length2;
622
622
 
623
623
  if (!(*table & IS_CHAR))
624
624
  {
625
 
    uint16 *next= table + *table;
 
625
    uint16_t *next= table + *table;
626
626
    if (next > end || next == table)
627
627
    {
628
628
      return OFFSET_TABLE_SIZE;
632
632
  table++;
633
633
  if (!(*table & IS_CHAR))
634
634
  {
635
 
    uint16 *next= table + *table;
 
635
    uint16_t *next= table + *table;
636
636
    if (next > end || next == table)
637
637
    {
638
638
      return OFFSET_TABLE_SIZE;
771
771
                                   uchar *to, uchar *end)
772
772
{
773
773
  if (get_bit(bit_buff))
774
 
    bzero((char*) to,(uint) (end-to));
 
774
    memset((char*) to, 0, (uint) (end-to));
775
775
  else
776
776
  {
777
777
    end-=rec->space_length_bits;
778
778
    decode_bytes(rec,bit_buff,to,end);
779
 
    bzero((char*) end,rec->space_length_bits);
 
779
    memset((char*) end, 0, rec->space_length_bits);
780
780
  }
781
781
}
782
782
 
784
784
                          uchar *end)
785
785
{
786
786
  if (get_bit(bit_buff))
787
 
    bzero((char*) to,(uint) (end-to));
 
787
    memset((char*) to, 0, (uint) (end-to));
788
788
  else
789
789
    decode_bytes(rec,bit_buff,to,end);
790
790
}
793
793
                            uchar *end)
794
794
{
795
795
  if (get_bit(bit_buff))
796
 
    bfill((uchar*) to,(end-to),' ');
 
796
    memset((uchar*) to, ' ', (end-to));
797
797
  else
798
798
    decode_bytes(rec,bit_buff,to,end);
799
799
}
803
803
{
804
804
  uint spaces;
805
805
  if (get_bit(bit_buff))
806
 
    bfill((uchar*) to,(end-to),' ');
 
806
    memset((uchar*) to, ' ', (end-to));
807
807
  else
808
808
  {
809
809
    if (get_bit(bit_buff))
815
815
      }
816
816
      if (to+spaces != end)
817
817
        decode_bytes(rec,bit_buff,to,end-spaces);
818
 
      bfill((uchar*) end-spaces,spaces,' ');
 
818
      memset((uchar*) end-spaces, ' ', spaces);
819
819
    }
820
820
    else
821
821
      decode_bytes(rec,bit_buff,to,end);
835
835
    }
836
836
    if (to+spaces != end)
837
837
      decode_bytes(rec,bit_buff,to,end-spaces);
838
 
    bfill((uchar*) end-spaces,spaces,' ');
 
838
    memset((uchar*) end-spaces, ' ', spaces);
839
839
  }
840
840
  else
841
841
    decode_bytes(rec,bit_buff,to,end);
846
846
{
847
847
  uint spaces;
848
848
  if (get_bit(bit_buff))
849
 
    bfill((uchar*) to,(end-to),' ');
 
849
    memset((uchar*) to, ' ', (end-to));
850
850
  else
851
851
  {
852
852
    if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
856
856
    }
857
857
    if (to+spaces != end)
858
858
      decode_bytes(rec,bit_buff,to,end-spaces);
859
 
    bfill((uchar*) end-spaces,spaces,' ');
 
859
    memset((uchar*) end-spaces, ' ', spaces);
860
860
  }
861
861
}
862
862
 
871
871
  }
872
872
  if (to+spaces != end)
873
873
    decode_bytes(rec,bit_buff,to,end-spaces);
874
 
  bfill((uchar*) end-spaces,spaces,' ');
 
874
  memset((uchar*) end-spaces, ' ', spaces);
875
875
}
876
876
 
877
877
static void uf_space_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
879
879
{
880
880
  uint spaces;
881
881
  if (get_bit(bit_buff))
882
 
    bfill((uchar*) to,(end-to),' ');
 
882
    memset((uchar*) to, ' ', (end-to));
883
883
  else
884
884
  {
885
885
    if (get_bit(bit_buff))
889
889
        bit_buff->error=1;
890
890
        return;
891
891
      }
892
 
      bfill((uchar*) to,spaces,' ');
 
892
      memset((uchar*) to, ' ', spaces);
893
893
      if (to+spaces != end)
894
894
        decode_bytes(rec,bit_buff,to+spaces,end);
895
895
    }
910
910
      bit_buff->error=1;
911
911
      return;
912
912
    }
913
 
    bfill((uchar*) to,spaces,' ');
 
913
    memset((uchar*) to, ' ', spaces);
914
914
    if (to+spaces != end)
915
915
      decode_bytes(rec,bit_buff,to+spaces,end);
916
916
  }
924
924
{
925
925
  uint spaces;
926
926
  if (get_bit(bit_buff))
927
 
    bfill((uchar*) to,(end-to),' ');
 
927
    memset((uchar*) to, ' ', (end-to));
928
928
  else
929
929
  {
930
930
    if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
932
932
      bit_buff->error=1;
933
933
      return;
934
934
    }
935
 
    bfill((uchar*) to,spaces,' ');
 
935
    memset((uchar*) to, ' ', spaces);
936
936
    if (to+spaces != end)
937
937
      decode_bytes(rec,bit_buff,to+spaces,end);
938
938
  }
947
947
    bit_buff->error=1;
948
948
    return;
949
949
  }
950
 
  bfill((uchar*) to,spaces,' ');
 
950
  memset((uchar*) to, ' ', spaces);
951
951
  if (to+spaces != end)
952
952
    decode_bytes(rec,bit_buff,to+spaces,end);
953
953
}
957
957
{
958
958
  end-=rec->space_length_bits;
959
959
  decode_bytes(rec,bit_buff,(uchar*) to,end);
960
 
  bzero((char*) end,rec->space_length_bits);
 
960
  memset((char*) end, 0, rec->space_length_bits);
961
961
}
962
962
 
963
963
static void uf_constant(MI_COLUMNDEF *rec,
983
983
                    MI_BIT_BUFF *bit_buff __attribute__((unused)),
984
984
                    uchar *to, uchar *end)
985
985
{
986
 
  bzero((char*) to,(uint) (end-to));
 
986
  memset((char*) to, 0, (uint) (end-to));
987
987
}
988
988
 
989
989
static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
990
990
                    uchar *to, uchar *end)
991
991
{
992
992
  if (get_bit(bit_buff))
993
 
    bzero((uchar*) to,(end-to));
 
993
    memset((uchar*) to, 0, (end-to));
994
994
  else
995
995
  {
996
996
    ulong length=get_bits(bit_buff,rec->space_length_bits);
998
998
    if (bit_buff->blob_pos+length > bit_buff->blob_end)
999
999
    {
1000
1000
      bit_buff->error=1;
1001
 
      bzero((uchar*) to,(end-to));
 
1001
      memset((uchar*) to, 0, (end-to));
1002
1002
      return;
1003
1003
    }
1004
1004
    decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
1005
1005
    _my_store_blob_length((uchar*) to,pack_length,length);
1006
 
    memcpy_fixed((char*) to+pack_length,(char*) &bit_buff->blob_pos,
1007
 
                 sizeof(char*));
 
1006
    memcpy((char*) to+pack_length,(char*) &bit_buff->blob_pos,
 
1007
           sizeof(char*));
1008
1008
    bit_buff->blob_pos+=length;
1009
1009
  }
1010
1010
}
1045
1045
                         uchar *end)
1046
1046
{
1047
1047
  register uint bits,low_byte;
1048
 
  register uint16 *pos;
 
1048
  register uint16_t *pos;
1049
1049
  register uint table_bits,table_and;
1050
1050
  MI_DECODE_TREE *decode_tree;
1051
1051
 
1138
1138
                         uchar *end)
1139
1139
{
1140
1140
  register uint bits,low_byte;
1141
 
  register uint16 *pos;
 
1141
  register uint16_t *pos;
1142
1142
  register uint table_bits,table_and;
1143
1143
  MI_DECODE_TREE *decode_tree;
1144
1144
 
1233
1233
 
1234
1234
static uint decode_pos(MI_BIT_BUFF *bit_buff, MI_DECODE_TREE *decode_tree)
1235
1235
{
1236
 
  uint16 *pos=decode_tree->table;
 
1236
  uint16_t *pos=decode_tree->table;
1237
1237
  for (;;)
1238
1238
  {
1239
1239
    if (get_bit(bit_buff))