← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_packrec.c

  • Committer: Brian Aker
  • Date: 2008-08-05 04:10:42 UTC
  • mfrom: (261.2.8 codestyle)
  • mto: This revision was merged to the branch mainline in revision 263.
  • Revision ID: brian@tangent.org-20080805041042-1l4893r3bwy2lxz2
Merge from Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_packrec.c
156
156
    goto err0;
157
157
  }
158
158
  /* Only the first three bytes of magic number are independent of version. */
159
 
  if (memcmp((uchar*) header, (uchar*) myisam_pack_file_magic, 3))
 
159
  if (memcmp(header, myisam_pack_file_magic, 3))
160
160
  {
161
161
    my_errno=HA_ERR_WRONG_IN_RECORD;
162
162
    goto err0;
771
771
                                   uchar *to, uchar *end)
772
772
{
773
773
  if (get_bit(bit_buff))
774
 
    memset((char*) to, 0, (uint) (end-to));
 
774
    memset(to, 0, end - to);
775
775
  else
776
776
  {
777
777
    end-=rec->space_length_bits;
778
778
    decode_bytes(rec,bit_buff,to,end);
779
 
    memset((char*) end, 0, rec->space_length_bits);
 
779
    memset(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
 
    memset((char*) to, 0, (uint) (end-to));
 
787
    memset(to, 0, 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
 
    memset((uchar*) to, ' ', (end-to));
 
796
    memset(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
 
    memset((uchar*) to, ' ', (end-to));
 
806
    memset(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
 
      memset((uchar*) end-spaces, ' ', spaces);
 
818
      memset(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
 
    memset((uchar*) end-spaces, ' ', spaces);
 
838
    memset(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
 
    memset((uchar*) to, ' ', (end-to));
 
849
    memset(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
 
    memset((uchar*) end-spaces, ' ', spaces);
 
859
    memset(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
 
  memset((uchar*) end-spaces, ' ', spaces);
 
874
  memset(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
 
    memset((uchar*) to, ' ', (end-to));
 
882
    memset(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
 
      memset((uchar*) to, ' ', spaces);
 
892
      memset(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
 
    memset((uchar*) to, ' ', spaces);
 
913
    memset(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
 
    memset((uchar*) to, ' ', (end-to));
 
927
    memset(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
 
    memset((uchar*) to, ' ', spaces);
 
935
    memset(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
 
  memset((uchar*) to, ' ', spaces);
 
950
  memset(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
 
  memset((char*) end, 0, rec->space_length_bits);
 
960
  memset(end, 0, rec->space_length_bits);
961
961
}
962
962
 
963
963
static void uf_constant(MI_COLUMNDEF *rec,
965
965
                        uchar *to,
966
966
                        uchar *end)
967
967
{
968
 
  memcpy(to,rec->huff_tree->intervalls,(size_t) (end-to));
 
968
  memcpy(to, rec->huff_tree->intervalls, end - to);
969
969
}
970
970
 
971
971
static void uf_intervall(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
972
972
                         uchar *end)
973
973
{
974
 
  register uint field_length=(uint) (end-to);
975
 
  memcpy(to,rec->huff_tree->intervalls+field_length*decode_pos(bit_buff,
976
 
                                                               rec->huff_tree),
977
 
         (size_t) field_length);
 
974
  register uint field_length= end - to;
 
975
  memcpy(to,
 
976
         rec->huff_tree->intervalls+field_length*decode_pos(bit_buff, rec->huff_tree),
 
977
         field_length);
978
978
}
979
979
 
980
980
 
983
983
                    MI_BIT_BUFF *bit_buff __attribute__((unused)),
984
984
                    uchar *to, uchar *end)
985
985
{
986
 
  memset((char*) to, 0, (uint) (end-to));
 
986
  memset(to, 0, 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
 
    memset((uchar*) to, 0, (end-to));
 
993
    memset(to, 0, end - to);
994
994
  else
995
995
  {
996
996
    ulong length=get_bits(bit_buff,rec->space_length_bits);
997
 
    uint pack_length=(uint) (end-to)-portable_sizeof_char_ptr;
 
997
    uint pack_length= end - to - portable_sizeof_char_ptr;
998
998
    if (bit_buff->blob_pos+length > bit_buff->blob_end)
999
999
    {
1000
1000
      bit_buff->error=1;
1001
 
      memset((uchar*) to, 0, (end-to));
 
1001
      memset(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((char*) to+pack_length,(char*) &bit_buff->blob_pos,
1007
 
           sizeof(char*));
 
1006
    memcpy(to + pack_length, &bit_buff->blob_pos, sizeof(char*));
1008
1007
    bit_buff->blob_pos+=length;
1009
1008
  }
1010
1009
}