← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_check.c

  • Committer: Monty Taylor
  • Date: 2008-12-06 07:22:02 UTC
  • mto: (656.1.7 devel) (660.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: monty@inaugust.com-20081206072202-2g25o9doqr1l8euu
OOOh doggie. Got rid of my_alloca.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_check.c
730
730
  char llbuff[22];
731
731
  uint32_t diff_pos[2];
732
732
 
733
 
  if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))
 
733
  if (!(temp_buff=(unsigned char*) malloc(keyinfo->block_length)))
734
734
  {
735
735
    mi_check_print_error(param,"Not enough memory for keyblock");
736
736
    return(-1);
828
828
                llstr(page,llbuff), used_length, (keypos - buff));
829
829
    goto err;
830
830
  }
831
 
  my_afree((unsigned char*) temp_buff);
 
831
  free(temp_buff);
832
832
  return(0);
833
833
 err:
834
 
  my_afree((unsigned char*) temp_buff);
 
834
  free(temp_buff);
835
835
  return(1);
836
836
} /* chk_index */
837
837
 
1896
1896
  new_page_pos=param->new_file_pos;
1897
1897
  param->new_file_pos+=keyinfo->block_length;
1898
1898
 
1899
 
  if (!(buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))
 
1899
  if (!(buff=(unsigned char*) malloc(keyinfo->block_length)))
1900
1900
  {
1901
1901
    mi_check_print_error(param,"Not enough memory for key block");
1902
1902
    return(-1);
1939
1939
    mi_check_print_error(param,"Can't write indexblock, error: %d",my_errno);
1940
1940
    goto err;
1941
1941
  }
1942
 
  my_afree((unsigned char*) buff);
 
1942
  free(buff);
1943
1943
  return(0);
1944
1944
err:
1945
 
  my_afree((unsigned char*) buff);
 
1945
  free(buff);
1946
1946
  return(1);
1947
1947
} /* sort_one_index */
1948
1948
 
3695
3695
  share= *(*org_info)->s;
3696
3696
  unpack= (share.options & HA_OPTION_COMPRESS_RECORD) &&
3697
3697
    (param->testflag & T_UNPACK);
3698
 
  if (!(keyinfo=(MI_KEYDEF*) my_alloca(sizeof(MI_KEYDEF)*share.base.keys)))
 
3698
  if (!(keyinfo=(MI_KEYDEF*) malloc(sizeof(MI_KEYDEF)*share.base.keys)))
3699
3699
    return(0);
3700
3700
  memcpy(keyinfo,share.keyinfo,sizeof(MI_KEYDEF)*share.base.keys);
3701
3701
 
3702
3702
  key_parts= share.base.all_key_parts;
3703
 
  if (!(keysegs=(HA_KEYSEG*) my_alloca(sizeof(HA_KEYSEG)*
3704
 
                                       (key_parts+share.base.keys))))
 
3703
  if (!(keysegs=(HA_KEYSEG*) malloc(sizeof(HA_KEYSEG)*
 
3704
                                    (key_parts+share.base.keys))))
3705
3705
  {
3706
 
    my_afree((unsigned char*) keyinfo);
 
3706
    free(keyinfo);
3707
3707
    return(1);
3708
3708
  }
3709
3709
  if (!(recdef=(MI_COLUMNDEF*)
3710
 
        my_alloca(sizeof(MI_COLUMNDEF)*(share.base.fields+1))))
 
3710
        malloc(sizeof(MI_COLUMNDEF)*(share.base.fields+1))))
3711
3711
  {
3712
 
    my_afree((unsigned char*) keyinfo);
3713
 
    my_afree((unsigned char*) keysegs);
 
3712
    free(keyinfo);
 
3713
    free(keysegs);
3714
3714
    return(1);
3715
3715
  }
3716
3716
  if (!(uniquedef=(MI_UNIQUEDEF*)
3717
 
        my_alloca(sizeof(MI_UNIQUEDEF)*(share.state.header.uniques+1))))
 
3717
        malloc(sizeof(MI_UNIQUEDEF)*(share.state.header.uniques+1))))
3718
3718
  {
3719
 
    my_afree((unsigned char*) recdef);
3720
 
    my_afree((unsigned char*) keyinfo);
3721
 
    my_afree((unsigned char*) keysegs);
 
3719
    free(recdef);
 
3720
    free(keyinfo);
 
3721
    free(keysegs);
3722
3722
    return(1);
3723
3723
  }
3724
3724
 
3833
3833
    goto end;
3834
3834
  error=0;
3835
3835
end:
3836
 
  my_afree((unsigned char*) uniquedef);
3837
 
  my_afree((unsigned char*) keyinfo);
3838
 
  my_afree((unsigned char*) recdef);
3839
 
  my_afree((unsigned char*) keysegs);
 
3836
  free(uniquedef);
 
3837
  free(keyinfo);
 
3838
  free(recdef);
 
3839
  free(keysegs);
3840
3840
  return(error);
3841
3841
}
3842
3842