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

8 files changed, 183 insertions, 169 deletions

diff --git a/mysys/mf_fn_ext.c b/mysys/mf_fn_ext.c
index fb3fd8870aa..3a11f1a247e 100644
--- a/mysys/mf_fn_ext.c
+++ b/mysys/mf_fn_ext.c
@@ -14,16 +14,16 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Returnerar en pekare till filnamnets extension. */
 
 #include "mysys_priv.h"
 #include <m_string.h>
 
-	/* Return a pointerto the extension of the filename
-	   The pointer points at the extension character (normally '.'))
-	   If there isn't any extension, the pointer points at the end
-	   NULL of the filename
-	*/
+/*
+  Return a pointerto the extension of the filename
+  The pointer points at the extension character (normally '.'))
+  If there isn't any extension, the pointer points at the end
+  ASCII(0) of the filename.
+*/
 
 my_string fn_ext(const char *name)
 {
diff --git a/mysys/mf_iocache.c b/mysys/mf_iocache.c
index 34873d107af..54dfaf6d993 100644
--- a/mysys/mf_iocache.c
+++ b/mysys/mf_iocache.c
@@ -73,11 +73,12 @@ init_functions(IO_CACHE* info, enum cache_type type)
 {
   switch (type) {
   case READ_NET:
-    /* must be initialized by the caller. The problem is that
-       _my_b_net_read has to be defined in sql directory because of
-       the dependency on THD, and therefore cannot be visible to
-       programs that link against mysys but know nothing about THD, such
-       as myisamchk
+    /*
+      Must be initialized by the caller. The problem is that
+      _my_b_net_read has to be defined in sql directory because of
+      the dependency on THD, and therefore cannot be visible to
+      programs that link against mysys but know nothing about THD, such
+      as myisamchk
     */
     break;
   case SEQ_READ_APPEND:
diff --git a/mysys/mf_iocache2.c b/mysys/mf_iocache2.c
index c56022e93e8..b19ca391672 100644
--- a/mysys/mf_iocache2.c
+++ b/mysys/mf_iocache2.c
@@ -27,32 +27,36 @@
 
 my_off_t my_b_append_tell(IO_CACHE* info)
 {
-  /* prevent optimizer from putting res in a register when debugging
-     we need this to be able to see the value of res when the assert fails
+  /*
+    Prevent optimizer from putting res in a register when debugging
+    we need this to be able to see the value of res when the assert fails
   */
   dbug_volatile my_off_t res; 
-/* we need to lock the append buffer mutex to keep flush_io_cache()
-   from messing with the variables that we need in order to provide the
-   answer to the question.
-*/
+
+  /*
+    We need to lock the append buffer mutex to keep flush_io_cache()
+    from messing with the variables that we need in order to provide the
+    answer to the question.
+  */
 #ifdef THREAD
   pthread_mutex_lock(&info->append_buffer_lock);
 #endif
-  /* save the value of my_tell in res so we can see it when studying
-     coredump
-  */
 #ifndef DBUG_OFF
-  /* make sure EOF is where we think it is. Note that we cannot just use
-     my_tell() because we have a reader thread that could have left the
-     file offset in a non-EOF location
-     */
+  /*
+    Make sure EOF is where we think it is. Note that we cannot just use
+    my_tell() because we have a reader thread that could have left the
+    file offset in a non-EOF location
+  */
   {
-   volatile my_off_t save_pos;
-   save_pos = my_tell(info->file,MYF(0));
-   my_seek(info->file,(my_off_t)0,MY_SEEK_END,MYF(0));
-   DBUG_ASSERT(info->end_of_file - (info->append_read_pos-info->write_buffer)
-	      == (res=my_tell(info->file,MYF(0))));
-   my_seek(info->file,save_pos,MY_SEEK_SET,MYF(0));
+    volatile my_off_t save_pos;
+    save_pos = my_tell(info->file,MYF(0));
+    my_seek(info->file,(my_off_t)0,MY_SEEK_END,MYF(0));
+    /*
+      Save the value of my_tell in res so we can see it when studying coredump
+    */
+    DBUG_ASSERT(info->end_of_file - (info->append_read_pos-info->write_buffer)
+		== (res=my_tell(info->file,MYF(0))));
+    my_seek(info->file,save_pos,MY_SEEK_SET,MYF(0));
   }
 #endif  
   res = info->end_of_file + (info->write_pos-info->append_read_pos);
@@ -74,10 +78,9 @@ void my_b_seek(IO_CACHE *info,my_off_t pos)
   DBUG_PRINT("enter",("pos: %lu", (ulong) pos));
 
   /*
-    TODO: verify that it is OK to do seek in the non-append
-    area in SEQ_READ_APPEND cache
-  */
-  /* TODO:
+    TODO:
+       Verify that it is OK to do seek in the non-append
+       area in SEQ_READ_APPEND cache
      a) see if this always works
      b) see if there is a better way to make it work
   */
diff --git a/mysys/my_getopt.c b/mysys/my_getopt.c
index 94614ccb612..ce9006e03c0 100644
--- a/mysys/my_getopt.c
+++ b/mysys/my_getopt.c
@@ -22,17 +22,17 @@
 #include <my_sys.h>
 #include <mysys_err.h>
 
-static int findopt (char *optpat, uint length,
-		    const struct my_option **opt_res,
-		    char **ffname);
-static my_bool compare_strings (register const char *s, register const char *t,
-				uint length);
-static longlong getopt_ll (char *arg, const struct my_option *optp, int *err);
-static ulonglong getopt_ull (char *arg, const struct my_option *optp,
-			     int *err);
+static int findopt(char *optpat, uint length,
+		   const struct my_option **opt_res,
+		   char **ffname);
+static my_bool compare_strings(register const char *s, register const char *t,
+			       uint length);
+static longlong getopt_ll(char *arg, const struct my_option *optp, int *err);
+static ulonglong getopt_ull(char *arg, const struct my_option *optp,
+			    int *err);
 static void init_variables(const struct my_option *options);
-static int setval (const struct my_option *opts, char *argument,
-		   my_bool set_maximum_value);
+static int setval(const struct my_option *opts, char *argument,
+		  my_bool set_maximum_value);
 
 /*
   The following three variables belong to same group and the number and
@@ -42,8 +42,8 @@ static const char *special_opt_prefix[]=
 {"skip", "disable", "enable", "maximum", "loose", 0};
 static const uint special_opt_prefix_lengths[]=
 { 4,      7,         6,        7,         5,      0};
-enum enum_special_opt { OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM,
-			OPT_LOOSE};
+enum enum_special_opt
+{ OPT_SKIP, OPT_DISABLE, OPT_ENABLE, OPT_MAXIMUM, OPT_LOOSE};
 
 char *disabled_my_option= (char*) "0";
 
@@ -74,7 +74,7 @@ int handle_options(int *argc, char ***argv,
 {
   uint opt_found, argvpos= 0, length, i;
   my_bool end_of_options= 0, must_be_var, set_maximum_value, special_used,
-          option_is_loose, option_used= 0;
+          option_is_loose;
   char *progname= *(*argv), **pos, *optend, *prev_found;
   const struct my_option *optp;
   int error;
@@ -90,7 +90,6 @@ int handle_options(int *argc, char ***argv,
     if (cur_arg[0] == '-' && cur_arg[1] && !end_of_options) /* must be opt */
     {
       char *argument=    0;
-      option_used=       1;
       must_be_var=       0;
       set_maximum_value= 0;
       special_used=      0;
@@ -406,12 +405,13 @@ int handle_options(int *argc, char ***argv,
     else /* non-option found */
       (*argv)[argvpos++]= cur_arg;
   }
-  /* Destroy the first, already handled option, so that programs that look
-     for arguments in 'argv', without checking 'argc', know when to stop.
-     Items in argv, before the destroyed one, are all non-option -arguments
-     to the program, yet to be (possibly) handled. */
-  if (option_used)
-    (*argv)[argvpos]= 0;
+  /*
+    Destroy the first, already handled option, so that programs that look
+    for arguments in 'argv', without checking 'argc', know when to stop.
+    Items in argv, before the destroyed one, are all non-option -arguments
+    to the program, yet to be (possibly) handled.
+  */
+  (*argv)[argvpos]= 0;
   return 0;
 }
 
@@ -429,8 +429,8 @@ static int setval (const struct my_option *opts, char *argument,
 
   if (opts->value && argument)
   {
-    gptr *result_pos= (set_maximum_value) ?
-      opts->u_max_value : opts->value;
+    gptr *result_pos= ((set_maximum_value) ?
+		       opts->u_max_value : opts->value);
 
     if (!result_pos)
       return EXIT_NO_PTR_TO_VARIABLE;
diff --git a/mysys/my_read.c b/mysys/my_read.c
index 0c8962e91a9..b7621ac99eb 100644
--- a/mysys/my_read.c
+++ b/mysys/my_read.c
@@ -19,13 +19,22 @@
 #include <errno.h>
 
 
-	/* Read a chunk of bytes from a file  */
+/*
+  Read a chunk of bytes from a file with retry's if needed
+
+  The parameters are:
+    File descriptor
+    Buffer to hold at least Count bytes
+    Bytes to read
+    Flags on what to do on error
+
+    Return:
+      -1 on error
+      0  if flag has bits MY_NABP or MY_FNABP set
+      N  number of bytes read.
+*/
 
 uint my_read(File Filedes, byte *Buffer, uint Count, myf MyFlags)
-				/* File descriptor */
-				/* Buffer must be at least count bytes */
-				/* Max number of bytes returnd */
-				/* Flags on what to do on error */
 {
   uint readbytes,save_count;
   DBUG_ENTER("my_read");
diff --git a/mysys/my_thr_init.c b/mysys/my_thr_init.c
index f62b8d5cb1a..2bd02ad957f 100644
--- a/mysys/my_thr_init.c
+++ b/mysys/my_thr_init.c
@@ -15,8 +15,8 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 /*
-** Functions to handle initializating and allocationg of all mysys & debug
-** thread variables.
+  Functions to handle initializating and allocationg of all mysys & debug
+  thread variables.
 */
 
 #include "mysys_priv.h"
@@ -44,10 +44,6 @@ pthread_mutexattr_t my_fast_mutexattr;
 pthread_mutexattr_t my_errchk_mutexattr;
 #endif
 
-/* FIXME  Note.  TlsAlloc does not set an auto destructor, so
-	the function my_thread_global_free must be called from
-	somewhere before final exit of the library */
-
 my_bool my_thread_global_init(void)
 {
   if (pthread_key_create(&THR_KEY_mysys,free))
@@ -86,6 +82,7 @@ my_bool my_thread_global_init(void)
   return my_thread_init();
 }
 
+
 void my_thread_global_end(void)
 {
 #if defined(USE_TLS)
@@ -158,6 +155,7 @@ end:
   return error;
 }
 
+
 void my_thread_end(void)
 {
   struct st_my_thread_var *tmp=my_thread_var;
@@ -204,8 +202,9 @@ struct st_my_thread_var *_my_thread_var(void)
   return tmp;
 }
 
+
 /****************************************************************************
-** Get name of current thread.
+  Get name of current thread.
 ****************************************************************************/
 
 #define UNKNOWN_THREAD -1
diff --git a/mysys/queues.c b/mysys/queues.c
index 50ef3944a3f..c458c96e998 100644
--- a/mysys/queues.c
+++ b/mysys/queues.c
@@ -173,11 +173,13 @@ static int queue_fix_cmp(QUEUE *queue, void **a, void **b)
 			(char*) (*b)+queue->offset_to_key);
 }
 
-/* Fix heap when every element was changed
-   actually, it can be done in linear time,
-   not in n*log(n), but some code (myisam/ft_boolean_search.c)
-   requires a strict order here, not just a queue property
+/*
+  Fix heap when every element was changed
+  actually, it can be done in linear time,
+  not in n*log(n), but some code (myisam/ft_boolean_search.c)
+  requires a strict order here, not just a queue property
 */
+
 void queue_fix(QUEUE *queue)
 {
   qsort2(queue->root+1,queue->elements, sizeof(void *),
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))
   {