bk commit into 5.1 tree (kaa:1.2433)

[Alexey Kopytov]

Below is the list of changes that have just been committed into a local
5.1 repository of kaa. When kaa 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-03-05 18:57:57+03:00, kaa@stripped +3 -0
  Merge polly.local:/tmp/maint/bug5731/my50-bug5731
  into  polly.local:/tmp/maint/bug5731/my51-bug5731
  MERGE: 1.1810.2566.3

  include/my_sys.h@stripped, 2007-03-05 18:57:53+03:00, kaa@stripped +2 -4
    Manual merge.
    MERGE: 1.178.10.3

  mysys/my_malloc.c@stripped, 2007-03-05 18:57:53+03:00, kaa@stripped +1 -2
    Manual merge.
    MERGE: 1.9.1.4

  mysys/safemalloc.c@stripped, 2007-03-05 18:57:53+03:00, kaa@stripped +1 -2
    Manual merge.
    MERGE: 1.24.1.4

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	kaa
# Host:	polly.local
# Root:	/tmp/maint/bug5731/my51-bug5731/RESYNC

--- 1.217/include/my_sys.h	2007-03-05 18:58:06 +03:00
+++ 1.218/include/my_sys.h	2007-03-05 18:58:06 +03:00
@@ -156,13 +156,13 @@ extern ulonglong sf_malloc_mem_limit;
 #define TERMINATE(A) {}
 #define QUICK_SAFEMALLOC
 #define NORMAL_SAFEMALLOC
-extern gptr my_malloc(uint Size,myf MyFlags);
+extern gptr my_malloc(size_t Size, myf MyFlags);
 #define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
-extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
+extern gptr my_realloc(gptr oldpoint, size_t Size, myf MyFlags);
 extern void my_no_flags_free(gptr ptr);
-extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
+extern gptr my_memdup(const byte *from, size_t length, myf MyFlags);
 extern char *my_strdup(const char *from,myf MyFlags);
-extern char *my_strndup(const char *from, uint length,
+extern char *my_strndup(const char *from, size_t length,
 				   myf MyFlags);
 /* we do use FG (as a no-op) in below so that a typo on FG is caught */
 #define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
@@ -174,7 +174,7 @@ extern char *my_strndup(const char *from
 
 #ifdef HAVE_LARGE_PAGES
 extern uint my_get_large_page_size(void);
-extern gptr my_large_malloc(uint size, myf my_flags);
+extern gptr my_large_malloc(size_t size, myf my_flags);
 extern void my_large_free(gptr ptr, myf my_flags);
 #else
 #define my_get_large_page_size() (0)
@@ -583,18 +583,18 @@ extern uint my_fwrite(FILE *stream,const
 		      myf MyFlags);
 extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
 extern my_off_t my_ftell(FILE *stream,myf MyFlags);
-extern gptr _mymalloc(uint uSize,const char *sFile,
+extern gptr _mymalloc(size_t uSize, const char *sFile,
 		      uint uLine, myf MyFlag);
-extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile,
+extern gptr _myrealloc(gptr pPtr, size_t uSize, const char *sFile,
 		       uint uLine, myf MyFlag);
 extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
 extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
 extern int _sanity(const char *sFile,unsigned int uLine);
-extern gptr _my_memdup(const byte *from,uint length,
+extern gptr _my_memdup(const byte *from, size_t length,
 		       const char *sFile, uint uLine,myf MyFlag);
 extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
 			    myf MyFlag);
-extern char *_my_strndup(const char *from, uint length,
+extern char *_my_strndup(const char *from, size_t length,
 				    const char *sFile, uint uLine,
 				    myf MyFlag);
 
@@ -790,7 +790,7 @@ extern my_bool dynstr_realloc(DYNAMIC_ST
 extern my_bool dynstr_trunc(DYNAMIC_STRING *str, int n);
 extern void dynstr_free(DYNAMIC_STRING *str);
 #ifdef HAVE_MLOCK
-extern byte *my_malloc_lock(uint length,myf flags);
+extern byte *my_malloc_lock(size_t length, myf flags);
 extern void my_free_lock(byte *ptr,myf flags);
 #else
 #define my_malloc_lock(A,B) my_malloc((A),(B))

--- 1.14/mysys/my_malloc.c	2007-03-05 18:58:06 +03:00
+++ 1.15/mysys/my_malloc.c	2007-03-05 18:58:06 +03:00
@@ -23,11 +23,11 @@
 
 	/* My memory allocator */
 
-gptr my_malloc(unsigned int size, myf my_flags)
+gptr my_malloc(size_t size, myf my_flags)
 {
   gptr point;
   DBUG_ENTER("my_malloc");
-  DBUG_PRINT("my",("size: %u  my_flags: %d",size, my_flags));
+  DBUG_PRINT("my",("size: %lu  my_flags: %d", (ulong) size, my_flags));
 
   if (!size)
     size=1;					/* Safety */
@@ -63,7 +63,7 @@ void my_no_flags_free(gptr ptr)
 
 	/* malloc and copy */
 
-gptr my_memdup(const byte *from, uint length, myf my_flags)
+gptr my_memdup(const byte *from, size_t length, myf my_flags)
 {
   gptr ptr;
   if ((ptr=my_malloc(length,my_flags)) != 0)
@@ -75,14 +75,14 @@ gptr my_memdup(const byte *from, uint le
 char *my_strdup(const char *from, myf my_flags)
 {
   gptr ptr;
-  uint length=(uint) strlen(from)+1;
+  size_t length= (size_t) strlen(from)+1;
   if ((ptr=my_malloc(length,my_flags)) != 0)
     memcpy((byte*) ptr, (byte*) from,(size_t) length);
   return((my_string) ptr);
 }
 
 
-char *my_strndup(const char *from, uint length, myf my_flags)
+char *my_strndup(const char *from, size_t length, myf my_flags)
 {
   gptr ptr;
   if ((ptr=my_malloc(length+1,my_flags)) != 0)

--- 1.29/mysys/safemalloc.c	2007-03-05 18:58:06 +03:00
+++ 1.30/mysys/safemalloc.c	2007-03-05 18:58:06 +03:00
@@ -119,12 +119,12 @@ static int _checkchunk(struct st_irem *p
 
 /* Allocate some memory. */
 
-gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
+gptr _mymalloc(size_t size, const char *filename, uint lineno, myf MyFlags)
 {
   struct st_irem *irem;
   char *data;
   DBUG_ENTER("_mymalloc");
-  DBUG_PRINT("enter",("Size: %u",size));
+  DBUG_PRINT("enter",("Size: %lu", (ulong) size));
 
   if (!sf_malloc_quick)
     (void) _sanity (filename, lineno);
@@ -148,12 +148,14 @@ gptr _mymalloc(uint size, const char *fi
     if (MyFlags & (MY_FAE+MY_WME))
     {
       char buff[SC_MAXWIDTH];
+      char llbuf1[22], llbuf2[22], llbuf3[22], llbuf4[22];
       my_errno=errno;
       sprintf(buff,"Out of memory at line %d, '%s'", lineno, filename);
       my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
-      sprintf(buff,"needed %d byte (%ldk), memory in use: %ld bytes (%ldk)",
-	      size, (size + 1023L) / 1024L,
-	      sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) / 1024L);
+      sprintf(buff,"needed %s bytes (%sk), memory in use: %s bytes (%sk)",
+              llstr(size, llbuf1), llstr((size + 1023UL) / 1024UL, llbuf2),
+              llstr(sf_malloc_max_memory, llbuf3),
+              llstr((sf_malloc_max_memory + 1023UL) / 1024UL, llbuf4));
       my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
     }
     DBUG_PRINT("error",("Out of memory, in use: %ld at line %d, '%s'",
@@ -207,7 +209,7 @@ gptr _mymalloc(uint size, const char *fi
   Free then old memoryblock
 */
 
-gptr _myrealloc(register gptr ptr, register uint size,
+gptr _myrealloc(register gptr ptr, register size_t size,
 		const char *filename, uint lineno, myf MyFlags)
 {
   struct st_irem *irem;
@@ -402,14 +404,14 @@ void TERMINATE(FILE *file)
       if (file)
       {
 	fprintf(file,
-		"\t%6u bytes at 0x%09lx, allocated at line %4u in '%s'",
-		irem->datasize, (long) data, irem->linenum, irem->filename);
+		"\t%6lu bytes at 0x%09lx, allocated at line %4u in '%s'",
+		(ulong) irem->datasize, (long) data, irem->linenum, irem->filename);
 	fprintf(file, "\n");
 	(void) fflush(file);
       }
       DBUG_PRINT("safe",
-		 ("%6u bytes at 0x%09lx, allocated at line %4d in '%s'",
-		  irem->datasize, (long) data, irem->linenum, irem->filename));
+		 ("%6lu bytes at 0x%09lx, allocated at line %4d in '%s'",
+		  (ulong) irem->datasize, (long) data, irem->linenum, irem->filename));
       irem= irem->next;
     }
   }
@@ -503,7 +505,7 @@ int _sanity(const char *filename, uint l
 
 	/* malloc and copy */
 
-gptr _my_memdup(const byte *from, uint length, const char *filename,
+gptr _my_memdup(const byte *from, size_t length, const char *filename,
 		uint lineno, myf MyFlags)
 {
   gptr ptr;
@@ -524,7 +526,7 @@ char *_my_strdup(const char *from, const
 } /* _my_strdup */
 
 
-char *_my_strndup(const char *from, uint length,
+char *_my_strndup(const char *from, size_t length,
 			     const char *filename, uint lineno,
 			     myf MyFlags)
 {