bk commit into 5.0 tree (iggy:1.2531)

[Ignacio Galarza]

Below is the list of changes that have just been committed into a local
5.0 repository of iggy. When iggy does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-10-11 10:09:34-04:00, iggy@amd64.(none) +12 -0
  Use size_t instead of uint for string leengths

  sql/item.cc@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +6 -6
    Use size_t instead of uint for string leengths

  sql/item.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +16 -16
    Use size_t instead of uint for string leengths

  sql/item_func.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +2 -2
    Use size_t instead of uint for string leengths

  sql/item_strfunc.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +1 -1
    Use size_t instead of uint for string leengths

  sql/item_sum.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +1 -1
    Use size_t instead of uint for string leengths

  sql/item_timefunc.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +1 -1
    Use size_t instead of uint for string leengths

  sql/my_decimal.cc@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +1 -1
    Use size_t instead of uint for string leengths

  sql/my_decimal.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +1 -1
    Use size_t instead of uint for string leengths

  sql/protocol.cc@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +6 -6
    Use size_t instead of uint for string leengths

  sql/protocol.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +7 -7
    Use size_t instead of uint for string leengths

  sql/sql_string.cc@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +26 -26
    Use size_t instead of uint for string leengths

  sql/sql_string.h@stripped, 2007-10-11 10:09:32-04:00, iggy@amd64.(none) +45 -45
    Use size_t instead of uint for string leengths

diff -Nrup a/sql/item.cc b/sql/item.cc
--- a/sql/item.cc	2007-10-05 06:08:36 -04:00
+++ b/sql/item.cc	2007-10-11 10:09:32 -04:00
@@ -679,7 +679,7 @@ bool Item::check_cols(uint c)
 }
 
 
-void Item::set_name(const char *str, uint length, CHARSET_INFO *cs)
+void Item::set_name(const char *str,size_t length, CHARSET_INFO *cs)
 {
   if (!length)
   {
@@ -951,7 +951,7 @@ int Item::save_in_field_no_warnings(Fiel
 *****************************************************************************/
 
 Item_sp_variable::Item_sp_variable(char *sp_var_name_str,
-                                   uint sp_var_name_length)
+                                   size_t sp_var_name_length)
   :m_thd(0)
 #ifndef DBUG_OFF
    , m_sp(0)
@@ -2080,7 +2080,7 @@ void Item_int::print(String *str)
 }
 
 
-Item_uint::Item_uint(const char *str_arg, uint length):
+Item_uint::Item_uint(const char *str_arg, size_t length):
   Item_int(str_arg, length)
 {
   unsigned_flag= 1;
@@ -2143,7 +2143,7 @@ Item_decimal::Item_decimal(double val, i
 
 
 Item_decimal::Item_decimal(const char *str, const my_decimal *val_arg,
-                           uint decimal_par, uint length)
+                           uint decimal_par, size_t length)
 {
   my_decimal2decimal(val_arg, &decimal_value);
   name= (char*) str;
@@ -2410,7 +2410,7 @@ void Item_param::set_null()
   DBUG_VOID_RETURN;
 }
 
-void Item_param::set_int(longlong i, uint32 max_length_arg)
+void Item_param::set_int(longlong i, size_t max_length_arg)
 {
   DBUG_ENTER("Item_param::set_int");
   value.integer= (longlong) i;
@@ -2479,7 +2479,7 @@ void Item_param::set_decimal(const char 
     MAX_DATE_STRING_REP_LENGTH buffer.
 */
 void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
-                          uint32 max_length_arg)
+                          size_t max_length_arg)
 { 
   DBUG_ENTER("Item_param::set_time");
 
diff -Nrup a/sql/item.h b/sql/item.h
--- a/sql/item.h	2007-08-03 12:59:12 -04:00
+++ b/sql/item.h	2007-10-11 10:09:32 -04:00
@@ -471,8 +471,8 @@ public:
   /* Original item name (if it was renamed)*/
   my_string orig_name;
   Item *next;
-  uint32 max_length;
-  uint name_length;                     /* Length of name */
+  size_t max_length;
+  size_t name_length;                     /* Length of name */
   int8 marker;
   uint8 decimals;
   my_bool maybe_null;			/* If item may be null */
@@ -504,7 +504,7 @@ public:
     name=0;
 #endif
   }		/*lint -e1509 */
-  void set_name(const char *str, uint length, CHARSET_INFO *cs);
+  void set_name(const char *str, size_t length, CHARSET_INFO *cs);
   void rename(char *new_name);
   void init_make_field(Send_field *tmp_field,enum enum_field_types type);
   virtual void cleanup();
@@ -905,7 +905,7 @@ public:
 #endif
 
 public:
-  Item_sp_variable(char *sp_var_name_str, uint sp_var_name_length);
+  Item_sp_variable(char *sp_var_name_str, size_t sp_var_name_length);
 
 public:
   bool fix_fields(THD *thd, Item **);
@@ -934,7 +934,7 @@ inline void Item_sp_variable::make_field
   Item *it= this_item();
 
   if (name)
-    it->set_name(name, (uint) strlen(name), system_charset_info);
+    it->set_name(name, strlen(name), system_charset_info);
   else
     it->set_name(m_name.str, m_name.length, system_charset_info);
   it->make_field(field);
@@ -1477,12 +1477,12 @@ public:
   int  save_in_field(Field *field, bool no_conversions);
 
   void set_null();
-  void set_int(longlong i, uint32 max_length_arg);
+  void set_int(longlong i, size_t max_length_arg);
   void set_double(double i);
   void set_decimal(const char *str, ulong length);
   bool set_str(const char *str, ulong length);
   bool set_longdata(const char *str, ulong length);
-  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
+  void set_time(MYSQL_TIME *tm, timestamp_type type, size_t max_length_arg);
   bool set_from_user_var(THD *thd, const user_var_entry *entry);
   void reset();
   /*
@@ -1547,7 +1547,7 @@ public:
   Item_int(ulonglong i, uint length= MY_INT64_NUM_DECIMAL_DIGITS)
     :value((longlong)i)
     { max_length=length; fixed= 1; unsigned_flag= 1; }
-  Item_int(const char *str_arg,longlong i,uint length) :value(i)
+  Item_int(const char *str_arg,longlong i,size_t length) :value(i)
     { max_length=length; name=(char*) str_arg; fixed= 1; }
   Item_int(const char *str_arg, uint length=64);
   enum Type type() const { return INT_ITEM; }
@@ -1573,7 +1573,7 @@ public:
 class Item_uint :public Item_int
 {
 public:
-  Item_uint(const char *str_arg, uint length);
+  Item_uint(const char *str_arg, size_t length);
   Item_uint(ulonglong i) :Item_int((ulonglong) i, 10) {}
   Item_uint(const char *str_arg, longlong i, uint length);
   double val_real()
@@ -1583,7 +1583,7 @@ public:
   int save_in_field(Field *field, bool no_conversions);
   void print(String *str);
   Item_num *neg ();
-  uint decimal_precision() const { return max_length; }
+  uint decimal_precision() const { return (uint) max_length; }
 };
 
 
@@ -1595,7 +1595,7 @@ protected:
 public:
   Item_decimal(const char *str_arg, uint length, CHARSET_INFO *charset);
   Item_decimal(const char *str, const my_decimal *val_arg,
-               uint decimal_par, uint length);
+               uint decimal_par, size_t length);
   Item_decimal(my_decimal *value_par);
   Item_decimal(longlong val, bool unsig);
   Item_decimal(double val, int precision, int scale);
@@ -1636,7 +1636,7 @@ public:
   double value;
   // Item_real() :value(0) {}
   Item_float(const char *str_arg, uint length);
-  Item_float(const char *str,double val_arg,uint decimal_par,uint length)
+  Item_float(const char *str,double val_arg,uint decimal_par,size_t length)
     :value(val_arg)
   {
     presentation= name=(char*) str;
@@ -1720,7 +1720,7 @@ public:
     decimals= NOT_FIXED_DEC;
     fixed= 1;
   }
-  Item_string(const char *name_par, const char *str, uint length,
+  Item_string(const char *name_par, const char *str, size_t length,
               CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
               uint repertoire= MY_REPERTOIRE_UNICODE30)
   {
@@ -1745,7 +1745,7 @@ public:
   {
     collation.repertoire= my_string_repertoire(str_value.charset(),
                                                str_value.ptr(),
-                                               str_value.length());
+                                               (ulong) str_value.length());
   }
   enum Type type() const { return STRING_ITEM; }
   double val_real();
@@ -2192,13 +2192,13 @@ public:
     char *end_not_used;
     return (null_value ? 0.0 :
 	    my_strntod(str_value.charset(), (char*) str_value.ptr(),
-		       str_value.length(), &end_not_used, &err_not_used));
+		       (uint) str_value.length(), &end_not_used, &err_not_used));
   }
   longlong val_int()
   {
     int err;
     return null_value ? LL(0) : my_strntoll(str_value.charset(),str_value.ptr(),
-                                            str_value.length(),10, (char**) 0,
+                                            (uint) str_value.length(),10, (char**) 0,
                                             &err); 
   }
   String *val_str(String*);
diff -Nrup a/sql/item_func.h b/sql/item_func.h
--- a/sql/item_func.h	2007-07-19 09:38:47 -04:00
+++ b/sql/item_func.h	2007-10-11 10:09:32 -04:00
@@ -1062,13 +1062,13 @@ public:
     String *res;
     res= val_str(&str_value);
     return res ? my_strntod(res->charset(),(char*) res->ptr(), 
-                            res->length(), &end_not_used, &err_not_used) :
0.0;
+                            (uint) res->length(), &end_not_used,
&err_not_used) : 0.0;
   }
   longlong val_int()
   {
     int err_not_used;
     String *res;  res=val_str(&str_value);
-    return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10,
+    return res ? my_strntoll(res->charset(),res->ptr(),(uint)res->length(),10,
                              (char**) 0, &err_not_used) : (longlong) 0;
   }
   my_decimal *val_decimal(my_decimal *dec_buf)
diff -Nrup a/sql/item_strfunc.h b/sql/item_strfunc.h
--- a/sql/item_strfunc.h	2007-07-27 09:42:24 -04:00
+++ b/sql/item_strfunc.h	2007-10-11 10:09:32 -04:00
@@ -516,7 +516,7 @@ public:
   void fix_length_and_dec()
   {
     collation.set(default_charset());
-    uint char_length=
args[0]->max_length/args[0]->collation.collation->mbmaxlen;
+    size_t char_length=
args[0]->max_length/args[0]->collation.collation->mbmaxlen;
     max_length= ((char_length + (char_length-args[0]->decimals)/3) *
                  collation.collation->mbmaxlen);
   }
diff -Nrup a/sql/item_sum.h b/sql/item_sum.h
--- a/sql/item_sum.h	2007-06-29 03:39:15 -04:00
+++ b/sql/item_sum.h	2007-10-11 10:09:32 -04:00
@@ -1046,7 +1046,7 @@ public:
     char *end_not_used;
     String *res;
     res=val_str(&str_value);
-    return res ? my_strntod(res->charset(),(char*) res->ptr(),res->length(),
+    return res ? my_strntod(res->charset(),(char*) res->ptr(),(uint)
res->length(),
 			    &end_not_used, &err_not_used) : 0.0;
   }
   longlong val_int()
diff -Nrup a/sql/item_timefunc.h b/sql/item_timefunc.h
--- a/sql/item_timefunc.h	2007-10-09 05:37:19 -04:00
+++ b/sql/item_timefunc.h	2007-10-11 10:09:32 -04:00
@@ -922,7 +922,7 @@ public:
       return (new Field_time(maybe_null, name, t_arg, &my_charset_bin));
     else if (cached_field_type == MYSQL_TYPE_DATETIME)
       return (new Field_datetime(maybe_null, name, t_arg, &my_charset_bin));
-    return (new Field_string(max_length, maybe_null, name, t_arg, &my_charset_bin));
+    return (new Field_string((uint32)max_length, maybe_null, name, t_arg,
&my_charset_bin));
   }
   void print(String *str);
   const char *func_name() const { return "add_time"; }
diff -Nrup a/sql/my_decimal.cc b/sql/my_decimal.cc
--- a/sql/my_decimal.cc	2007-10-05 03:38:55 -04:00
+++ b/sql/my_decimal.cc	2007-10-11 10:09:32 -04:00
@@ -176,7 +176,7 @@ int my_decimal2binary(uint mask, const m
     E_DEC_OOM
 */
 
-int str2my_decimal(uint mask, const char *from, uint length,
+int str2my_decimal(uint mask, const char *from, size_t length,
                    CHARSET_INFO *charset, my_decimal *decimal_value)
 {
   char *end, *from_end;
diff -Nrup a/sql/my_decimal.h b/sql/my_decimal.h
--- a/sql/my_decimal.h	2007-05-27 18:05:33 -04:00
+++ b/sql/my_decimal.h	2007-10-11 10:09:32 -04:00
@@ -289,7 +289,7 @@ int str2my_decimal(uint mask, const char
 }
 
 
-int str2my_decimal(uint mask, const char *from, uint length,
+int str2my_decimal(uint mask, const char *from, size_t length,
                    CHARSET_INFO *charset, my_decimal *decimal_value);
 
 #if defined(MYSQL_SERVER) || defined(EMBEDDED_LIBRARY)
diff -Nrup a/sql/protocol.cc b/sql/protocol.cc
--- a/sql/protocol.cc	2007-05-16 04:44:41 -04:00
+++ b/sql/protocol.cc	2007-10-11 10:09:32 -04:00
@@ -305,7 +305,7 @@ send_ok(THD *thd, ha_rows affected_rows,
     pos+=2;
   }
   if (message)
-    pos=net_store_data((char*) pos, message, strlen(message));
+    pos=net_store_data((char*) pos, message, (uint) strlen(message));
   VOID(my_net_write(net,buff,(uint) (pos-buff)));
   VOID(net_flush(net));
   /* We can't anymore send an error to the client */
@@ -799,7 +799,7 @@ bool Protocol::store_string_aux(const ch
 }
 
 
-bool Protocol_simple::store(const char *from, uint length,
+bool Protocol_simple::store(const char *from, size_t length,
 			    CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
 {
 #ifndef DBUG_OFF
@@ -815,7 +815,7 @@ bool Protocol_simple::store(const char *
 }
 
 
-bool Protocol_simple::store(const char *from, uint length,
+bool Protocol_simple::store(const char *from,size_t length,
 			    CHARSET_INFO *fromcs)
 {
   CHARSET_INFO *tocs= this->thd->variables.character_set_results;
@@ -1007,7 +1007,7 @@ bool Protocol_simple::store_time(MYSQL_T
 			   (int) tm->second));
   if (tm->second_part)
     length+= my_sprintf(buff+length,(buff+length, ".%06d", (int)tm->second_part));
-  return net_store_data((char*) buff, length);
+  return net_store_data((char*) buff, (uint) length);
 }
 
 
@@ -1049,14 +1049,14 @@ void Protocol_prep::prepare_for_resend()
 }
 
 
-bool Protocol_prep::store(const char *from, uint length, CHARSET_INFO *fromcs)
+bool Protocol_prep::store(const char *from, size_t length, CHARSET_INFO *fromcs)
 {
   CHARSET_INFO *tocs= thd->variables.character_set_results;
   field_pos++;
   return store_string_aux(from, length, fromcs, tocs);
 }
 
-bool Protocol_prep::store(const char *from,uint length,
+bool Protocol_prep::store(const char *from,size_t length,
 			  CHARSET_INFO *fromcs, CHARSET_INFO *tocs)
 {
   field_pos++;
diff -Nrup a/sql/protocol.h b/sql/protocol.h
--- a/sql/protocol.h	2007-05-16 04:44:41 -04:00
+++ b/sql/protocol.h	2007-10-11 10:09:32 -04:00
@@ -81,8 +81,8 @@ public:
   virtual bool store_long(longlong from)=0;
   virtual bool store_longlong(longlong from, bool unsigned_flag)=0;
   virtual bool store_decimal(const my_decimal *)=0;
-  virtual bool store(const char *from, uint length, CHARSET_INFO *cs)=0;
-  virtual bool store(const char *from, uint length, 
+  virtual bool store(const char *from, size_t length, CHARSET_INFO *cs)=0;
+  virtual bool store(const char *from, size_t length, 
   		     CHARSET_INFO *fromcs, CHARSET_INFO *tocs)=0;
   virtual bool store(float from, uint32 decimals, String *buffer)=0;
   virtual bool store(double from, uint32 decimals, String *buffer)=0;
@@ -113,8 +113,8 @@ public:
   virtual bool store_long(longlong from);
   virtual bool store_longlong(longlong from, bool unsigned_flag);
   virtual bool store_decimal(const my_decimal *);
-  virtual bool store(const char *from, uint length, CHARSET_INFO *cs);
-  virtual bool store(const char *from, uint length,
+  virtual bool store(const char *from, size_t length, CHARSET_INFO *cs);
+  virtual bool store(const char *from, size_t length,
   		     CHARSET_INFO *fromcs, CHARSET_INFO *tocs);
   virtual bool store(MYSQL_TIME *time);
   virtual bool store_date(MYSQL_TIME *time);
@@ -147,8 +147,8 @@ public:
   virtual bool store_long(longlong from);
   virtual bool store_longlong(longlong from, bool unsigned_flag);
   virtual bool store_decimal(const my_decimal *);
-  virtual bool store(const char *from,uint length, CHARSET_INFO *cs);
-  virtual bool store(const char *from, uint length,
+  virtual bool store(const char *from,size_t length, CHARSET_INFO *cs);
+  virtual bool store(const char *from,size_t length,
   		     CHARSET_INFO *fromcs, CHARSET_INFO *tocs);
   virtual bool store(MYSQL_TIME *time);
   virtual bool store_date(MYSQL_TIME *time);
@@ -165,7 +165,7 @@ void send_ok(THD *thd, ha_rows affected_
 	     const char *info=0);
 void send_eof(THD *thd);
 bool send_old_password_request(THD *thd);
-char *net_store_data(char *to,const char *from, uint length);
+char *net_store_data(char *to,const char *from,uint length);
 char *net_store_data(char *to,int32 from);
 char *net_store_data(char *to,longlong from);
 
diff -Nrup a/sql/sql_string.cc b/sql/sql_string.cc
--- a/sql/sql_string.cc	2007-08-07 10:25:43 -04:00
+++ b/sql/sql_string.cc	2007-10-11 10:09:32 -04:00
@@ -41,7 +41,7 @@ extern void sql_element_free(void *ptr);
 ** String functions
 *****************************************************************************/
 
-bool String::real_alloc(uint32 arg_length)
+bool String::real_alloc(size_t arg_length)
 {
   arg_length=ALIGN_SIZE(arg_length+1);
   str_length=0;
@@ -63,9 +63,9 @@ bool String::real_alloc(uint32 arg_lengt
 ** (for C functions)
 */
 
-bool String::realloc(uint32 alloc_length)
+bool String::realloc(size_t alloc_length)
 {
-  uint32 len=ALIGN_SIZE(alloc_length+1);
+  size_t len=ALIGN_SIZE(alloc_length+1);
   if (Alloced_length < len)
   {
     char *new_ptr;
@@ -219,7 +219,7 @@ bool String::copy(const String &str)
   return FALSE;
 }
 
-bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
+bool String::copy(const char *str,size_t arg_length, CHARSET_INFO *cs)
 {
   if (alloc(arg_length))
     return TRUE;
@@ -253,7 +253,7 @@ bool String::copy(const char *str,uint32
   character_set_results is NULL.
 */
 
-bool String::needs_conversion(uint32 arg_length,
+bool String::needs_conversion(size_t arg_length,
 			      CHARSET_INFO *from_cs,
 			      CHARSET_INFO *to_cs,
 			      uint32 *offset)
@@ -295,7 +295,7 @@ bool String::needs_conversion(uint32 arg
     1  error
 */
 
-bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
+bool String::copy_aligned(const char *str,size_t arg_length, uint32 offset,
 			  CHARSET_INFO *cs)
 {
   /* How many bytes are in incomplete character */
@@ -321,7 +321,7 @@ bool String::copy_aligned(const char *st
 }
 
 
-bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
+bool String::set_or_copy_aligned(const char *str,size_t arg_length,
 				 CHARSET_INFO *cs)
 {
   /* How many bytes are in incomplete character */
@@ -337,7 +337,7 @@ bool String::set_or_copy_aligned(const c
 
 	/* Copy with charset convertion */
 
-bool String::copy(const char *str, uint32 arg_length,
+bool String::copy(const char *str, size_t arg_length,
 		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
 {
   uint32 offset;
@@ -380,7 +380,7 @@ bool String::copy(const char *str, uint3
 
 */
 
-bool String::set_ascii(const char *str, uint32 arg_length)
+bool String::set_ascii(const char *str, size_t arg_length)
 {
   if (str_charset->mbminlen == 1)
   {
@@ -394,7 +394,7 @@ bool String::set_ascii(const char *str, 
 
 /* This is used by mysql.cc */
 
-bool String::fill(uint32 max_length,char fill_char)
+bool String::fill(size_t max_length,char fill_char)
 {
   if (str_length > max_length)
     Ptr[str_length=max_length]=0;
@@ -431,7 +431,7 @@ bool String::append(const String &s)
   Append an ASCII string to the a string of the current character set
 */
 
-bool String::append(const char *s,uint32 arg_length)
+bool String::append(const char *s,size_t arg_length)
 {
   if (!arg_length)
     return FALSE;
@@ -477,7 +477,7 @@ bool String::append(const char *s)
   with character set recoding
 */
 
-bool String::append(const char *s,uint32 arg_length, CHARSET_INFO *cs)
+bool String::append(const char *s,size_t arg_length, CHARSET_INFO *cs)
 {
   uint32 dummy_offset;
   
@@ -502,7 +502,7 @@ bool String::append(const char *s,uint32
 
 
 #ifdef TO_BE_REMOVED
-bool String::append(FILE* file, uint32 arg_length, myf my_flags)
+bool String::append(FILE* file, size_t arg_length, myf my_flags)
 {
   if (realloc(str_length+arg_length))
     return TRUE;
@@ -516,7 +516,7 @@ bool String::append(FILE* file, uint32 a
 }
 #endif
 
-bool String::append(IO_CACHE* file, uint32 arg_length)
+bool String::append(IO_CACHE* file, size_t arg_length)
 {
   if (realloc(str_length+arg_length))
     return TRUE;
@@ -529,8 +529,8 @@ bool String::append(IO_CACHE* file, uint
   return FALSE;
 }
 
-bool String::append_with_prefill(const char *s,uint32 arg_length,
-		 uint32 full_length, char fill_char)
+bool String::append_with_prefill(const char *s,size_t arg_length,
+		 size_t full_length, char fill_char)
 {
   int t_length= arg_length > full_length ? arg_length : full_length;
 
@@ -546,7 +546,7 @@ bool String::append_with_prefill(const c
   return FALSE;
 }
 
-uint32 String::numchars()
+size_t String::numchars()
 {
   return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
 }
@@ -621,13 +621,13 @@ skip:
   If wrong parameter or not enough memory, do nothing
 */
 
-bool String::replace(uint32 offset,uint32 arg_length,const String &to)
+bool String::replace(uint32 offset,size_t arg_length,const String &to)
 {
   return replace(offset,arg_length,to.ptr(),to.length());
 }
 
-bool String::replace(uint32 offset,uint32 arg_length,
-                     const char *to, uint32 to_length)
+bool String::replace(uint32 offset,size_t arg_length,
+                     const char *to, size_t to_length)
 {
   long diff = (long) to_length-(long) arg_length;
   if (offset+arg_length <= str_length)
@@ -668,7 +668,7 @@ int String::reserve(uint32 space_needed,
   return FALSE;
 }
 
-void String::qs_append(const char *str, uint32 len)
+void String::qs_append(const char *str, size_t len)
 {
   memcpy(Ptr + str_length, str, len + 1);
   str_length += len;
@@ -754,7 +754,7 @@ int stringcmp(const String *s,const Stri
 }
 
 
-String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
+String *copy_if_not_alloced(String *to,String *from,size_t from_length)
 {
   if (from->Alloced_length >= from_length)
     return from;
@@ -796,8 +796,8 @@ String *copy_if_not_alloced(String *to,S
 
 
 uint32
-copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
-                 const char *from, uint32 from_length, CHARSET_INFO *from_cs,
+copy_and_convert(char *to, size_t to_length, CHARSET_INFO *to_cs, 
+                 const char *from, size_t from_length, CHARSET_INFO *from_cs,
                  uint *errors)
 {
   int         cnvres;
@@ -881,9 +881,9 @@ outp:
 
 uint32
 well_formed_copy_nchars(CHARSET_INFO *to_cs,
-                        char *to, uint to_length,
+                        char *to, size_t to_length,
                         CHARSET_INFO *from_cs,
-                        const char *from, uint from_length,
+                        const char *from, size_t from_length,
                         uint nchars,
                         const char **well_formed_error_pos,
                         const char **cannot_convert_error_pos,
diff -Nrup a/sql/sql_string.h b/sql/sql_string.h
--- a/sql/sql_string.h	2007-01-22 07:10:41 -05:00
+++ b/sql/sql_string.h	2007-10-11 10:09:32 -04:00
@@ -27,14 +27,14 @@
 
 class String;
 int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
-String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
-uint32 copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
-			const char *from, uint32 from_length,
+String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
+uint32 copy_and_convert(char *to, size_t to_length, CHARSET_INFO *to_cs,
+			const char *from, size_t from_length,
 			CHARSET_INFO *from_cs, uint *errors);
 uint32 well_formed_copy_nchars(CHARSET_INFO *to_cs,
-                               char *to, uint to_length,
+                               char *to, size_t to_length,
                                CHARSET_INFO *from_cs,
-                               const char *from, uint from_length,
+                               const char *from, size_t from_length,
                                uint nchars,
                                const char **well_formed_error_pos,
                                const char **cannot_convert_error_pos,
@@ -43,7 +43,7 @@ uint32 well_formed_copy_nchars(CHARSET_I
 class String
 {
   char *Ptr;
-  uint32 str_length,Alloced_length;
+  size_t str_length,Alloced_length;
   bool alloced;
   CHARSET_INFO *str_charset;
 public:
@@ -52,22 +52,22 @@ public:
     Ptr=0; str_length=Alloced_length=0; alloced=0; 
     str_charset= &my_charset_bin; 
   }
-  String(uint32 length_arg)
+  String(size_t length_arg)
   { 
     alloced=0; Alloced_length=0; (void) real_alloc(length_arg); 
     str_charset= &my_charset_bin;
   }
   String(const char *str, CHARSET_INFO *cs)
   { 
-    Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;
+    Ptr=(char*) str; str_length= strlen(str); Alloced_length=0; alloced=0;
     str_charset=cs;
   }
-  String(const char *str,uint32 len, CHARSET_INFO *cs)
+  String(const char *str,size_t len, CHARSET_INFO *cs)
   { 
     Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;
     str_charset=cs;
   }
-  String(char *str,uint32 len, CHARSET_INFO *cs)
+  String(char *str,size_t len, CHARSET_INFO *cs)
   { 
     Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;
     str_charset=cs;
@@ -89,10 +89,10 @@ public:
   inline void set_charset(CHARSET_INFO *charset_arg)
   { str_charset= charset_arg; }
   inline CHARSET_INFO *charset() const { return str_charset; }
-  inline uint32 length() const { return str_length;}
-  inline uint32 alloced_length() const { return Alloced_length;}
+  inline size_t length() const { return str_length;}
+  inline size_t alloced_length() const { return Alloced_length;}
   inline char& operator [] (uint32 i) const { return Ptr[i]; }
-  inline void length(uint32 len) { str_length=len ; }
+  inline void length(size_t len) { str_length=len ; }
   inline bool is_empty() { return (str_length == 0); }
   inline void mark_as_const() { Alloced_length= 0;}
   inline const char *ptr() const { return Ptr; }
@@ -117,7 +117,7 @@ public:
     return Ptr;
   }
 
-  void set(String &str,uint32 offset,uint32 arg_length)
+  void set(String &str,uint32 offset,size_t arg_length)
   {
     DBUG_ASSERT(&str != this);
     free();
@@ -128,20 +128,20 @@ public:
       Alloced_length=0;
     str_charset=str.str_charset;
   }
-  inline void set(char *str,uint32 arg_length, CHARSET_INFO *cs)
+  inline void set(char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     free();
     Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
     str_charset=cs;
   }
-  inline void set(const char *str,uint32 arg_length, CHARSET_INFO *cs)
+  inline void set(const char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     free();
     Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
     str_charset=cs;
   }
-  bool set_ascii(const char *str, uint32 arg_length);
-  inline void set_quick(char *str,uint32 arg_length, CHARSET_INFO *cs)
+  bool set_ascii(const char *str, size_t arg_length);
+  inline void set_quick(char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     if (!alloced)
     {
@@ -191,20 +191,20 @@ public:
       str_length=0;				/* Safety */
     }
   }
-  inline bool alloc(uint32 arg_length)
+  inline bool alloc(size_t arg_length)
   {
     if (arg_length < Alloced_length)
       return 0;
     return real_alloc(arg_length);
   }
-  bool real_alloc(uint32 arg_length);			// Empties old string
-  bool realloc(uint32 arg_length);
-  inline void shrink(uint32 arg_length)		// Shrink buffer
+  bool real_alloc(size_t arg_length);			// Empties old string
+  bool realloc(size_t arg_length);
+  inline void shrink(size_t arg_length)		// Shrink buffer
   {
     if (arg_length < Alloced_length)
     {
       char *new_ptr;
-      if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
+      if (!(new_ptr=(char*) my_realloc(Ptr,(uint) arg_length,MYF(0))))
       {
 	Alloced_length = 0;
 	real_alloc(arg_length);
@@ -235,26 +235,26 @@ public:
 
   bool copy();					// Alloc string if not alloced
   bool copy(const String &s);			// Allocate new string
-  bool copy(const char *s,uint32 arg_length, CHARSET_INFO *cs);	// Allocate new string
-  static bool needs_conversion(uint32 arg_length,
+  bool copy(const char *s,size_t arg_length, CHARSET_INFO *cs);	// Allocate new string
+  static bool needs_conversion(size_t arg_length,
   			       CHARSET_INFO *cs_from, CHARSET_INFO *cs_to,
 			       uint32 *offset);
-  bool copy_aligned(const char *s, uint32 arg_length, uint32 offset,
+  bool copy_aligned(const char *s, size_t arg_length, uint32 offset,
 		    CHARSET_INFO *cs);
-  bool set_or_copy_aligned(const char *s, uint32 arg_length, CHARSET_INFO *cs);
-  bool copy(const char*s,uint32 arg_length, CHARSET_INFO *csfrom,
+  bool set_or_copy_aligned(const char *s, size_t arg_length, CHARSET_INFO *cs);
+  bool copy(const char*s,size_t arg_length, CHARSET_INFO *csfrom,
 	    CHARSET_INFO *csto, uint *errors);
   bool append(const String &s);
   bool append(const char *s);
-  bool append(const char *s,uint32 arg_length);
-  bool append(const char *s,uint32 arg_length, CHARSET_INFO *cs);
-  bool append(IO_CACHE* file, uint32 arg_length);
-  bool append_with_prefill(const char *s, uint32 arg_length, 
-			   uint32 full_length, char fill_char);
+  bool append(const char *s,size_t arg_length);
+  bool append(const char *s,size_t arg_length, CHARSET_INFO *cs);
+  bool append(IO_CACHE* file, size_t arg_length);
+  bool append_with_prefill(const char *s, size_t arg_length, 
+			   size_t full_length, char fill_char);
   int strstr(const String &search,uint32 offset=0); // Returns offset to substring or
-1
   int strrstr(const String &search,uint32 offset=0); // Returns offset to substring
or -1
-  bool replace(uint32 offset,uint32 arg_length,const char *to,uint32 length);
-  bool replace(uint32 offset,uint32 arg_length,const String &to);
+  bool replace(uint32 offset,size_t arg_length,const char *to,size_t length);
+  bool replace(uint32 offset,size_t arg_length,const String &to);
   inline bool append(char chr)
   {
     if (str_length < Alloced_length)
@@ -269,12 +269,12 @@ public:
     }
     return 0;
   }
-  bool fill(uint32 max_length,char fill);
+  bool fill(size_t max_length,char fill);
   void strip_sp();
   friend int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
   friend int stringcmp(const String *a,const String *b);
-  friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
-  uint32 numchars();
+  friend String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
+  size_t numchars();
   int charpos(int i,uint32 offset=0);
 
   int reserve(uint32 space_needed)
@@ -307,7 +307,7 @@ public:
     float8store(Ptr + str_length, *d);
     str_length += 8;
   }
-  void q_append(const char *data, uint32 data_len)
+  void q_append(const char *data, size_t data_len)
   {
     memcpy(Ptr + str_length, data, data_len);
     str_length += data_len;
@@ -318,7 +318,7 @@ public:
     int4store(Ptr + position,value);
   }
 
-  void qs_append(const char *str, uint32 len);
+  void qs_append(const char *str, size_t len);
   void qs_append(double d);
   void qs_append(double *d);
   inline void qs_append(const char c)
@@ -331,22 +331,22 @@ public:
 
   /* Inline (general) functions used by the protocol functions */
 
-  inline char *prep_append(uint32 arg_length, uint32 step_alloc)
+  inline char *prep_append(size_t arg_length, uint32 step_alloc)
   {
-    uint32 new_length= arg_length + str_length;
+    size_t new_length= arg_length + str_length;
     if (new_length > Alloced_length)
     {
       if (realloc(new_length + step_alloc))
         return 0;
     }
-    uint32 old_length= str_length;
+    size_t old_length= str_length;
     str_length+= arg_length;
     return Ptr+ old_length;			/* Area to use */
   }
 
-  inline bool append(const char *s, uint32 arg_length, uint32 step_alloc)
+  inline bool append(const char *s, size_t arg_length, uint32 step_alloc)
   {
-    uint32 new_length= arg_length + str_length;
+    size_t new_length= arg_length + str_length;
     if (new_length > Alloced_length && realloc(new_length + step_alloc))
       return TRUE;
     memcpy(Ptr+str_length, s, arg_length);