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, 230 insertions, 247 deletions

diff --git a/sql/log_event.h b/sql/log_event.h
index a29c3952d46..29cf6287a4f 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -15,8 +15,8 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
 
-#ifndef _LOG_EVENT_H
-#define _LOG_EVENT_H
+#ifndef _log_event_h
+#define _log_event_h
 
 #ifdef __EMX__
 #undef write  // remove pthread.h macro definition, conflict with write() class member
@@ -36,74 +36,76 @@
 #define LOG_EVENT_OFFSET 4
 #define BINLOG_VERSION    3
 
-/* we could have used SERVER_VERSION_LENGTH, but this introduces an
-   obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
-   this would have broke the replication protocol
+/*
+ We could have used SERVER_VERSION_LENGTH, but this introduces an
+ obscure dependency - if somebody decided to change SERVER_VERSION_LENGTH
+ this would have broke the replication protocol
 */
 #define ST_SERVER_VER_LEN 50
 
-#define DUMPFILE_FLAG 0x1
-#define OPT_ENCLOSED_FLAG 0x2
-#define REPLACE_FLAG  0x4
-#define IGNORE_FLAG   0x8
+#define DUMPFILE_FLAG		0x1
+#define OPT_ENCLOSED_FLAG	0x2
+#define REPLACE_FLAG		0x4
+#define IGNORE_FLAG		0x8
 
-#define FIELD_TERM_EMPTY 0x1
-#define ENCLOSED_EMPTY   0x2
-#define LINE_TERM_EMPTY  0x4
-#define LINE_START_EMPTY 0x8
-#define ESCAPED_EMPTY    0x10
+#define FIELD_TERM_EMPTY	0x1
+#define ENCLOSED_EMPTY		0x2
+#define LINE_TERM_EMPTY		0x4
+#define LINE_START_EMPTY	0x8
+#define ESCAPED_EMPTY		0x10
 
 struct old_sql_ex
-  {
-    char field_term;
-    char enclosed;
-    char line_term;
-    char line_start;
-    char escaped;
-    char opt_flags;
-    char empty_flags;
-  };
+{
+  char field_term;
+  char enclosed;
+  char line_term;
+  char line_start;
+  char escaped;
+  char opt_flags;
+  char empty_flags;
+};
 
 #define NUM_LOAD_DELIM_STRS 5
 
-
 struct sql_ex_info
-  {
-    char* field_term;
-    char* enclosed;
-    char* line_term;
-    char* line_start;
-    char* escaped;
-    uint8 field_term_len,enclosed_len,line_term_len,line_start_len,
-      escaped_len;
-    char opt_flags; 
-    char empty_flags;
-    int cached_new_format;
+{
+  char* field_term;
+  char* enclosed;
+  char* line_term;
+  char* line_start;
+  char* escaped;
+  int cached_new_format;
+  uint8 field_term_len,enclosed_len,line_term_len,line_start_len, escaped_len;
+  char opt_flags; 
+  char empty_flags;
     
-    // store in new format even if old is possible
-    void force_new_format() { cached_new_format = 1;} 
-    int data_size() { return new_format() ?
-			field_term_len + enclosed_len + line_term_len +
-			line_start_len + escaped_len + 6 : 7;}
-    int write_data(IO_CACHE* file);
-    char* init(char* buf,char* buf_end,bool use_new_format);
-    bool new_format()
-      {
-	return (cached_new_format != -1) ? cached_new_format :
-	  (cached_new_format=(field_term_len > 1 ||
-			      enclosed_len > 1 ||
-			      line_term_len > 1 || line_start_len > 1 ||
-			      escaped_len > 1));
-      }
-  } ;
-
-/* Binary log consists of events. Each event has a fixed length header,
-   followed by possibly variable ( depending on the type of event) length
-   data body. The data body consists of an optional fixed length segment
-   (post-header), and an optional variable length segment. See #defines and
-   comments below for the format specifics
-*/
+  // store in new format even if old is possible
+  void force_new_format() { cached_new_format = 1;} 
+  int data_size()
+  {
+    return (new_format() ?
+	    field_term_len + enclosed_len + line_term_len +
+	    line_start_len + escaped_len + 6 : 7);
+  }
+  int write_data(IO_CACHE* file);
+  char* init(char* buf,char* buf_end,bool use_new_format);
+  bool new_format()
+  {
+    return ((cached_new_format != -1) ? cached_new_format :
+	    (cached_new_format=(field_term_len > 1 ||
+				enclosed_len > 1 ||
+				line_term_len > 1 || line_start_len > 1 ||
+				escaped_len > 1)));
+  }
+};
 
+/*
+  Binary log consists of events. Each event has a fixed length header,
+  followed by possibly variable ( depending on the type of event) length
+  data body. The data body consists of an optional fixed length segment
+  (post-header), and an optional variable length segment. See #defines and
+  comments below for the format specifics
+*/
 
 /* event-specific post-header sizes */
 #define LOG_EVENT_HEADER_LEN 19
@@ -139,11 +141,11 @@ struct sql_ex_info
 
 /* query event post-header */
 
-#define Q_THREAD_ID_OFFSET   0
-#define Q_EXEC_TIME_OFFSET   4
-#define Q_DB_LEN_OFFSET      8
-#define Q_ERR_CODE_OFFSET    9
-#define Q_DATA_OFFSET    QUERY_HEADER_LEN
+#define Q_THREAD_ID_OFFSET	0
+#define Q_EXEC_TIME_OFFSET	4
+#define Q_DB_LEN_OFFSET		8
+#define Q_ERR_CODE_OFFSET	9
+#define Q_DATA_OFFSET		QUERY_HEADER_LEN
 
 /* Intvar event post-header */
 
@@ -159,7 +161,7 @@ struct sql_ex_info
 #define L_DB_LEN_OFFSET      13
 #define L_NUM_FIELDS_OFFSET  14
 #define L_SQL_EX_OFFSET      18
-#define L_DATA_OFFSET    LOAD_HEADER_LEN
+#define L_DATA_OFFSET        LOAD_HEADER_LEN
 
 /* Rotate event post-header */
 
@@ -176,10 +178,10 @@ struct sql_ex_info
 
 #define DF_FILE_ID_OFFSET  0
 
-#define QUERY_EVENT_OVERHEAD  (LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
-#define QUERY_DATA_OFFSET (LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
-#define ROTATE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+ROTATE_HEADER_LEN)
-#define LOAD_EVENT_OVERHEAD   (LOG_EVENT_HEADER_LEN+LOAD_HEADER_LEN)
+#define QUERY_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
+#define QUERY_DATA_OFFSET	(LOG_EVENT_HEADER_LEN+QUERY_HEADER_LEN)
+#define ROTATE_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+ROTATE_HEADER_LEN)
+#define LOAD_EVENT_OVERHEAD	(LOG_EVENT_HEADER_LEN+LOAD_HEADER_LEN)
 #define CREATE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+\
  +LOAD_HEADER_LEN+CREATE_FILE_HEADER_LEN)
 #define DELETE_FILE_EVENT_OVERHEAD (LOG_EVENT_HEADER_LEN+DELETE_FILE_HEADER_LEN)
@@ -192,13 +194,19 @@ struct sql_ex_info
 #define LOG_EVENT_TIME_F           0x1
 #define LOG_EVENT_FORCED_ROTATE_F  0x2
 
-enum Log_event_type { START_EVENT = 1, QUERY_EVENT =2,
-		      STOP_EVENT=3, ROTATE_EVENT = 4, INTVAR_EVENT=5,
-                      LOAD_EVENT=6, SLAVE_EVENT=7, CREATE_FILE_EVENT=8,
- APPEND_BLOCK_EVENT=9, EXEC_LOAD_EVENT=10, DELETE_FILE_EVENT=11,
- NEW_LOAD_EVENT=12};
-enum Int_event_type { INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
- };
+enum Log_event_type
+{
+  START_EVENT = 1, QUERY_EVENT =2, STOP_EVENT=3, ROTATE_EVENT = 4,
+  INTVAR_EVENT=5, LOAD_EVENT=6, SLAVE_EVENT=7, CREATE_FILE_EVENT=8,
+  APPEND_BLOCK_EVENT=9, EXEC_LOAD_EVENT=10, DELETE_FILE_EVENT=11,
+  NEW_LOAD_EVENT=12
+};
+
+enum Int_event_type
+{
+  INVALID_INT_EVENT = 0, LAST_INSERT_ID_EVENT = 1, INSERT_ID_EVENT = 2
+};
+
 
 #ifndef MYSQL_CLIENT
 class String;
@@ -220,15 +228,38 @@ public:
   uint16 flags;
   int cached_event_len;
   char* temp_buf;
-#ifndef MYSQL_CLIENT  
+
+#ifndef MYSQL_CLIENT
   THD* thd;
+
+  Log_event(THD* thd_arg, uint16 flags_arg = 0);
+  // if mutex is 0, the read will proceed without mutex
+  static Log_event* read_log_event(IO_CACHE* file,
+				   pthread_mutex_t* log_lock,
+				   bool old_format);
+  static int read_log_event(IO_CACHE* file, String* packet,
+			    pthread_mutex_t* log_lock);
+  void set_log_pos(MYSQL_LOG* log);
+  virtual void pack_info(String* packet);
+  int net_send(THD* thd, const char* log_name, my_off_t pos);
+  static void init_show_field_list(List<Item>* field_list);
+  virtual int exec_event(struct st_relay_log_info* rli);
+  virtual const char* get_db()
+  {
+    return thd ? thd->db : 0;
+  }
+#else
+ // avoid having to link mysqlbinlog against libpthread
+  static Log_event* read_log_event(IO_CACHE* file, bool old_format);
+  virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
+  void print_timestamp(FILE* file, time_t *ts = 0);
+  void print_header(FILE* file);
 #endif  
 
   static void *operator new(size_t size)
   {
     return (void*) my_malloc((uint)size, MYF(MY_WME|MY_FAE));
   }
-
   static void operator delete(void *ptr, size_t size)
   {
     my_free((gptr) ptr, MYF(MY_WME|MY_ALLOW_ZERO_PTR));
@@ -237,64 +268,35 @@ public:
   int write(IO_CACHE* file);
   int write_header(IO_CACHE* file);
   virtual int write_data(IO_CACHE* file)
-    { return write_data_header(file) || write_data_body(file); }
+  { return write_data_header(file) || write_data_body(file); }
   virtual int write_data_header(IO_CACHE* file __attribute__((unused)))
-    { return 0; }
+  { return 0; }
   virtual int write_data_body(IO_CACHE* file __attribute__((unused)))
-    { return 0; }
+  { return 0; }
   virtual Log_event_type get_type_code() = 0;
   virtual bool is_valid() = 0;
   virtual bool get_cache_stmt() { return 0; }
   Log_event(const char* buf, bool old_format);
-#ifndef MYSQL_CLIENT  
-  Log_event(THD* thd_arg, uint16 flags_arg = 0);
-#endif  
   virtual ~Log_event() { free_temp_buf();}
   void register_temp_buf(char* buf) { temp_buf = buf; }
   void free_temp_buf()
+  {
+    if (temp_buf)
     {
-      if (temp_buf)
-      {
-        my_free(temp_buf, MYF(0));
-        temp_buf = 0;
-      }
+      my_free(temp_buf, MYF(0));
+      temp_buf = 0;
     }
+  }
   virtual int get_data_size() { return 0;}
   virtual int get_data_body_offset() { return 0; }
-  int get_event_len() { return cached_event_len ? cached_event_len :
-    (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()); }
-#ifdef MYSQL_CLIENT  
-  virtual void print(FILE* file, bool short_form = 0, char* last_db = 0) = 0;
-  void print_timestamp(FILE* file, time_t *ts = 0);
-  void print_header(FILE* file);
-#endif
-  
-#ifndef MYSQL_CLIENT  
-  // if mutex is 0, the read will proceed without mutex
-  static Log_event* read_log_event(IO_CACHE* file,
-				   pthread_mutex_t* log_lock,
-				   bool old_format);
-#else // avoid having to link mysqlbinlog against libpthread
-  static Log_event* read_log_event(IO_CACHE* file, bool old_format);
-#endif  
+  int get_event_len()
+  {
+    return (cached_event_len ? cached_event_len :
+	    (cached_event_len = LOG_EVENT_HEADER_LEN + get_data_size()));
+  }
   static Log_event* read_log_event(const char* buf, int event_len,
 				   const char **error, bool old_format);
   const char* get_type_str();
-
-#ifndef MYSQL_CLIENT
-  static int read_log_event(IO_CACHE* file, String* packet,
-			    pthread_mutex_t* log_lock);
-  void set_log_pos(MYSQL_LOG* log);
-  virtual void pack_info(String* packet);
-  int net_send(THD* thd, const char* log_name, my_off_t pos);
-  static void init_show_field_list(List<Item>* field_list);
-  virtual int exec_event(struct st_relay_log_info* rli);
-  virtual const char* get_db()
-    {
-      return thd ? thd->db : 0;
-    }
-#endif
-  
 };
 
 
@@ -305,13 +307,16 @@ protected:
 public:
   const char* query;
   const char* db;
-  uint32 q_len; // if we already know the length of the query string
-  // we pass it here, so we would not have to call strlen()
-  // otherwise, set it to 0, in which case, we compute it with strlen()
+  /*
+    If we already know the length of the query string
+    we pass it with q_len, so we would not have to call strlen()
+    otherwise, set it to 0, in which case, we compute it with strlen()
+  */
+  uint32 q_len;
   uint32 db_len;
   uint16 error_code;
   ulong thread_id;
-#if !defined(MYSQL_CLIENT)
+#ifndef MYSQL_CLIENT
   bool cache_stmt;
 
   Query_log_event(THD* thd_arg, const char* query_arg,
@@ -320,6 +325,8 @@ public:
   void pack_info(String* packet);
   int exec_event(struct st_relay_log_info* rli);
   bool get_cache_stmt() { return cache_stmt; }
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif
 
   Query_log_event(const char* buf, int event_len, bool old_format);
@@ -336,17 +343,15 @@ public:
   bool is_valid() { return query != 0; }
   int get_data_size()
   {
-    return q_len + db_len + 2 +
-      4		// thread_id
-      + 4	// exec_time
-      + 2	// error_code
-      ;
+    return (q_len + db_len + 2
+	    + 4	// thread_id
+	    + 4	// exec_time
+	    + 2	// error_code
+	    );
   }
-#ifdef MYSQL_CLIENT
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
 };
 
+
 class Slave_log_event: public Log_event
 {
 protected:
@@ -364,18 +369,16 @@ public:
   Slave_log_event(THD* thd_arg, struct st_relay_log_info* rli);
   void pack_info(String* packet);
   int exec_event(struct st_relay_log_info* rli);
-#endif
-  
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
+#endif  
+
   Slave_log_event(const char* buf, int event_len);
   ~Slave_log_event();
   int get_data_size();
   bool is_valid() { return master_host != 0; }
   Log_event_type get_type_code() { return SLAVE_EVENT; }
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
   int write_data(IO_CACHE* file );
-
 };
 
 class Load_log_event: public Log_event
@@ -399,7 +402,7 @@ public:
   uint32 skip_lines;
   sql_ex_info sql_ex;
   
-#if !defined(MYSQL_CLIENT)
+#ifndef MYSQL_CLIENT
   String field_lens_buf;
   String fields_buf;
   
@@ -414,6 +417,8 @@ public:
       return exec_event(thd->slave_net,rli);
     }
   int exec_event(NET* net, struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif
 
   Load_log_event(const char* buf, int event_len, bool old_format);
@@ -427,18 +432,14 @@ public:
   bool is_valid() { return table_name != 0; }
   int get_data_size()
   {
-    return table_name_len + 2 + db_len + 2 + fname_len
-      + 4 // thread_id
-      + 4 // exec_time
-      + 4 // skip_lines
-      + 4 // field block len
-      + sql_ex.data_size() + field_block_len + num_fields;
-      ;
+    return (table_name_len + 2 + db_len + 2 + fname_len
+	    + 4 // thread_id
+	    + 4 // exec_time
+	    + 4 // skip_lines
+	    + 4 // field block len
+	    + sql_ex.data_size() + field_block_len + num_fields);
   }
   int get_data_body_offset() { return LOAD_EVENT_OVERHEAD; }
-#ifdef MYSQL_CLIENT
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
 };
 
 extern char server_version[SERVER_VERSION_LENGTH];
@@ -449,13 +450,19 @@ public:
   uint32 created;
   uint16 binlog_version;
   char server_version[ST_SERVER_VER_LEN];
-#ifndef MYSQL_CLIENT  
+
+#ifndef MYSQL_CLIENT
   Start_log_event() :Log_event((THD*)0),binlog_version(BINLOG_VERSION)
   {
     created = (uint32) when;
     memcpy(server_version, ::server_version, ST_SERVER_VER_LEN);
   }
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif  
+
   Start_log_event(const char* buf, bool old_format);
   ~Start_log_event() {}
   Log_event_type get_type_code() { return START_EVENT;}
@@ -465,25 +472,25 @@ public:
   {
     return START_HEADER_LEN;
   }
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
 };
 
+
 class Intvar_log_event: public Log_event
 {
 public:
   ulonglong val;
   uchar type;
+
 #ifndef MYSQL_CLIENT  
   Intvar_log_event(THD* thd_arg,uchar type_arg, ulonglong val_arg)
     :Log_event(thd_arg),val(val_arg),type(type_arg)
   {}
-#endif
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
+#endif  
+
   Intvar_log_event(const char* buf, bool old_format);
   ~Intvar_log_event() {}
   Log_event_type get_type_code() { return INTVAR_EVENT;}
@@ -491,38 +498,29 @@ public:
   int get_data_size() { return  sizeof(type) + sizeof(val);}
   int write_data(IO_CACHE* file);
   bool is_valid() { return 1; }
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
-  
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
 };
 
+
 class Stop_log_event: public Log_event
 {
 public:
 #ifndef MYSQL_CLIENT  
   Stop_log_event() :Log_event((THD*)0)
   {}
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif  
-  Stop_log_event(const char* buf, bool old_format):Log_event(buf,
-							     old_format)
-  {
-  }
+
+  Stop_log_event(const char* buf, bool old_format):
+    Log_event(buf, old_format)
+  {}
   ~Stop_log_event() {}
   Log_event_type get_type_code() { return STOP_EVENT;}
   bool is_valid() { return 1; }
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif
-#ifndef MYSQL_CLIENT
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
 };
 
+
 class Rotate_log_event: public Log_event
 {
 public:
@@ -532,14 +530,18 @@ public:
   bool alloced;
 #ifndef MYSQL_CLIENT  
   Rotate_log_event(THD* thd_arg, const char* new_log_ident_arg,
-		   uint ident_len_arg = 0,ulonglong pos_arg = 4) :
-    Log_event(thd_arg),
-    new_log_ident(new_log_ident_arg),
+		   uint ident_len_arg = 0,ulonglong pos_arg = 4)
+    : Log_event(thd_arg), new_log_ident(new_log_ident_arg),
     ident_len(ident_len_arg ? ident_len_arg :
 	      (uint) strlen(new_log_ident_arg)), pos(pos_arg),
     alloced(0)
   {}
-#endif  
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
+#endif
+
   Rotate_log_event(const char* buf, int event_len, bool old_format);
   ~Rotate_log_event()
   {
@@ -550,13 +552,6 @@ public:
   int get_data_size() { return  ident_len + ROTATE_HEADER_LEN;}
   bool is_valid() { return new_log_ident != 0; }
   int write_data(IO_CACHE* file);
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
 };
 
 /* the classes below are for the new LOAD DATA INFILE logging */
@@ -564,51 +559,59 @@ public:
 class Create_file_log_event: public Load_log_event
 {
 protected:
-  // pretend we are Load event, so we can write out just
-  // our Load part - used on the slave when writing event out to
-  // SQL_LOAD-*.info file
+  /*
+    Pretend we are Load event, so we can write out just
+    our Load part - used on the slave when writing event out to
+    SQL_LOAD-*.info file
+  */
   bool fake_base; 
 public:
   char* block;
   uint block_len;
   uint file_id;
   bool inited_from_old;
+
 #ifndef MYSQL_CLIENT
   Create_file_log_event(THD* thd, sql_exchange* ex, const char* db_arg,
 			const char* table_name_arg,
 			List<Item>& fields_arg,
 			enum enum_duplicates handle_dup,
 			char* block_arg, uint block_len_arg);
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif  
   
   Create_file_log_event(const char* buf, int event_len, bool old_format);
-  ~Create_file_log_event()
+  ~Create_file_log_event() {}
+
+  Log_event_type get_type_code()
   {
+    return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
+  }
+  int get_data_size()
+  {
+    return (fake_base ? Load_log_event::get_data_size() :
+	    Load_log_event::get_data_size() +
+	    4 + 1 + block_len);
+  }
+  int get_data_body_offset()
+  {
+    return (fake_base ? LOAD_EVENT_OVERHEAD:
+	    LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN);
   }
-  Log_event_type get_type_code()
-    {
-     return fake_base ? Load_log_event::get_type_code() : CREATE_FILE_EVENT;
-    }
-  int get_data_size() { return  fake_base ? Load_log_event::get_data_size() :
-			  Load_log_event::get_data_size() +
-			  4 + 1 + block_len;}
-  int get_data_body_offset() { return fake_base ? LOAD_EVENT_OVERHEAD:
-    LOAD_EVENT_OVERHEAD + CREATE_FILE_HEADER_LEN; }
   bool is_valid() { return inited_from_old || block != 0; }
   int write_data_header(IO_CACHE* file);
   int write_data_body(IO_CACHE* file);
-  int write_base(IO_CACHE* file); // cut out Create_file extentions and
-  // write it as Load event - used on the slave
-
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
+  /*
+    Cut out Create_file extentions and
+    write it as Load event - used on the slave
+  */
+  int write_base(IO_CACHE* file);
 };
 
+
 class Append_block_log_event: public Log_event
 {
 public:
@@ -618,27 +621,22 @@ public:
   
 #ifndef MYSQL_CLIENT
   Append_block_log_event(THD* thd, char* block_arg,
-		       uint block_len_arg);
+			 uint block_len_arg);
   int exec_event(struct st_relay_log_info* rli);
-#endif  
+  void pack_info(String* packet);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
+#endif
   
   Append_block_log_event(const char* buf, int event_len);
-  ~Append_block_log_event()
-  {
-  }
+  ~Append_block_log_event() {}
   Log_event_type get_type_code() { return APPEND_BLOCK_EVENT;}
   int get_data_size() { return  block_len + APPEND_BLOCK_HEADER_LEN ;}
   bool is_valid() { return block != 0; }
   int write_data(IO_CACHE* file);
-
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-#endif  
 };
 
+
 class Delete_file_log_event: public Log_event
 {
 public:
@@ -646,24 +644,18 @@ public:
   
 #ifndef MYSQL_CLIENT
   Delete_file_log_event(THD* thd);
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif  
   
   Delete_file_log_event(const char* buf, int event_len);
-  ~Delete_file_log_event()
-  {
-  }
+  ~Delete_file_log_event() {}
   Log_event_type get_type_code() { return DELETE_FILE_EVENT;}
   int get_data_size() { return DELETE_FILE_HEADER_LEN ;}
   bool is_valid() { return file_id != 0; }
   int write_data(IO_CACHE* file);
-
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
 };
 
 class Execute_load_log_event: public Log_event
@@ -673,27 +665,18 @@ public:
   
 #ifndef MYSQL_CLIENT
   Execute_load_log_event(THD* thd);
+  void pack_info(String* packet);
+  int exec_event(struct st_relay_log_info* rli);
+#else
+  void print(FILE* file, bool short_form = 0, char* last_db = 0);
 #endif  
   
   Execute_load_log_event(const char* buf, int event_len);
-  ~Execute_load_log_event()
-  {
-  }
+  ~Execute_load_log_event() {}
   Log_event_type get_type_code() { return EXEC_LOAD_EVENT;}
   int get_data_size() { return  EXEC_LOAD_HEADER_LEN ;}
   bool is_valid() { return file_id != 0; }
   int write_data(IO_CACHE* file);
-
-#ifdef MYSQL_CLIENT  
-  void print(FILE* file, bool short_form = 0, char* last_db = 0);
-#endif  
-#ifndef MYSQL_CLIENT
-  void pack_info(String* packet);
-  int exec_event(struct st_relay_log_info* rli);
-#endif  
 };
 
-#endif
-
-
-
+#endif /* _log_event_h */