← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

  • 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:
drizzled/sql_string.cc
91
91
 
92
92
bool String::set_int(int64_t num, bool unsigned_flag, const CHARSET_INFO * const cs)
93
93
{
94
 
  uint l=20*cs->mbmaxlen+1;
 
94
  uint32_t l=20*cs->mbmaxlen+1;
95
95
  int base= unsigned_flag ? 10 : -10;
96
96
 
97
97
  if (alloc(l))
101
101
  return false;
102
102
}
103
103
 
104
 
bool String::set_real(double num,uint decimals, const CHARSET_INFO * const cs)
 
104
bool String::set_real(double num,uint32_t decimals, const CHARSET_INFO * const cs)
105
105
{
106
106
  char buff[FLOATING_POINT_BUFFER];
107
 
  uint dummy_errors;
 
107
  uint32_t dummy_errors;
108
108
  size_t len;
109
109
 
110
110
  str_charset=cs;
260
260
 
261
261
bool String::copy(const char *str, uint32_t arg_length,
262
262
                          const CHARSET_INFO * const from_cs,
263
 
                                  const CHARSET_INFO * const to_cs, uint *errors)
 
263
                                  const CHARSET_INFO * const to_cs, uint32_t *errors)
264
264
{
265
265
  uint32_t offset;
266
266
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
309
309
    set(str, arg_length, str_charset);
310
310
    return 0;
311
311
  }
312
 
  uint dummy_errors;
 
312
  uint32_t dummy_errors;
313
313
  return copy(str, arg_length, &my_charset_utf8_general_ci, str_charset, &dummy_errors);
314
314
}
315
315
 
358
358
  if (str_charset->mbminlen > 1)
359
359
  {
360
360
    uint32_t add_length=arg_length * str_charset->mbmaxlen;
361
 
    uint dummy_errors;
 
361
    uint32_t dummy_errors;
362
362
    if (realloc(str_length+ add_length))
363
363
      return true;
364
364
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
400
400
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
401
401
  {
402
402
    uint32_t add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
403
 
    uint dummy_errors;
 
403
    uint32_t dummy_errors;
404
404
    if (realloc(str_length + add_length)) 
405
405
      return true;
406
406
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
595
595
  str_length+= (int) (end-buff);
596
596
}
597
597
 
598
 
void String::qs_append(uint i)
 
598
void String::qs_append(uint32_t i)
599
599
{
600
600
  char *buff= Ptr + str_length;
601
601
  char *end= int10_to_str(i, buff, 10);
701
701
                          const CHARSET_INFO * const to_cs, 
702
702
                          const char *from, uint32_t from_length,
703
703
                          const CHARSET_INFO * const from_cs,
704
 
                          uint *errors)
 
704
                          uint32_t *errors)
705
705
{
706
706
  int         cnvres;
707
707
  my_wc_t     wc;
710
710
  unsigned char *to_end= (unsigned char*) to+to_length;
711
711
  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
712
712
  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
713
 
  uint error_count= 0;
 
713
  uint32_t error_count= 0;
714
714
 
715
715
  while (1)
716
716
  {
759
759
uint32_t
760
760
copy_and_convert(char *to, uint32_t to_length, const CHARSET_INFO * const to_cs, 
761
761
                 const char *from, uint32_t from_length,
762
 
                                 const CHARSET_INFO * const from_cs, uint *errors)
 
762
                                 const CHARSET_INFO * const from_cs, uint32_t *errors)
763
763
{
764
764
  /*
765
765
    If any of the character sets is not ASCII compatible,
903
903
 
904
904
uint32_t
905
905
well_formed_copy_nchars(const CHARSET_INFO * const to_cs,
906
 
                        char *to, uint to_length,
 
906
                        char *to, uint32_t to_length,
907
907
                        const CHARSET_INFO * const from_cs,
908
 
                        const char *from, uint from_length,
909
 
                        uint nchars,
 
908
                        const char *from, uint32_t from_length,
 
909
                        uint32_t nchars,
910
910
                        const char **well_formed_error_pos,
911
911
                        const char **cannot_convert_error_pos,
912
912
                        const char **from_end_pos)
913
913
{
914
 
  uint res;
 
914
  uint32_t res;
915
915
 
916
916
  if ((to_cs == &my_charset_bin) || 
917
917
      (from_cs == &my_charset_bin) ||
937
937
    else
938
938
    {
939
939
      int well_formed_error;
940
 
      uint from_offset;
 
940
      uint32_t from_offset;
941
941
 
942
942
      if ((from_offset= (from_length % to_cs->mbminlen)) &&
943
943
          (from_cs == &my_charset_bin))
947
947
          INSERT INTO t1 (ucs2_column) VALUES (0x01);
948
948
          0x01 -> 0x0001
949
949
        */
950
 
        uint pad_length= to_cs->mbminlen - from_offset;
 
950
        uint32_t pad_length= to_cs->mbminlen - from_offset;
951
951
        memset(to, 0, pad_length);
952
952
        memmove(to + pad_length, from, from_offset);
953
953
        nchars--;