Big code cleanup/review before 4.0.2 release.

(All commit emails since 4.0.1 checked)
This had to be done now, before the 4.1 tree changes to much, to make it easy to propagate bug fixes to the 4.1 tree.


BUILD/SETUP.sh:
  Added -DPEDANTIC_SAFEMALLOC as standard debug option
Docs/manual.texi:
  Changes for new version.
client/mysql.cc:
  Fixed default value for rehash
  cleanup
client/mysqladmin.c:
  Cleanup
client/mysqlbinlog.cc:
  cleanup
client/mysqldump.c:
  Cleanup
client/mysqlmanager-pwgen.c:
  Cleanup
client/mysqlmanagerc.c:
  Cleanup
client/mysqltest.c:
  Cleanup
dbug/dbug.c:
  Cleanup
extra/resolve_stack_dump.c:
  Cleanup & Simple optimizations
include/ft_global.h:
  Cleanup
include/my_alloc.h:
  Cleanup
include/my_global.h:
  Cleanup
include/my_sys.h:
  Cleanup
include/myisam.h:
  Cleanup
libmysql/libmysql.c:
  Cleanup
libmysql/manager.c:
  Cleanup
myisam/ft_boolean_search.c:
  Cleanup
myisam/ft_dump.c:
  Change strcpy -> strmov
myisam/ft_eval.c:
  Cleanup
myisam/ft_nlq_search.c:
  Cleanup
myisam/ft_test1.c:
  strncpy -> strnmov
myisam/ft_update.c:
  Cleanup
myisam/mi_static.c:
  Cleanup
myisam/mi_test2.c:
  Cleanup
myisam/mi_write.c:
  Cleanup
mysys/mf_fn_ext.c:
  Cleanup
mysys/mf_iocache.c:
  Cleanup
mysys/mf_iocache2.c:
  Cleanup
mysys/my_getopt.c:
  Cleanup
mysys/my_read.c:
  Cleanup
mysys/my_thr_init.c:
  Cleanup
mysys/queues.c:
  Cleanup
mysys/safemalloc.c:
  Cleanup
sql/field.cc:
  Indentation cleanups
sql/ha_berkeley.cc:
  Indentation cleanups
sql/ha_myisam.cc:
  Cleanup
sql/item.h:
  Indentation cleanups
sql/item_cmpfunc.cc:
  Indentation cleanups
sql/item_create.cc:
  cleanup
sql/item_func.cc:
  Cleanup
sql/item_func.h:
  Indentation cleanups
sql/item_strfunc.cc:
  Indentation cleanups
sql/item_sum.cc:
  Indentation cleanups
sql/item_timefunc.cc:
  Indentation cleanups
sql/lock.cc:
  Indentation cleanups
sql/log.cc:
  Cleanup
  strnmov -> strmake
sql/log_event.cc:
  Cleanup + optimizations
  Fixed memory leak
  Added missing pthread_mutex_unlock()  (On error condition)
sql/log_event.h:
  Indentation and comment cleanup
  Merged #ifdef's into common blocks for better readability
sql/mini_client.cc:
  Indentation cleanup
sql/mysql_priv.h:
  Cleanup
  Changed int function to bool
sql/mysqld.cc:
  Indentation and comment cleanup
sql/net_pkg.cc:
  Indentation cleanup
sql/net_serv.cc:
  Changed int function -> bool
sql/nt_servc.cc:
  Cleanup
sql/opt_range.cc:
  Indentation cleanup
sql/repl_failsafe.cc:
  Cleanup + simple optimization
  strnmov -> strmake
sql/slave.cc:
  strnmov -> strmake
  Cleanups
sql/slave.h:
  Cleanup
sql/sql_acl.cc:
  Indentation and DBUG_PRINT cleanup
  Changed WITH MAX... to not use =
sql/sql_base.cc:
  Indentation cleanup
sql/sql_cache.cc:
  Indentation cleanup
sql/sql_class.cc:
  Indentation cleanup
sql/sql_class.h:
  Renamed some struct slots
sql/sql_delete.cc:
  Indentation cleanup
sql/sql_handler.cc:
  Indentation cleanup
sql/sql_insert.cc:
  Use new slot names.
sql/sql_lex.cc:
  Indentation cleanup
sql/sql_lex.h:
  Indentation cleanup
sql/sql_load.cc:
  Indentation cleanup
sql/sql_parse.cc:
  Indentation cleanup
  Removed not used check from LOCK TABLES
sql/sql_repl.cc:
  strnmov -> strmake
sql/sql_repl.h:
  Removed test if file is included (We want to know if it's included twice to avoid this)
sql/sql_select.cc:
  Indentation cleanup
sql/sql_show.cc:
  Indentation cleanup
sql/sql_string.cc:
  Indentation cleanup
sql/sql_table.cc:
  Indentation cleanup
sql/sql_union.cc:
  Use renamed struct slot
sql/sql_update.cc:
  Indentation cleanup
sql/sql_yacc.yy:
  Removed = after GRANT ... MAX_  to make the syntax uniform
sql/table.cc:
  Indentation cleanup
sql/table.h:
  Indentation cleanup
sql/time.cc:
  Indentation cleanup
sql/udf_example.cc:
  Indentation cleanup
sql/unireg.cc:
  strnmov -> strmake
tests/grant.pl:
  Added test for LOCK TABLES
tools/mysqlmanager.c:
  Cleanup
  fopen() -> my_fopen()
vio/viosocket.c:
  DBUG_PRINT cleanups
vio/viosslfactories.c:
  Indentation cleanup
  Checking of results from malloc()
  Fixed possible memory leak
BitKeeper/etc/ignore:
  Added scripts/mysql_secure_installation to the ignore list
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

1 files changed, 97 insertions, 97 deletions

diff --git a/mysys/safemalloc.c b/mysys/safemalloc.c
index 074afe27500..961d49f042e 100644
--- a/mysys/safemalloc.c
+++ b/mysys/safemalloc.c
@@ -15,53 +15,50 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 /*
- * [This posting refers to an article entitled "oops, corrupted memory
- * again!" in net.lang.c.  I am posting it here because it is source.]
- *
- * My tool for approaching this problem is to build another level of data
- * abstraction on top of malloc() and free() that implements some checking.
- * This does a number of things for you:
- *	- Checks for overruns and underruns on allocated data
- *	- Keeps track of where in the program the memory was malloc'ed
- *	- Reports on pieces of memory that were not free'ed
- *	- Records some statistics such as maximum memory used
- *	- Marks newly malloc'ed and newly free'ed memory with special values
- * You can use this scheme to:
- *	- Find bugs such as overrun, underrun, etc because you know where
- *	  a piece of data was malloc'ed and where it was free'ed
- *	- Find bugs where memory was not free'ed
- *	- Find bugs where newly malloc'ed memory is used without initializing
- *	- Find bugs where newly free'ed memory is still used
- *	- Determine how much memory your program really uses
- *	- and other things
- */
-
-/*
- * To implement my scheme you must have a C compiler that has __LINE__ and
- * __FILE__ macros.  If your compiler doesn't have these then (a) buy another:
- * compilers that do are available on UNIX 4.2bsd based systems and the PC,
- * and probably on other machines; or (b) change my scheme somehow.  I have
- * recomendations on both these points if you would like them (e-mail please).
- *
- * There are 4 functions in my package:
- *	char *NEW( uSize )	Allocate memory of uSize bytes
- *				(equivalent to malloc())
- *	char *REA( pPtr, uSize) Allocate memory of uSize bytes, move data and
- *				free pPtr.
- *				(equivalent to realloc())
- *	FREE( pPtr )		Free memory allocated by NEW
- *				(equivalent to free())
- *	TERMINATE(file)		End system, report errors and stats on file
- * I personally use two more functions, but have not included them here:
- *	char *STRSAVE( sPtr )	Save a copy of the string in dynamic memory
- *	char *RENEW( pPtr, uSize )
- *				(equivalent to realloc())
- */
-
-/*
  * Memory sub-system, written by Bjorn Benson
    Fixed to use my_sys scheme by Michael Widenius
- */
+
+  [This posting refers to an article entitled "oops, corrupted memory
+  again!" in net.lang.c.  I am posting it here because it is source.]
+
+  My tool for approaching this problem is to build another level of data
+  abstraction on top of malloc() and free() that implements some checking.
+  This does a number of things for you:
+	- Checks for overruns and underruns on allocated data
+	- Keeps track of where in the program the memory was malloc'ed
+	- Reports on pieces of memory that were not free'ed
+	- Records some statistics such as maximum memory used
+	- Marks newly malloc'ed and newly free'ed memory with special values
+  You can use this scheme to:
+	- Find bugs such as overrun, underrun, etc because you know where
+	  a piece of data was malloc'ed and where it was free'ed
+	- Find bugs where memory was not free'ed
+	- Find bugs where newly malloc'ed memory is used without initializing
+	- Find bugs where newly free'ed memory is still used
+	- Determine how much memory your program really uses
+	- and other things
+
+  To implement my scheme you must have a C compiler that has __LINE__ and
+  __FILE__ macros.  If your compiler doesn't have these then (a) buy another:
+  compilers that do are available on UNIX 4.2bsd based systems and the PC,
+  and probably on other machines; or (b) change my scheme somehow.  I have
+  recomendations on both these points if you would like them (e-mail please).
+
+  There are 4 functions in my package:
+	char *NEW( uSize )	Allocate memory of uSize bytes
+				(equivalent to malloc())
+	char *REA( pPtr, uSize) Allocate memory of uSize bytes, move data and
+				free pPtr.
+				(equivalent to realloc())
+	FREE( pPtr )		Free memory allocated by NEW
+				(equivalent to free())
+	TERMINATE(file)		End system, report errors and stats on file
+  I personally use two more functions, but have not included them here:
+	char *STRSAVE( sPtr )	Save a copy of the string in dynamic memory
+	char *RENEW( pPtr, uSize )
+				(equivalent to realloc())
+
+*/
 
 #ifndef SAFEMALLOC
 #define SAFEMALLOC			/* Get protos from my_sys */
@@ -87,11 +84,12 @@ pthread_t shutdown_th,main_th,signal_th;
 #define lSpecialValue	tInt._lSpecialValue
 
 #ifndef PEDANTIC_SAFEMALLOC
-static int sf_malloc_tampered = 0; /* set to 1 after TERMINATE() if we had
-				    to fiddle with cNewCount and the linked
-				    list of blocks so that _sanity() will
-				    not fuss when it is not supposed to
-				 */
+/*
+  Set to 1 after TERMINATE() if we had to fiddle with cNewCount and
+  the linked list of blocks so that _sanity() will not fuss when it
+  is not supposed to
+*/
+static int sf_malloc_tampered = 0;
 #endif
 				   
 
@@ -102,37 +100,37 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
 static int _checkchunk(struct remember *pRec, const char *sFile, uint uLine);
 
 /*
- *	Note: both these refer to the NEW'ed
- *	data only.  They do not include
- *	malloc() roundoff or the extra
- *	space required by the remember
- *	structures.
- */
-
-#define ALLOC_VAL	(uchar) 0xA5	/* NEW'ed memory is filled with this */
-				/* value so that references to it will	 */
-				/* end up being very strange.		 */
-#define FREE_VAL	(uchar) 0x8F	/* FREE'ed memory is filled with this */
-				/* value so that references to it will	 */
-				/* also end up being strange.		 */
+  Note: both these refer to the NEW'ed data only.  They do not include
+  malloc() roundoff or the extra space required by the remember
+  structures.
+*/
 
+/*
+  NEW'ed memory is filled with this value so that references to it will
+  end up being very strange.
+*/
+#define ALLOC_VAL	(uchar) 0xA5
+/*
+  FEEE'ed memory is filled with this value so that references to it will
+  end up being very strange.
+*/
+#define FREE_VAL	(uchar) 0x8F
 #define MAGICKEY	0x14235296	/* A magic value for underrun key */
+
+/*
+  Warning: do not change the MAGICEND? values to something with the
+  high bit set.  Various C compilers (like the 4.2bsd one) do not do
+  the sign extension right later on in this code and you will get
+  erroneous errors.
+*/
+
 #define MAGICEND0	0x68		/* Magic values for overrun keys  */
 #define MAGICEND1	0x34		/*		"		  */
 #define MAGICEND2	0x7A		/*		"		  */
 #define MAGICEND3	0x15		/*		"		  */
 
- /* Warning: do not change the MAGICEND? values to */
- /* something with the high bit set.  Various C    */
- /* compilers (like the 4.2bsd one) do not do the  */
- /* sign extension right later on in this code and */
- /* you will get erroneous errors.		  */
-
 
-/*
- * gptr _mymalloc( uint uSize, my_string sFile, uint uLine, MyFlags )
- *	Allocate some memory.
- */
+/* Allocate some memory. */
 
 gptr _mymalloc (uint uSize, const char *sFile, uint uLine, myf MyFlags)
 {
@@ -144,9 +142,10 @@ gptr _mymalloc (uint uSize, const char *sFile, uint uLine, myf MyFlags)
     if (!sf_malloc_quick)
       (void) _sanity (sFile, uLine);
 
-    if(uSize + lCurMemory > safemalloc_mem_limit)
+    if (uSize + lCurMemory > safemalloc_mem_limit)
       pTmp = 0;
     else
+    {
        /* Allocate the physical memory */
        pTmp = (struct remember *) malloc (
 		sizeof (struct irem)			/* remember data  */
@@ -155,7 +154,7 @@ gptr _mymalloc (uint uSize, const char *sFile, uint uLine, myf MyFlags)
 		+ 4					/* overrun mark   */
 		+ sf_malloc_endhunc
 		);
-
+    }
     /* Check if there isn't anymore memory avaiable */
     if (pTmp == NULL)
     {
@@ -225,9 +224,9 @@ gptr _mymalloc (uint uSize, const char *sFile, uint uLine, myf MyFlags)
 }
 
 /*
- *  Allocate some new memory and move old memoryblock there.
- *  Free then old memoryblock
- */
+  Allocate some new memory and move old memoryblock there.
+  Free then old memoryblock
+*/
 
 gptr _myrealloc (register gptr pPtr, register uint uSize,
 		 const char *sFile, uint uLine, myf MyFlags)
@@ -258,7 +257,7 @@ gptr _myrealloc (register gptr pPtr, register uint uSize,
     DBUG_RETURN((gptr) NULL);
   }
 
-  if ((ptr=_mymalloc(uSize,sFile,uLine,MyFlags)))	/* Allocate new area */
+  if ((ptr=_mymalloc(uSize,sFile,uLine,MyFlags))) /* Allocate new area */
   {
     uSize=min(uSize,pRec-> uDataSize);		/* Move as much as possibly */
     memcpy((byte*) ptr,pPtr,(size_t) uSize);	/* Copy old data */
@@ -275,10 +274,7 @@ gptr _myrealloc (register gptr pPtr, register uint uSize,
 } /* _myrealloc */
 
 
-/*
- * void _myfree( my_string pPtr, my_string sFile, uint uLine, myf myflags)
- *	Deallocate some memory.
- */
+/* Deallocate some memory. */
 
 void _myfree (gptr pPtr, const char *sFile, uint uLine, myf myflags)
 {
@@ -297,12 +293,14 @@ void _myfree (gptr pPtr, const char *sFile, uint uLine, myf myflags)
   pRec = (struct remember *) ((byte*) pPtr-sizeof(struct irem)-
 			      sf_malloc_prehunc);
 
-  /* Check to make sure that we have a real remember structure	*/
-  /* Note: this test could fail for four reasons:		*/
-  /*	(1) The memory was already free'ed			*/
-  /*	(2) The memory was never new'ed				*/
-  /*	(3) There was an underrun				*/
-  /*	(4) A stray pointer hit this location			*/
+  /*
+    Check to make sure that we have a real remember structure.
+    Note: this test could fail for four reasons:
+    	(1) The memory was already free'ed
+	(2) The memory was never new'ed
+	(3) There was an underrun
+	(4) A stray pointer hit this location
+  */
 
   if (*((long*) ((char*) &pRec -> lSpecialValue+sf_malloc_prehunc))
       != MAGICKEY)
@@ -379,9 +377,9 @@ static int check_ptr(const char *where, byte *ptr, const char *sFile,
 #ifdef THREAD
 static int legal_leak(struct remember* pPtr)
 {
- return pthread_self() == pPtr->thread_id || main_th == pPtr->thread_id
-	    || shutdown_th == pPtr->thread_id
-   || signal_th == pPtr->thread_id;
+  /* TODO: This code needs to be made more general */
+  return (pthread_self() == pPtr->thread_id || main_th == pPtr->thread_id ||
+	  shutdown_th == pPtr->thread_id || signal_th == pPtr->thread_id);
 }
 #else
 static int legal_leak(struct remember* pPtr)
@@ -391,9 +389,9 @@ static int legal_leak(struct remember* pPtr)
 #endif
 
 /*
- * TERMINATE(FILE *file)
- *	Report on all the memory pieces that have not been
- *	free'ed as well as the statistics.
+  TERMINATE(FILE *file)
+    Report on all the memory pieces that have not been
+    free'ed as well as the statistics.
  */
 
 void TERMINATE (FILE *file)
@@ -460,8 +458,10 @@ void TERMINATE (FILE *file)
     DBUG_PRINT("safe",("cNewCount: %d",cNewCount));
   }
 
-  /* Report on all the memory that was allocated with NEW	 */
-  /* but not free'ed with FREE.				 */
+  /*
+    Report on all the memory that was allocated with NEW
+    but not free'ed with FREE.
+  */
 
   if ((pPtr=pRememberRoot))
   {