← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item_strfunc.cc

  • Committer: Brian Aker
  • Date: 2008-07-22 18:31:32 UTC
  • Revision ID: brian@tangent.org-20080722183132-ne2ntl7g7mdf2eez
uint32 -> uin32_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/item_strfunc.cc
223
223
          now work in place in tmp_value to set it to res | res2
224
224
        */
225
225
        /* Chop the last characters in tmp_value that isn't in res2 */
226
 
        tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
 
226
        tmp_value.length((uint32_t) (res2->ptr() - tmp_value.ptr()) +
227
227
                         res2->length());
228
228
        /* Place res2 at start of tmp_value, remove chars before res2 */
229
 
        if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
 
229
        if (tmp_value.replace(0,(uint32_t) (res2->ptr() - tmp_value.ptr()),
230
230
                              *res))
231
231
          goto null;
232
232
        res= &tmp_value;
392
392
        now work in place in tmp_value to set it to res | sep_str | res2
393
393
      */
394
394
      /* Chop the last characters in tmp_value that isn't in res2 */
395
 
      tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
 
395
      tmp_value.length((uint32_t) (res2->ptr() - tmp_value.ptr()) +
396
396
                       res2->length());
397
397
      /* Place res2 at start of tmp_value, remove chars before res2 */
398
 
      if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
 
398
      if (tmp_value.replace(0,(uint32_t) (res2->ptr() - tmp_value.ptr()),
399
399
                            *res) ||
400
400
          tmp_value.replace(res->length(),0, *sep_str))
401
401
        goto null;
497
497
#ifdef USE_MB
498
498
  if (use_mb(res->charset()))
499
499
  {
500
 
    register uint32 l;
 
500
    register uint32_t l;
501
501
    while (ptr < end)
502
502
    {
503
503
      if ((l= my_ismbchar(res->charset(),ptr,end)))
544
544
  bool alloced=0;
545
545
#ifdef USE_MB
546
546
  const char *ptr,*end,*strend,*search,*search_end;
547
 
  register uint32 l;
 
547
  register uint32_t l;
548
548
  bool binary_cmp;
549
549
#endif
550
550
 
694
694
 
695
695
  /* start and length are now sufficiently valid to pass to charpos function */
696
696
   start= res->charpos((int) start);
697
 
   length= res->charpos((int) length, (uint32) start);
 
697
   length= res->charpos((int) length, (uint32_t) start);
698
698
 
699
699
  /* Re-testing with corrected params */
700
700
  if (start > res->length())
712
712
    goto null;
713
713
  }
714
714
  res=copy_if_not_alloced(str,res,res->length());
715
 
  res->replace((uint32) start,(uint32) length,*res2);
 
715
  res->replace((uint32_t) start,(uint32_t) length,*res2);
716
716
  return res;
717
717
null:
718
718
  null_value=1;
903
903
  if ((start < 0) || ((uint) start + 1 > res->length()))
904
904
    return &my_empty_string;
905
905
 
906
 
  length= res->charpos((int) length, (uint32) start);
 
906
  length= res->charpos((int) length, (uint32_t) start);
907
907
  tmp_length= res->length() - start;
908
908
  length= min(length, tmp_length);
909
909
 
910
910
  if (!start && (int64_t) res->length() == length)
911
911
    return res;
912
 
  tmp_value.set(*res, (uint32) start, (uint32) length);
 
912
  tmp_value.set(*res, (uint32_t) start, (uint32_t) length);
913
913
  return &tmp_value;
914
914
}
915
915
 
921
921
  collation.set(args[0]->collation);
922
922
  if (args[1]->const_item())
923
923
  {
924
 
    int32 start= (int32) args[1]->val_int();
 
924
    int32_t start= (int32_t) args[1]->val_int();
925
925
    if (start < 0)
926
926
      max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
927
927
    else
929
929
  }
930
930
  if (arg_count == 3 && args[2]->const_item())
931
931
  {
932
 
    int32 length= (int32) args[2]->val_int();
 
932
    int32_t length= (int32_t) args[2]->val_int();
933
933
    if (length <= 0)
934
934
      max_length=0; /* purecov: inspected */
935
935
    else
953
953
  assert(fixed == 1);
954
954
  String *res= args[0]->val_str(str);
955
955
  String *delimiter= args[1]->val_str(&tmp_value);
956
 
  int32 count= (int32) args[2]->val_int();
 
956
  int32_t count= (int32_t) args[2]->val_int();
957
957
  uint offset;
958
958
 
959
959
  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
976
976
    const char *end= strend-delimiter_length+1;
977
977
    const char *search= delimiter->ptr();
978
978
    const char *search_end= search+delimiter_length;
979
 
    int32 n=0,c=count,pass;
980
 
    register uint32 l;
 
979
    int32_t n=0,c=count,pass;
 
980
    register uint32_t l;
981
981
    for (pass=(count>0);pass<2;++pass)
982
982
    {
983
983
      while (ptr < end)
1151
1151
  end= ptr+res->length();
1152
1152
#ifdef USE_MB
1153
1153
  char *p=ptr;
1154
 
  register uint32 l;
 
1154
  register uint32_t l;
1155
1155
#endif
1156
1156
  if (remove_length == 1)
1157
1157
  {
1237
1237
  if (use_mb(res->charset()))
1238
1238
  {
1239
1239
    char *p=ptr;
1240
 
    register uint32 l;
 
1240
    register uint32_t l;
1241
1241
 loop:
1242
1242
    while (ptr + remove_length < end)
1243
1243
    {
1549
1549
 
1550
1550
String *Item_func_format::val_str(String *str)
1551
1551
{
1552
 
  uint32 length;
1553
 
  uint32 str_length;
 
1552
  uint32_t length;
 
1553
  uint32_t str_length;
1554
1554
  /* Number of decimal digits */
1555
1555
  int dec;
1556
1556
  /* Number of characters used to represent the decimals, including '.' */
1557
 
  uint32 dec_length;
 
1557
  uint32_t dec_length;
1558
1558
  int diff;
1559
1559
  assert(fixed == 1);
1560
1560
 
1817
1817
  str->set_charset(collation.collation);
1818
1818
  for (uint i=0 ; i < arg_count ; i++)
1819
1819
  {
1820
 
    int32 num=(int32) args[i]->val_int();
 
1820
    int32_t num=(int32_t) args[i]->val_int();
1821
1821
    if (!args[i]->null_value)
1822
1822
    {
1823
1823
      char char_num= (char) num;
1982
1982
String *Item_func_rpad::val_str(String *str)
1983
1983
{
1984
1984
  assert(fixed == 1);
1985
 
  uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
 
1985
  uint32_t res_byte_length,res_char_length,pad_char_length,pad_byte_length;
1986
1986
  char *to;
1987
1987
  const char *ptr_pad;
1988
1988
  /* must be int64_t to avoid truncation */
2025
2025
  ptr_pad=rpad->ptr();
2026
2026
  pad_byte_length= rpad->length();
2027
2027
  count-= res_char_length;
2028
 
  for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
 
2028
  for ( ; (uint32_t) count > pad_char_length; count-= pad_char_length)
2029
2029
  {
2030
2030
    memcpy(to,ptr_pad,pad_byte_length);
2031
2031
    to+= pad_byte_length;
2085
2085
String *Item_func_lpad::val_str(String *str)
2086
2086
{
2087
2087
  assert(fixed == 1);
2088
 
  uint32 res_char_length,pad_char_length;
 
2088
  uint32_t res_char_length,pad_char_length;
2089
2089
  /* must be int64_t to avoid truncation */
2090
2090
  int64_t count= args[1]->val_int();
2091
2091
  int64_t byte_count;
2122
2122
  }
2123
2123
 
2124
2124
  if (args[2]->null_value || !pad_char_length ||
2125
 
      str->alloc((uint32) byte_count))
 
2125
      str->alloc((uint32_t) byte_count))
2126
2126
    goto err;
2127
2127
  
2128
2128
  str->length(0);
2174
2174
                                 from_base, &endptr, &err);
2175
2175
 
2176
2176
  ptr= int64_t2str(dec, ans, to_base);
2177
 
  if (str->copy(ans, (uint32) (ptr-ans), default_charset()))
 
2177
  if (str->copy(ans, (uint32_t) (ptr-ans), default_charset()))
2178
2178
    return &my_empty_string;
2179
2179
  return str;
2180
2180
}
2378
2378
    if ((null_value= args[0]->null_value))
2379
2379
      return 0;
2380
2380
    ptr= int64_t2str(dec,ans,16);
2381
 
    if (str->copy(ans,(uint32) (ptr-ans),default_charset()))
 
2381
    if (str->copy(ans,(uint32_t) (ptr-ans),default_charset()))
2382
2382
      return &my_empty_string;                  // End of memory
2383
2383
    return str;
2384
2384
  }
2749
2749
  new_size= res->length() + res->length() / 5 + 12;
2750
2750
 
2751
2751
  // Check new_size overflow: new_size <= res->length()
2752
 
  if (((uint32) (new_size+5) <= res->length()) || 
2753
 
      buffer.realloc((uint32) new_size + 4 + 1))
 
2752
  if (((uint32_t) (new_size+5) <= res->length()) || 
 
2753
      buffer.realloc((uint32_t) new_size + 4 + 1))
2754
2754
  {
2755
2755
    null_value= 1;
2756
2756
    return 0;
2779
2779
    new_size++;
2780
2780
  }
2781
2781
 
2782
 
  buffer.length((uint32)new_size + 4);
 
2782
  buffer.length((uint32_t)new_size + 4);
2783
2783
  return &buffer;
2784
2784
}
2785
2785
 
2817
2817
                        current_thd->variables.max_allowed_packet);
2818
2818
    goto err;
2819
2819
  }
2820
 
  if (buffer.realloc((uint32)new_size))
 
2820
  if (buffer.realloc((uint32_t)new_size))
2821
2821
    goto err;
2822
2822
 
2823
2823
  if ((err= uncompress((Byte*)buffer.ptr(), &new_size,
2824
2824
                       ((const Bytef*)res->ptr())+4,res->length())) == Z_OK)
2825
2825
  {
2826
 
    buffer.length((uint32) new_size);
 
2826
    buffer.length((uint32_t) new_size);
2827
2827
    return &buffer;
2828
2828
  }
2829
2829
 
2934
2934
  uuid_time=tv;
2935
2935
  pthread_mutex_unlock(&LOCK_uuid_generator);
2936
2936
 
2937
 
  uint32 time_low=            (uint32) (tv & 0xFFFFFFFF);
 
2937
  uint32_t time_low=            (uint32_t) (tv & 0xFFFFFFFF);
2938
2938
  uint16 time_mid=            (uint16) ((tv >> 32) & 0xFFFF);
2939
2939
  uint16 time_hi_and_version= (uint16) ((tv >> 48) | UUID_VERSION);
2940
2940