List:Commits« Previous MessageNext Message »
From:vvaintroub Date:April 8 2008 12:30pm
Subject:bk commit into 5.1 tree (vvaintroub:1.2571) BUG#32082
View as plain text  
Below is the list of changes that have just been committed into a local
5.1 repository of vvaintroub.  When vvaintroub 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, 2008-04-08 12:30:06+02:00, vvaintroub@wva. +122 -0
  Bug#32082 : definition of VOID in my_global.h conflicts with Windows
  SDK headers
  
  VOID macro is now removed. Its usage is replaced with void cast.
  In some cases, where cast does not make much sense (pthread_*, printf, 
  hash_delete, my_seek), cast is ommited.

  client/mysqladmin.cc@stripped, 2008-04-08 12:28:59+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  client/mysqldump.c@stripped, 2008-04-08 12:29:00+02:00, vvaintroub@wva. +5 -5
    Bug#32082 : remove VOID macro

  client/mysqlimport.c@stripped, 2008-04-08 12:29:00+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  client/mysqlslap.c@stripped, 2008-04-08 12:29:00+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  client/mysqltest.c@stripped, 2008-04-08 12:29:01+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  client/sql_string.cc@stripped, 2008-04-08 12:29:01+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  extra/comp_err.c@stripped, 2008-04-08 12:29:02+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  extra/replace.c@stripped, 2008-04-08 12:29:02+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  include/my_alarm.h@stripped, 2008-04-08 12:29:03+02:00, vvaintroub@wva. +5 -5
    Bug#32082 : remove VOID macro

  include/my_global.h@stripped, 2008-04-08 12:29:03+02:00, vvaintroub@wva. +0 -11
    Bug#32082 : remove VOID macro

  libmysql/libmysql.c@stripped, 2008-04-08 12:29:04+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/hash.c@stripped, 2008-04-08 12:29:04+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/mf_iocache2.c@stripped, 2008-04-08 12:29:05+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  mysys/mf_keycache.c@stripped, 2008-04-08 12:29:05+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  mysys/mf_loadpath.c@stripped, 2008-04-08 12:29:06+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  mysys/mf_path.c@stripped, 2008-04-08 12:29:06+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  mysys/my_append.c@stripped, 2008-04-08 12:29:06+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  mysys/my_clock.c@stripped, 2008-04-08 12:29:07+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/my_copy.c@stripped, 2008-04-08 12:29:07+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  mysys/my_fstream.c@stripped, 2008-04-08 12:29:08+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  mysys/my_getwd.c@stripped, 2008-04-08 12:29:08+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/my_lib.c@stripped, 2008-04-08 12:29:09+02:00, vvaintroub@wva. +11 -11
    Bug#32082 : remove VOID macro

  mysys/my_lockmem.c@stripped, 2008-04-08 12:29:09+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  mysys/my_pread.c@stripped, 2008-04-08 12:29:10+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/my_pthread.c@stripped, 2008-04-08 12:29:10+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  mysys/my_redel.c@stripped, 2008-04-08 12:29:10+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  mysys/my_winthread.c@stripped, 2008-04-08 12:29:11+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/my_write.c@stripped, 2008-04-08 12:29:11+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  mysys/thr_alarm.c@stripped, 2008-04-08 12:29:12+02:00, vvaintroub@wva. +10 -10
    Bug#32082 : remove VOID macro

  mysys/thr_lock.c@stripped, 2008-04-08 12:29:12+02:00, vvaintroub@wva. +10 -10
    Bug#32082 : remove VOID macro

  sql/derror.cc@stripped, 2008-04-08 12:29:13+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  sql/des_key_file.cc@stripped, 2008-04-08 12:29:13+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/discover.cc@stripped, 2008-04-08 12:29:14+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/field.cc@stripped, 2008-04-08 12:29:14+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/filesort.cc@stripped, 2008-04-08 12:29:14+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/ha_ndbcluster.cc@stripped, 2008-04-08 12:29:15+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/ha_partition.cc@stripped, 2008-04-08 12:29:15+02:00, vvaintroub@wva. +15 -15
    Bug#32082 : remove VOID macro

  sql/handler.cc@stripped, 2008-04-08 12:29:16+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  sql/hostname.cc@stripped, 2008-04-08 12:29:16+02:00, vvaintroub@wva. +14 -14
    Bug#32082 : remove VOID macro

  sql/init.cc@stripped, 2008-04-08 12:29:17+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/item.cc@stripped, 2008-04-08 12:29:17+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/item_cmpfunc.cc@stripped, 2008-04-08 12:29:18+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/item_strfunc.cc@stripped, 2008-04-08 12:29:18+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/lock.cc@stripped, 2008-04-08 12:29:19+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/log.cc@stripped, 2008-04-08 12:29:19+02:00, vvaintroub@wva. +10 -10
    Bug#32082 : remove VOID macro

  sql/log_event.cc@stripped, 2008-04-08 12:29:20+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  sql/mysqld.cc@stripped, 2008-04-08 12:29:20+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/opt_range.h@stripped, 2008-04-08 12:29:21+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/parse_file.cc@stripped, 2008-04-08 12:29:21+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/protocol.cc@stripped, 2008-04-08 12:29:22+02:00, vvaintroub@wva. +7 -7
    Bug#32082 : remove VOID macro

  sql/records.cc@stripped, 2008-04-08 12:29:22+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  sql/slave.cc@stripped, 2008-04-08 12:29:23+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  sql/sp_head.cc@stripped, 2008-04-08 12:29:23+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  sql/sp_pcontext.cc@stripped, 2008-04-08 12:29:24+02:00, vvaintroub@wva. +20 -20
    Bug#32082 : remove VOID macro

  sql/sql_acl.cc@stripped, 2008-04-08 12:29:24+02:00, vvaintroub@wva. +50 -50
    Bug#32082 : remove VOID macro

  sql/sql_base.cc@stripped, 2008-04-08 12:29:25+02:00, vvaintroub@wva. +54 -54
    Bug#32082 : remove VOID macro

  sql/sql_cache.cc@stripped, 2008-04-08 12:29:25+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/sql_connect.cc@stripped, 2008-04-08 12:29:26+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/sql_db.cc@stripped, 2008-04-08 12:29:26+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  sql/sql_delete.cc@stripped, 2008-04-08 12:29:26+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/sql_handler.cc@stripped, 2008-04-08 12:29:27+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/sql_insert.cc@stripped, 2008-04-08 12:29:27+02:00, vvaintroub@wva. +10 -10
    Bug#32082 : remove VOID macro

  sql/sql_map.cc@stripped, 2008-04-08 12:29:28+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  sql/sql_parse.cc@stripped, 2008-04-08 12:29:28+02:00, vvaintroub@wva. +10 -10
    Bug#32082 : remove VOID macro

  sql/sql_select.cc@stripped, 2008-04-08 12:29:29+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  sql/sql_servers.cc@stripped, 2008-04-08 12:29:29+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/sql_show.cc@stripped, 2008-04-08 12:29:30+02:00, vvaintroub@wva. +11 -11
    Bug#32082 : remove VOID macro

  sql/sql_string.cc@stripped, 2008-04-08 12:29:30+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  sql/sql_table.cc@stripped, 2008-04-08 12:29:31+02:00, vvaintroub@wva. +52 -52
    Bug#32082 : remove VOID macro

  sql/sql_test.cc@stripped, 2008-04-08 12:29:31+02:00, vvaintroub@wva. +14 -14
    Bug#32082 : remove VOID macro

  sql/sql_trigger.cc@stripped, 2008-04-08 12:29:32+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/sql_update.cc@stripped, 2008-04-08 12:29:32+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/sql_view.cc@stripped, 2008-04-08 12:29:33+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  sql/stacktrace.c@stripped, 2008-04-08 12:29:33+02:00, vvaintroub@wva. +0 -3
    Remove workaround for Bug#32082

  sql/table.cc@stripped, 2008-04-08 12:29:34+02:00, vvaintroub@wva. +15 -15
    Bug#32082 : remove VOID macro

  sql/tztime.cc@stripped, 2008-04-08 12:29:34+02:00, vvaintroub@wva. +4 -4
    Bug#32082 : remove VOID macro

  sql/udf_example.c@stripped, 2008-04-08 12:29:35+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  sql/uniques.cc@stripped, 2008-04-08 12:29:35+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  sql/unireg.cc@stripped, 2008-04-08 12:29:36+02:00, vvaintroub@wva. +7 -7
    Bug#32082 : remove VOID macro

  storage/archive/ha_archive.cc@stripped, 2008-04-08 12:29:36+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  storage/blackhole/ha_blackhole.cc@stripped, 2008-04-08 12:29:36+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/csv/ha_tina.cc@stripped, 2008-04-08 12:29:37+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/csv/transparent_file.cc@stripped, 2008-04-08 12:29:37+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/example/ha_example.cc@stripped, 2008-04-08 12:29:38+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/federated/ha_federated.cc@stripped, 2008-04-08 12:29:38+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/heap/hp_clear.c@stripped, 2008-04-08 12:29:39+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/heap/hp_create.c@stripped, 2008-04-08 12:29:39+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/heap/hp_test1.c@stripped, 2008-04-08 12:29:40+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/heap/hp_test2.c@stripped, 2008-04-08 12:29:40+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/innobase/handler/ha_innodb.cc@stripped, 2008-04-08 12:29:41+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/ft_eval.c@stripped, 2008-04-08 12:29:41+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/ha_myisam.cc@stripped, 2008-04-08 12:29:42+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  storage/myisam/mi_changed.c@stripped, 2008-04-08 12:29:42+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_check.c@stripped, 2008-04-08 12:29:42+02:00, vvaintroub@wva. +35 -35
    Bug#32082 : remove VOID macro

  storage/myisam/mi_close.c@stripped, 2008-04-08 12:29:43+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/myisam/mi_create.c@stripped, 2008-04-08 12:29:43+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/myisam/mi_dbug.c@stripped, 2008-04-08 12:29:44+02:00, vvaintroub@wva. +18 -18
    Bug#32082 : remove VOID macro

  storage/myisam/mi_delete.c@stripped, 2008-04-08 12:29:44+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/mi_delete_all.c@stripped, 2008-04-08 12:29:45+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/mi_dynrec.c@stripped, 2008-04-08 12:29:45+02:00, vvaintroub@wva. +6 -6
    Bug#32082 : remove VOID macro

  storage/myisam/mi_info.c@stripped, 2008-04-08 12:29:46+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_locking.c@stripped, 2008-04-08 12:29:46+02:00, vvaintroub@wva. +9 -9
    Bug#32082 : remove VOID macro

  storage/myisam/mi_log.c@stripped, 2008-04-08 12:29:46+02:00, vvaintroub@wva. +7 -7
    Bug#32082 : remove VOID macro

  storage/myisam/mi_open.c@stripped, 2008-04-08 12:29:47+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  storage/myisam/mi_packrec.c@stripped, 2008-04-08 12:29:47+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/myisam/mi_panic.c@stripped, 2008-04-08 12:29:48+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_rsame.c@stripped, 2008-04-08 12:29:48+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/mi_statrec.c@stripped, 2008-04-08 12:29:49+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_test1.c@stripped, 2008-04-08 12:29:49+02:00, vvaintroub@wva. +3 -3
    Bug#32082 : remove VOID macro

  storage/myisam/mi_test2.c@stripped, 2008-04-08 12:29:50+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_test3.c@stripped, 2008-04-08 12:29:50+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisam/mi_update.c@stripped, 2008-04-08 12:29:50+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/mi_write.c@stripped, 2008-04-08 12:29:51+02:00, vvaintroub@wva. +2 -2
    Bug#32082 : remove VOID macro

  storage/myisam/myisamchk.c@stripped, 2008-04-08 12:29:51+02:00, vvaintroub@wva. +43 -43
    Bug#32082 : remove VOID macro

  storage/myisam/myisamlog.c@stripped, 2008-04-08 12:29:52+02:00, vvaintroub@wva. +25 -25
    Bug#32082 : remove VOID macro

  storage/myisam/myisampack.c@stripped, 2008-04-08 12:29:52+02:00, vvaintroub@wva. +110 -110
    Bug#32082 : remove VOID macro

  storage/myisam/sort.c@stripped, 2008-04-08 12:29:53+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisammrg/myrg_close.c@stripped, 2008-04-08 12:29:53+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisammrg/myrg_create.c@stripped, 2008-04-08 12:29:54+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

  storage/myisammrg/myrg_open.c@stripped, 2008-04-08 12:29:54+02:00, vvaintroub@wva. +12 -12
    Bug#32082 : remove VOID macro

  strings/str_test.c@stripped, 2008-04-08 12:29:55+02:00, vvaintroub@wva. +8 -8
    Bug#32082 : remove VOID macro

  tests/thread_test.c@stripped, 2008-04-08 12:29:55+02:00, vvaintroub@wva. +1 -1
    Bug#32082 : remove VOID macro

diff -Nrup a/client/mysqladmin.cc b/client/mysqladmin.cc
--- a/client/mysqladmin.cc	2007-09-15 05:10:27 +02:00
+++ b/client/mysqladmin.cc	2008-04-08 12:28:59 +02:00
@@ -344,8 +344,8 @@ int main(int argc,char *argv[])
   if (tty_password)
     opt_password = get_tty_password(NullS);
 
-  VOID(signal(SIGINT,endprog));			/* Here if abort */
-  VOID(signal(SIGTERM,endprog));		/* Here if abort */
+  (void) signal(SIGINT,endprog);			/* Here if abort */
+  (void) signal(SIGTERM,endprog);		/* Here if abort */
 
   if (opt_compress)
     mysql_options(&mysql,MYSQL_OPT_COMPRESS,NullS);
@@ -1071,7 +1071,7 @@ static int drop_db(MYSQL *mysql, const c
     puts("Any data stored in the database will be destroyed.\n");
     printf("Do you really want to drop the '%s' database [y/N] ",db);
     fflush(stdout);
-    VOID(fgets(buf,sizeof(buf)-1,stdin));
+    (void) fgets(buf,sizeof(buf)-1,stdin);
     if ((*buf != 'y') && (*buf != 'Y'))
     {
       puts("\nOK, aborting database drop!");
diff -Nrup a/client/mysqldump.c b/client/mysqldump.c
--- a/client/mysqldump.c	2008-03-28 11:03:00 +01:00
+++ b/client/mysqldump.c	2008-04-08 12:29:00 +02:00
@@ -1999,7 +1999,7 @@ static uint dump_events_for_db(char *db)
   mysql_free_result(event_list_res);
 
   if (lock_tables)
-    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
+    (void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
   DBUG_RETURN(0);
 }
 
@@ -2193,7 +2193,7 @@ static uint dump_routines_for_db(char *d
     DBUG_RETURN(1);
 
   if (lock_tables)
-    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
+    (void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
   DBUG_RETURN(0);
 }
 
@@ -4048,7 +4048,7 @@ static int dump_all_tables_in_db(char *d
     check_io(md_result_file);
   }
   if (lock_tables)
-    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
+    (void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
   if (flush_privileges && using_mysql_db == 0)
   {
     fprintf(md_result_file,"\n--\n-- Flush Grant Tables \n--\n");
@@ -4122,7 +4122,7 @@ static my_bool dump_all_views_in_db(char
     check_io(md_result_file);
   }
   if (lock_tables)
-    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
+    (void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
   return 0;
 } /* dump_all_tables_in_db */
 
@@ -4291,7 +4291,7 @@ static int dump_selected_tables(char *db
     check_io(md_result_file);
   }
   if (lock_tables)
-    VOID(mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES"));
+    (void) mysql_query_with_error_report(mysql, 0, "UNLOCK TABLES");
   DBUG_RETURN(0);
 } /* dump_selected_tables */
 
diff -Nrup a/client/mysqlimport.c b/client/mysqlimport.c
--- a/client/mysqlimport.c	2007-11-08 12:18:00 +01:00
+++ b/client/mysqlimport.c	2008-04-08 12:29:00 +02:00
@@ -601,8 +601,8 @@ int main(int argc, char **argv)
     pthread_attr_setdetachstate(&attr,
                                 PTHREAD_CREATE_DETACHED);
 
-    VOID(pthread_mutex_init(&counter_mutex, NULL));
-    VOID(pthread_cond_init(&count_threshhold, NULL));
+    pthread_mutex_init(&counter_mutex, NULL);
+    pthread_cond_init(&count_threshhold, NULL);
 
     for (counter= 0; *argv != NULL; argv++) /* Loop through tables */
     {
@@ -641,8 +641,8 @@ int main(int argc, char **argv)
       pthread_cond_timedwait(&count_threshhold, &counter_mutex, &abstime);
     }
     pthread_mutex_unlock(&counter_mutex);
-    VOID(pthread_mutex_destroy(&counter_mutex));
-    VOID(pthread_cond_destroy(&count_threshhold));
+    pthread_mutex_destroy(&counter_mutex);
+    pthread_cond_destroy(&count_threshhold);
     pthread_attr_destroy(&attr);
   }
   else
diff -Nrup a/client/mysqlslap.c b/client/mysqlslap.c
--- a/client/mysqlslap.c	2008-02-08 12:13:25 +01:00
+++ b/client/mysqlslap.c	2008-04-08 12:29:00 +02:00
@@ -352,10 +352,10 @@ int main(int argc, char **argv)
     }
   }
 
-  VOID(pthread_mutex_init(&counter_mutex, NULL));
-  VOID(pthread_cond_init(&count_threshhold, NULL));
-  VOID(pthread_mutex_init(&sleeper_mutex, NULL));
-  VOID(pthread_cond_init(&sleep_threshhold, NULL));
+  pthread_mutex_init(&counter_mutex, NULL);
+  pthread_cond_init(&count_threshhold, NULL);
+  pthread_mutex_init(&sleeper_mutex, NULL);
+  pthread_cond_init(&sleep_threshhold, NULL);
 
   /* Main iterations loop */
   eptr= engine_options;
@@ -386,10 +386,10 @@ int main(int argc, char **argv)
 
   } while (eptr ? (eptr= eptr->next) : 0);
 
-  VOID(pthread_mutex_destroy(&counter_mutex));
-  VOID(pthread_cond_destroy(&count_threshhold));
-  VOID(pthread_mutex_destroy(&sleeper_mutex));
-  VOID(pthread_cond_destroy(&sleep_threshhold));
+  pthread_mutex_destroy(&counter_mutex);
+  pthread_cond_destroy(&count_threshhold);
+  pthread_mutex_destroy(&sleeper_mutex);
+  pthread_cond_destroy(&sleep_threshhold);
 
   if (!opt_only_print) 
     mysql_close(&mysql); /* Close & free connection */
diff -Nrup a/client/mysqltest.c b/client/mysqltest.c
--- a/client/mysqltest.c	2008-03-30 13:12:23 +02:00
+++ b/client/mysqltest.c	2008-04-08 12:29:01 +02:00
@@ -504,12 +504,12 @@ pthread_handler_t send_one_query(void *a
   struct st_connection *cn= (struct st_connection*)arg;
 
   mysql_thread_init();
-  VOID(mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len));
+  (void) mysql_send_query(&cn->mysql, cn->cur_query, cn->cur_query_len);
 
   mysql_thread_end();
   pthread_mutex_lock(&cn->mutex);
   cn->query_done= 1;
-  VOID(pthread_cond_signal(&cn->cond));
+  pthread_cond_signal(&cn->cond);
   pthread_mutex_unlock(&cn->mutex);
   pthread_exit(0);
   return 0;
@@ -8150,7 +8150,7 @@ REPLACE *init_replace(char * *from, char
     free_sets(&sets);
     DBUG_RETURN(0);
   }
-  VOID(make_new_set(&sets));			/* Set starting set */
+  (void) make_new_set(&sets);			/* Set starting set */
   make_sets_invisible(&sets);			/* Hide previus sets */
   used_sets=-1;
   word_states=make_new_set(&sets);		/* Start of new word */
@@ -8649,7 +8649,7 @@ int insert_pointer_name(reg1 POINTER_ARR
   pa->flag[pa->typelib.count]=0;			/* Reset flag */
   pa->typelib.type_names[pa->typelib.count++]= (char*) pa->str+pa->length;
   pa->typelib.type_names[pa->typelib.count]= NullS;	/* Put end-mark */
-  VOID(strmov((char*) pa->str+pa->length,name));
+  (void) strmov((char*) pa->str+pa->length,name);
   pa->length+=length;
   DBUG_RETURN(0);
 } /* insert_pointer_name */
diff -Nrup a/client/sql_string.cc b/client/sql_string.cc
--- a/client/sql_string.cc	2007-08-13 15:11:09 +02:00
+++ b/client/sql_string.cc	2008-04-08 12:29:01 +02:00
@@ -132,7 +132,7 @@ bool String::set(double num,uint decimal
   int decpt,sign;
   char *pos,*to;
 
-  VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
+  (void) fconvert(num,(int) decimals,&decpt,&sign,buff+1);
   if (!my_isdigit(&my_charset_latin1, buff[1]))
   {						// Nan or Inf
     pos=buff+1;
diff -Nrup a/extra/comp_err.c b/extra/comp_err.c
--- a/extra/comp_err.c	2007-10-05 19:58:12 +02:00
+++ b/extra/comp_err.c	2008-04-08 12:29:02 +02:00
@@ -1039,11 +1039,11 @@ static char *parse_text_line(char *pos)
       switch (*++pos) {
       case '\\':
       case '"':
-	VOID(strmov(pos - 1, pos));
+	(void) strmov(pos - 1, pos);
 	break;
       case 'n':
 	pos[-1]= '\n';
-	VOID(strmov(pos, pos + 1));
+	(void) strmov(pos, pos + 1);
 	break;
       default:
 	if (*pos >= '0' && *pos < '8')
@@ -1053,10 +1053,10 @@ static char *parse_text_line(char *pos)
 	    nr= nr * 8 + (*(pos++) - '0');
 	  pos -= i;
 	  pos[-1]= nr;
-	  VOID(strmov(pos, pos + i));
+	  (void) strmov(pos, pos + i);
 	}
 	else if (*pos)
-	  VOID(strmov(pos - 1, pos));		/* Remove '\' */
+	  (void) strmov(pos - 1, pos);		/* Remove '\' */
       }
     }
     else
diff -Nrup a/extra/replace.c b/extra/replace.c
--- a/extra/replace.c	2008-02-18 23:29:35 +01:00
+++ b/extra/replace.c	2008-04-08 12:29:02 +02:00
@@ -311,7 +311,7 @@ static int insert_pointer_name(reg1 POIN
   pa->flag[pa->typelib.count]=0;			/* Reset flag */
   pa->typelib.type_names[pa->typelib.count++]= (char*) (pa->str+pa->length);
   pa->typelib.type_names[pa->typelib.count]= NullS;	/* Put end-mark */
-  VOID(strmov((char*) pa->str + pa->length, name));
+  (void) strmov((char*) pa->str + pa->length, name);
   pa->length+=length;
   DBUG_RETURN(0);
 } /* insert_pointer_name */
@@ -433,7 +433,7 @@ static REPLACE *init_replace(char * *fro
     free_sets(&sets);
     DBUG_RETURN(0);
   }
-  VOID(make_new_set(&sets));			/* Set starting set */
+  (void) make_new_set(&sets);			/* Set starting set */
   make_sets_invisible(&sets);			/* Hide previus sets */
   used_sets=-1;
   word_states=make_new_set(&sets);		/* Start of new word */
diff -Nrup a/include/my_alarm.h b/include/my_alarm.h
--- a/include/my_alarm.h	2006-12-23 20:04:04 +01:00
+++ b/include/my_alarm.h	2008-04-08 12:29:03 +02:00
@@ -33,15 +33,15 @@ extern ulong my_time_to_wait_for_lock;
 #define ALARM_INIT	my_have_got_alarm=0 ; \
 			alarm_old=(uint) alarm(MY_HOW_OFTEN_TO_ALARM); \
 			alarm_signal=signal(SIGALRM,my_set_alarm_variable);
-#define ALARM_END	VOID(signal(SIGALRM,alarm_signal)); \
-			VOID(alarm(alarm_old));
+#define ALARM_END	(void) signal(SIGALRM,alarm_signal); \
+			(void) alarm(alarm_old);
 #define ALARM_TEST	my_have_got_alarm
 #ifdef DONT_REMEMBER_SIGNAL
-#define ALARM_REINIT	VOID(alarm(MY_HOW_OFTEN_TO_ALARM)); \
-			VOID(signal(SIGALRM,my_set_alarm_variable));\
+#define ALARM_REINIT	(void) alarm(MY_HOW_OFTEN_TO_ALARM); \
+			(void) signal(SIGALRM,my_set_alarm_variable);\
 			my_have_got_alarm=0;
 #else
-#define ALARM_REINIT	VOID(alarm((uint) MY_HOW_OFTEN_TO_ALARM)); \
+#define ALARM_REINIT	(void) alarm((uint) MY_HOW_OFTEN_TO_ALARM); \
 			my_have_got_alarm=0;
 #endif /* DONT_REMEMBER_SIGNAL */
 #else
diff -Nrup a/include/my_global.h b/include/my_global.h
--- a/include/my_global.h	2008-03-28 11:03:01 +01:00
+++ b/include/my_global.h	2008-04-08 12:29:03 +02:00
@@ -538,17 +538,6 @@ extern "C" int madvise(void *addr, size_
 #define DONT_REMEMBER_SIGNAL
 #endif
 
-/* Define void to stop lint from generating "null effekt" comments */
-#ifndef DONT_DEFINE_VOID
-#ifdef _lint
-int	__void__;
-#define VOID(X)		(__void__ = (int) (X))
-#else
-#undef VOID
-#define VOID(X)		(X)
-#endif
-#endif /* DONT_DEFINE_VOID */
-
 #if defined(_lint) || defined(FORCE_INIT_OF_VARS)
 #define LINT_INIT(var)	var=0			/* No uninitialize-warning */
 #else
diff -Nrup a/libmysql/libmysql.c b/libmysql/libmysql.c
--- a/libmysql/libmysql.c	2008-03-29 08:58:48 +01:00
+++ b/libmysql/libmysql.c	2008-04-08 12:29:04 +02:00
@@ -867,7 +867,7 @@ my_bool handle_local_infile(MYSQL *mysql
   if ((*options->local_infile_init)(&li_ptr, net_filename,
     options->local_infile_userdata))
   {
-    VOID(my_net_write(net,(const uchar*) "",0)); /* Server needs one packet */
+    (void) my_net_write(net,(const uchar*) "",0); /* Server needs one packet */
     net_flush(net);
     strmov(net->sqlstate, unknown_sqlstate);
     net->last_errno=
diff -Nrup a/mysys/hash.c b/mysys/hash.c
--- a/mysys/hash.c	2008-03-18 10:45:32 +01:00
+++ b/mysys/hash.c	2008-04-08 12:29:04 +02:00
@@ -525,7 +525,7 @@ my_bool hash_delete(HASH *hash,uchar *re
   pos->next=empty_index;
 
 exit:
-  VOID(pop_dynamic(&hash->array));
+  (void) pop_dynamic(&hash->array);
   if (hash->free)
     (*hash->free)((uchar*) record);
   DBUG_RETURN(0);
diff -Nrup a/mysys/mf_iocache2.c b/mysys/mf_iocache2.c
--- a/mysys/mf_iocache2.c	2007-08-08 18:20:59 +02:00
+++ b/mysys/mf_iocache2.c	2008-04-08 12:29:05 +02:00
@@ -135,7 +135,7 @@ void my_b_seek(IO_CACHE *info,my_off_t p
      b) see if there is a better way to make it work
   */
   if (info->type == SEQ_READ_APPEND)
-    VOID(flush_io_cache(info));
+    (void) flush_io_cache(info);
 
   offset=(pos - info->pos_in_file);
 
@@ -163,7 +163,7 @@ void my_b_seek(IO_CACHE *info,my_off_t p
       info->write_pos = info->write_buffer + offset;
       DBUG_VOID_RETURN;
     }
-    VOID(flush_io_cache(info));
+    (void) flush_io_cache(info);
     /* Correct buffer end so that we write in increments of IO_SIZE */
     info->write_end=(info->write_buffer+info->buffer_length-
 		     (pos & (IO_SIZE-1)));
diff -Nrup a/mysys/mf_keycache.c b/mysys/mf_keycache.c
--- a/mysys/mf_keycache.c	2008-03-31 09:40:35 +02:00
+++ b/mysys/mf_keycache.c	2008-04-08 12:29:05 +02:00
@@ -4401,8 +4401,8 @@ static void keycache_debug_print(const c
   va_start(args,fmt);
   if (keycache_debug_log)
   {
-    VOID(vfprintf(keycache_debug_log, fmt, args));
-    VOID(fputc('\n',keycache_debug_log));
+    (void) vfprintf(keycache_debug_log, fmt, args);
+    (void) fputc('\n',keycache_debug_log);
   }
   va_end(args);
 }
diff -Nrup a/mysys/mf_loadpath.c b/mysys/mf_loadpath.c
--- a/mysys/mf_loadpath.c	2007-05-10 11:59:25 +02:00
+++ b/mysys/mf_loadpath.c	2008-04-08 12:29:06 +02:00
@@ -34,7 +34,7 @@ char * my_load_path(char * to, const cha
 
   if ((path[0] == FN_HOMELIB && path[1] == FN_LIBCHAR) ||
       test_if_hard_path(path))
-    VOID(strmov(buff,path));
+    (void) strmov(buff,path);
   else if ((is_cur=(path[0] == FN_CURLIB && path[1] == FN_LIBCHAR)) ||
 	   (is_prefix(path,FN_PARENTDIR)) ||
 	   ! own_path_prefix)
@@ -42,12 +42,12 @@ char * my_load_path(char * to, const cha
     if (is_cur)
       is_cur=2;					/* Remove current dir */
     if (! my_getwd(buff,(uint) (FN_REFLEN-strlen(path)+is_cur),MYF(0)))
-      VOID(strcat(buff,path+is_cur));
+      (void) strcat(buff,path+is_cur);
     else
-      VOID(strmov(buff,path));			/* Return org file name */
+      (void) strmov(buff,path);			/* Return org file name */
   }
   else
-    VOID(strxmov(buff,own_path_prefix,path,NullS));
+    (void) strxmov(buff,own_path_prefix,path,NullS);
   strmov(to,buff);
   DBUG_PRINT("exit",("to: %s",to));
   DBUG_RETURN(to);
diff -Nrup a/mysys/mf_path.c b/mysys/mf_path.c
--- a/mysys/mf_path.c	2007-07-30 10:33:42 +02:00
+++ b/mysys/mf_path.c	2008-04-08 12:29:06 +02:00
@@ -42,7 +42,7 @@ char * my_path(char * to, const char *pr
 		   ((prog=getenv("_")) != 0 &&
                     dirname_part(to, prog, &to_length))))
   {
-    VOID(intern_filename(to,to));
+    (void) intern_filename(to,to);
     if (!test_if_hard_path(to))
     {
       if (!my_getwd(curr_dir,FN_REFLEN,MYF(0)))
@@ -60,11 +60,11 @@ char * my_path(char * to, const char *pr
       end= (char*) "/my/";
 #endif
     }
-    VOID(intern_filename(to,end));
+    (void) intern_filename(to,end);
     to=strend(to);
     if (to != start && to[-1] != FN_LIBCHAR)
       *to++ = FN_LIBCHAR;
-    VOID(strmov(to,own_pathname_part));
+    (void) strmov(to,own_pathname_part);
   }
   DBUG_PRINT("exit",("to: '%s'",start));
   DBUG_RETURN(start);
diff -Nrup a/mysys/my_append.c b/mysys/my_append.c
--- a/mysys/my_append.c	2007-07-30 10:33:42 +02:00
+++ b/mysys/my_append.c	2008-04-08 12:29:06 +02:00
@@ -58,7 +58,7 @@ int my_append(const char *from, const ch
     }
   }
 err:
-  if (from_file >= 0) VOID(my_close(from_file,MyFlags));
-  if (to_file >= 0)   VOID(my_close(to_file,MyFlags));
+  if (from_file >= 0) (void) my_close(from_file,MyFlags);
+  if (to_file >= 0)   (void) my_close(to_file,MyFlags);
   DBUG_RETURN(-1);
 }
diff -Nrup a/mysys/my_clock.c b/mysys/my_clock.c
--- a/mysys/my_clock.c	2006-12-23 20:19:46 +01:00
+++ b/mysys/my_clock.c	2008-04-08 12:29:07 +02:00
@@ -24,7 +24,7 @@ long my_clock(void)
 {
 #if !defined(__WIN__) && !defined(__NETWARE__)
   struct tms tmsbuf;
-  VOID(times(&tmsbuf));
+  (void) times(&tmsbuf);
   return (tmsbuf.tms_utime + tmsbuf.tms_stime);
 #else
   return clock();
diff -Nrup a/mysys/my_copy.c b/mysys/my_copy.c
--- a/mysys/my_copy.c	2007-07-30 10:33:42 +02:00
+++ b/mysys/my_copy.c	2008-04-08 12:29:07 +02:00
@@ -94,9 +94,9 @@ int my_copy(const char *from, const char
 
     if (MyFlags & MY_HOLD_ORIGINAL_MODES && !new_file_stat)
 	DBUG_RETURN(0);			/* File copyed but not stat */
-    VOID(chmod(to, stat_buff.st_mode & 07777)); /* Copy modes */
+    (void) chmod(to, stat_buff.st_mode & 07777); /* Copy modes */
 #if !defined(__WIN__) && !defined(__NETWARE__)
-    VOID(chown(to, stat_buff.st_uid,stat_buff.st_gid)); /* Copy ownership */
+    (void) chown(to, stat_buff.st_uid,stat_buff.st_gid); /* Copy ownership */
 #endif
 #if !defined(VMS) && !defined(__ZTC__)
     if (MyFlags & MY_COPYTIME)
@@ -104,19 +104,19 @@ int my_copy(const char *from, const char
       struct utimbuf timep;
       timep.actime  = stat_buff.st_atime;
       timep.modtime = stat_buff.st_mtime;
-      VOID(utime((char*) to, &timep)); /* last accessed and modified times */
+      (void) utime((char*) to, &timep); /* last accessed and modified times */
     }
 #endif
     DBUG_RETURN(0);
   }
 
 err:
-  if (from_file >= 0) VOID(my_close(from_file,MyFlags));
+  if (from_file >= 0) (void) my_close(from_file,MyFlags);
   if (to_file >= 0)
   {
-    VOID(my_close(to_file, MyFlags));
+    (void) my_close(to_file, MyFlags);
     /* attempt to delete the to-file we've partially written */
-    VOID(my_delete(to, MyFlags));
+    (void) my_delete(to, MyFlags);
   }
   DBUG_RETURN(-1);
 } /* my_copy */
diff -Nrup a/mysys/my_fstream.c b/mysys/my_fstream.c
--- a/mysys/my_fstream.c	2007-05-10 11:59:25 +02:00
+++ b/mysys/my_fstream.c	2008-04-08 12:29:08 +02:00
@@ -119,7 +119,7 @@ size_t my_fwrite(FILE *stream, const uch
 #ifdef EINTR
       if (errno == EINTR)
       {
-	VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
+	(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
 	continue;
       }
 #endif
@@ -134,8 +134,8 @@ size_t my_fwrite(FILE *stream, const uch
         if (!(errors++ % MY_WAIT_GIVE_USER_A_MESSAGE))
           my_error(EE_DISK_FULL,MYF(ME_BELL | ME_NOREFRESH),
                    "[stream]",my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
-        VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
-        VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
+        (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
+        (void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
         continue;
       }
 #endif
diff -Nrup a/mysys/my_getwd.c b/mysys/my_getwd.c
--- a/mysys/my_getwd.c	2007-05-10 11:59:25 +02:00
+++ b/mysys/my_getwd.c	2008-04-08 12:29:08 +02:00
@@ -51,7 +51,7 @@ int my_getwd(char * buf, size_t size, my
                    (long) buf, (uint) size, MyFlags));
 
   if (curr_dir[0])				/* Current pos is saved here */
-    VOID(strmake(buf,&curr_dir[0],size-1));
+    (void) strmake(buf,&curr_dir[0],size-1);
   else
   {
 #if defined(HAVE_GETCWD)
diff -Nrup a/mysys/my_lib.c b/mysys/my_lib.c
--- a/mysys/my_lib.c	2007-10-18 12:32:38 +02:00
+++ b/mysys/my_lib.c	2008-04-08 12:29:09 +02:00
@@ -160,8 +160,8 @@ MY_DIR	*my_dir(const char *path, myf MyF
         goto error;
       
       bzero(finfo.mystat, sizeof(MY_STAT));
-      VOID(strmov(tmp_file,dp->d_name));
-      VOID(my_stat(tmp_path, finfo.mystat, MyFlags));
+      (void) strmov(tmp_file,dp->d_name);
+      (void) my_stat(tmp_path, finfo.mystat, MyFlags);
       if (!(finfo.mystat->st_mode & MY_S_IREAD))
         continue;
     }
@@ -267,7 +267,7 @@ char * directory_file_name (char * dst, 
 	/* what about when we have logical_name:???? */
       if (src[slen] == FN_DEVCHAR)
       {				/* Xlate logical name and see what we get */
-	VOID(strmov(dst,src));
+	(void) strmov(dst,src);
 	dst[slen] = 0;				/* remove colon */
 	if (!(src = getenv (dst)))
 	  return dst;				/* Can't translate */
@@ -283,13 +283,13 @@ char * directory_file_name (char * dst, 
 	slen = strlen (src) - 1;
 	if (src[slen] != FN_C_AFTER_DIR && src[slen] != FN_C_AFTER_DIR_2)
 	{					/* no recursion here! */
-	  VOID(strmov(dst, src));
+	  (void) strmov(dst, src);
 	  return(dst);
 	}
       }
       else
       {						/* not a directory spec */
-	VOID(strmov(dst, src));
+	(void) strmov(dst, src);
 	return(dst);
       }
     }
@@ -297,13 +297,13 @@ char * directory_file_name (char * dst, 
     bracket = src[slen];			/* End char */
     if (!(ptr = strchr (src, bracket - 2)))
     {						/* no opening bracket */
-      VOID(strmov (dst, src));
+      (void) strmov (dst, src);
       return dst;
     }
     if (!(rptr = strrchr (src, '.')))
       rptr = ptr;
     slen = rptr - src;
-    VOID(strmake (dst, src, slen));
+    (void) strmake (dst, src, slen);
 
     if (*rptr == '.')
     {						/* Put bracket and add */
@@ -324,7 +324,7 @@ char * directory_file_name (char * dst, 
 	    && (ptr[rlen] == FN_C_AFTER_DIR || ptr[rlen] == FN_C_AFTER_DIR_2)
 	    && ptr[rlen - 1] == '.')
 	{
-	  VOID(strmov(esa,ptr));
+	  (void) strmov(esa,ptr);
 	  esa[rlen - 1] = FN_C_AFTER_DIR;
 	  esa[rlen] = '\0';
 	  return (directory_file_name (dst, esa));
@@ -332,13 +332,13 @@ char * directory_file_name (char * dst, 
 	else
 	  dst[slen - 1] = ':';
       }
-      VOID(strmov(dst+slen,"[000000]"));
+      (void) strmov(dst+slen,"[000000]");
       slen += 8;
     }
-    VOID(strmov(strmov(dst+slen,rptr+1)-1,".DIR.1"));
+    (void) strmov(strmov(dst+slen,rptr+1)-1,".DIR.1");
     return dst;
   }
-  VOID(strmov(dst, src));
+  (void) strmov(dst, src);
   if (dst[slen] == '/' && slen > 1)
     dst[slen] = 0;
   return dst;
diff -Nrup a/mysys/my_lockmem.c b/mysys/my_lockmem.c
--- a/mysys/my_lockmem.c	2007-05-10 11:59:25 +02:00
+++ b/mysys/my_lockmem.c	2008-04-08 12:29:09 +02:00
@@ -59,7 +59,7 @@ uchar *my_malloc_lock(uint size,myf MyFl
     /* Add block in a list for munlock */
     if (!(element=(struct st_mem_list*) my_malloc(sizeof(*element),MyFlags)))
     {
-      VOID(munlock((uchar*) ptr,size));
+      (void) munlock((uchar*) ptr,size);
       free(ptr);
       DBUG_RETURN(0);
     }
@@ -85,7 +85,7 @@ void my_free_lock(uchar *ptr,myf Myflags
     element=(struct st_mem_list*) list->data;
     if (ptr == element->page)
     {						/* Found locked mem */
-      VOID(munlock((uchar*) ptr,element->size));
+      (void) munlock((uchar*) ptr,element->size);
       mem_list=list_delete(mem_list,list);
       break;
     }
diff -Nrup a/mysys/my_pread.c b/mysys/my_pread.c
--- a/mysys/my_pread.c	2007-10-11 17:07:34 +02:00
+++ b/mysys/my_pread.c	2008-04-08 12:29:10 +02:00
@@ -164,7 +164,7 @@ size_t my_pwrite(int Filedes, const ucha
       if (!(errors++ % MY_WAIT_GIVE_USER_A_MESSAGE))
 	my_error(EE_DISK_FULL,MYF(ME_BELL | ME_NOREFRESH),
 		 my_filename(Filedes),my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
-      VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
+      (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
       continue;
     }
     if ((writenbytes && writenbytes != (size_t) -1) || my_errno == EINTR)
diff -Nrup a/mysys/my_pthread.c b/mysys/my_pthread.c
--- a/mysys/my_pthread.c	2007-07-30 21:42:51 +02:00
+++ b/mysys/my_pthread.c	2008-04-08 12:29:10 +02:00
@@ -38,7 +38,7 @@ void my_pthread_setprio(pthread_t thread
   struct sched_param tmp_sched_param;
   bzero((char*) &tmp_sched_param,sizeof(tmp_sched_param));
   tmp_sched_param.sched_priority=prior;
-  VOID(pthread_setschedparam(thread_id,SCHED_POLICY,&tmp_sched_param));
+  pthread_setschedparam(thread_id,SCHED_POLICY,&tmp_sched_param);
 #endif
 }
 #endif
@@ -65,7 +65,7 @@ void my_pthread_attr_setprio(pthread_att
   struct sched_param tmp_sched_param;
   bzero((char*) &tmp_sched_param,sizeof(tmp_sched_param));
   tmp_sched_param.sched_priority=priority;
-  VOID(pthread_attr_setschedparam(attr,&tmp_sched_param));
+  pthread_attr_setschedparam(attr,&tmp_sched_param);
 #endif
 }
 #endif
@@ -308,7 +308,7 @@ void sigwait_handle_sig(int sig)
 {
   pthread_mutex_lock(&LOCK_sigwait);
   sigaddset(&pending_set, sig);
-  VOID(pthread_cond_signal(&COND_sigwait)); /* inform sigwait() about signal */
+  pthread_cond_signal(&COND_sigwait); /* inform sigwait() about signal */
   pthread_mutex_unlock(&LOCK_sigwait);
 }
 
@@ -365,8 +365,8 @@ int sigwait(sigset_t *setp, int *sigp)
     pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
     pthread_attr_setstacksize(&thr_attr,8196);
     my_pthread_attr_setprio(&thr_attr,100);	/* Very high priority */
-    VOID(pthread_create(&sigwait_thread_id,&thr_attr,sigwait_thread,setp));
-    VOID(pthread_attr_destroy(&thr_attr));
+    pthread_create(&sigwait_thread_id,&thr_attr,sigwait_thread,setp);
+    pthread_attr_destroy(&thr_attr);
   }
 
   pthread_mutex_lock(&LOCK_sigwait);
@@ -392,7 +392,7 @@ int sigwait(sigset_t *setp, int *sigp)
 	return 0;
       }
     }
-    VOID(pthread_cond_wait(&COND_sigwait,&LOCK_sigwait));
+    pthread_cond_wait(&COND_sigwait,&LOCK_sigwait);
   }
   return 0;
 }
diff -Nrup a/mysys/my_redel.c b/mysys/my_redel.c
--- a/mysys/my_redel.c	2007-03-29 19:01:47 +02:00
+++ b/mysys/my_redel.c	2008-04-08 12:29:10 +02:00
@@ -86,7 +86,7 @@ int my_copystat(const char *from, const 
   }
   if ((statbuf.st_mode & S_IFMT) != S_IFREG)
     return 1;
-  VOID(chmod(to, statbuf.st_mode & 07777));		/* Copy modes */
+  (void) chmod(to, statbuf.st_mode & 07777);		/* Copy modes */
 
 #if !defined(__WIN__) && !defined(__NETWARE__)
   if (statbuf.st_nlink > 1 && MyFlags & MY_LINK_WARNING)
@@ -94,7 +94,7 @@ int my_copystat(const char *from, const 
     if (MyFlags & MY_LINK_WARNING)
       my_error(EE_LINK_WARNING,MYF(ME_BELL+ME_WAITTANG),from,statbuf.st_nlink);
   }
-  VOID(chown(to, statbuf.st_uid, statbuf.st_gid));	/* Copy ownership */
+  (void) chown(to, statbuf.st_uid, statbuf.st_gid);	/* Copy ownership */
 #endif /* !__WIN__ && !__NETWARE__ */
 
 #ifndef VMS
@@ -104,7 +104,7 @@ int my_copystat(const char *from, const 
     struct utimbuf timep;
     timep.actime  = statbuf.st_atime;
     timep.modtime = statbuf.st_mtime;
-    VOID(utime((char*) to, &timep));/* Update last accessed and modified times */
+    (void) utime((char*) to, &timep);/* Update last accessed and modified times */
   }
 #else
   if (MyFlags & MY_COPYTIME)
@@ -112,7 +112,7 @@ int my_copystat(const char *from, const 
     time_t time[2];
     time[0]= statbuf.st_atime;
     time[1]= statbuf.st_mtime;
-    VOID(utime((char*) to, time));/* Update last accessed and modified times */
+    (void) utime((char*) to, time);/* Update last accessed and modified times */
   }
 #endif
 #endif
diff -Nrup a/mysys/my_winthread.c b/mysys/my_winthread.c
--- a/mysys/my_winthread.c	2007-10-03 21:38:30 +02:00
+++ b/mysys/my_winthread.c	2008-04-08 12:29:11 +02:00
@@ -119,7 +119,7 @@ int pthread_create(pthread_t *thread_id,
 	       ("Can't create thread to handle request (error %d)",error));
     DBUG_RETURN(error ? error : -1);
   }
-  VOID(SetThreadPriority(hThread, attr->priority)) ;
+  SetThreadPriority(hThread, attr->priority);
   DBUG_RETURN(0);
 }
 
diff -Nrup a/mysys/my_write.c b/mysys/my_write.c
--- a/mysys/my_write.c	2007-10-25 06:22:07 +02:00
+++ b/mysys/my_write.c	2008-04-08 12:29:11 +02:00
@@ -57,7 +57,7 @@ size_t my_write(int Filedes, const uchar
       if (!(errors++ % MY_WAIT_GIVE_USER_A_MESSAGE))
 	my_error(EE_DISK_FULL,MYF(ME_BELL | ME_NOREFRESH),
 		 my_filename(Filedes),my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
-      VOID(sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC));
+      (void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
       continue;
     }
 
diff -Nrup a/mysys/thr_alarm.c b/mysys/thr_alarm.c
--- a/mysys/thr_alarm.c	2008-02-19 18:45:06 +01:00
+++ b/mysys/thr_alarm.c	2008-04-08 12:29:12 +02:00
@@ -99,8 +99,8 @@ void init_thr_alarm(uint max_alarms)
     pthread_attr_setstacksize(&thr_attr,8196);
 
     my_pthread_attr_setprio(&thr_attr,100);	/* Very high priority */
-    VOID(pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL));
-    VOID(pthread_attr_destroy(&thr_attr));
+    pthread_create(&alarm_thread,&thr_attr,alarm_handler,NULL);
+    pthread_attr_destroy(&thr_attr);
   }
 #elif defined(USE_ONE_SIGNAL_HAND)
   pthread_sigmask(SIG_BLOCK, &s, NULL);		/* used with sigwait() */
@@ -774,7 +774,7 @@ static void *test_thread(void *arg)
 		break;
 	      continue;
 	    }
-	    VOID(getchar());			/* Somebody was playing */
+	    (void) getchar();			/* Somebody was playing */
 	  }
 	}
       }
@@ -786,7 +786,7 @@ static void *test_thread(void *arg)
   }
   pthread_mutex_lock(&LOCK_thread_count);
   thread_count--;
-  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
   pthread_mutex_unlock(&LOCK_thread_count);
   free((uchar*) arg);
   return 0;
@@ -815,7 +815,7 @@ static void *signal_hand(void *arg __att
   pthread_detach_this_thread();
   init_thr_alarm(10);				/* Setup alarm handler */
   pthread_mutex_lock(&LOCK_thread_count);	/* Required by bsdi */
-  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
   pthread_mutex_unlock(&LOCK_thread_count);
 
   sigemptyset(&set);				/* Catch all signals */
@@ -906,7 +906,7 @@ int main(int argc __attribute__((unused)
 #ifdef NOT_USED
   sigemptyset(&set);
   sigaddset(&set, thr_client_alarm);
-  VOID(pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0));
+  pthread_sigmask(SIG_UNBLOCK, &set, (sigset_t*) 0);
 #endif
 
   pthread_attr_init(&thr_attr);
@@ -915,10 +915,10 @@ int main(int argc __attribute__((unused)
   pthread_attr_setstacksize(&thr_attr,65536L);
 
   /* Start signal thread and wait for it to start */
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   pthread_create(&tid,&thr_attr,signal_hand,NULL);
-  VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
+  pthread_mutex_unlock(&LOCK_thread_count);
   DBUG_PRINT("info",("signal thread created"));
 
   thr_setconcurrency(3);
@@ -946,7 +946,7 @@ int main(int argc __attribute__((unused)
 	 alarm_info.next_alarm_time);
   while (thread_count)
   {
-    VOID(pthread_cond_wait(&COND_thread_count,&LOCK_thread_count));
+    pthread_cond_wait(&COND_thread_count,&LOCK_thread_count);
     if (thread_count == 1)
     {
       printf("Calling end_thr_alarm. This should cancel the last thread\n");
diff -Nrup a/mysys/thr_lock.c b/mysys/thr_lock.c
--- a/mysys/thr_lock.c	2008-02-18 23:36:53 +01:00
+++ b/mysys/thr_lock.c	2008-04-08 12:29:12 +02:00
@@ -316,7 +316,7 @@ void thr_lock_init(THR_LOCK *lock)
 {
   DBUG_ENTER("thr_lock_init");
   bzero((char*) lock,sizeof(*lock));
-  VOID(pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&lock->mutex,MY_MUTEX_INIT_FAST);
   lock->read.last= &lock->read.data;
   lock->read_wait.last= &lock->read_wait.data;
   lock->write_wait.last= &lock->write_wait.data;
@@ -333,7 +333,7 @@ void thr_lock_init(THR_LOCK *lock)
 void thr_lock_delete(THR_LOCK *lock)
 {
   DBUG_ENTER("thr_lock_delete");
-  VOID(pthread_mutex_destroy(&lock->mutex));
+  pthread_mutex_destroy(&lock->mutex);
   pthread_mutex_lock(&THR_LOCK_lock);
   thr_lock_thread_list=list_delete(thr_lock_thread_list,&lock->list);
   pthread_mutex_unlock(&THR_LOCK_lock);
@@ -500,7 +500,7 @@ thr_lock(THR_LOCK_DATA *data, THR_LOCK_O
   data->cond=0;					/* safety */
   data->type=lock_type;
   data->owner= owner;                           /* Must be reset ! */
-  VOID(pthread_mutex_lock(&lock->mutex));
+  pthread_mutex_lock(&lock->mutex);
   DBUG_PRINT("lock",("data: 0x%lx  thread: 0x%lx  lock: 0x%lx  type: %d",
                      (long) data, data->owner->info->thread_id,
                      (long) lock, (int) lock_type));
@@ -750,7 +750,7 @@ static inline void free_all_read_locks(T
 		       data->owner->info->thread_id));
     /* purecov: end */
     data->cond=0;				/* Mark thread free */
-    VOID(pthread_cond_signal(cond));
+    pthread_cond_signal(cond);
   } while ((data=data->next));
   *lock->read_wait.last=0;
   if (!lock->read_wait.data)
@@ -860,7 +860,7 @@ static void wake_up_waiters(THR_LOCK *lo
 	  {
 	    pthread_cond_t *cond=data->cond;
 	    data->cond=0;				/* Mark thread free */
-	    VOID(pthread_cond_signal(cond));	/* Start waiting thread */
+	    pthread_cond_signal(cond);	/* Start waiting thread */
 	  }
 	  if (data->type != TL_WRITE_ALLOW_WRITE ||
 	      !lock->write_wait.data ||
@@ -911,7 +911,7 @@ static void wake_up_waiters(THR_LOCK *lo
 	lock->write.last= &data->next;
 	data->next=0;				/* Only one write lock */
 	data->cond=0;				/* Mark thread free */
-	VOID(pthread_cond_signal(cond));	/* Start waiting thread */
+	pthread_cond_signal(cond);	/* Start waiting thread */
       } while (lock_type == TL_WRITE_ALLOW_WRITE &&
 	       (data=lock->write_wait.data) &&
 	       data->type == TL_WRITE_ALLOW_WRITE);
@@ -1478,7 +1478,7 @@ void thr_print_locks(void)
        list= list_rest(list))
   {
     THR_LOCK *lock=(THR_LOCK*) list->data;
-    VOID(pthread_mutex_lock(&lock->mutex));
+    pthread_mutex_lock(&lock->mutex);
     printf("lock: 0x%lx:",(ulong) lock);
     if ((lock->write_wait.data || lock->read_wait.data) &&
 	(! lock->read.data && ! lock->write.data))
@@ -1496,7 +1496,7 @@ void thr_print_locks(void)
     thr_print_lock("write_wait",&lock->write_wait);
     thr_print_lock("read",&lock->read);
     thr_print_lock("read_wait",&lock->read_wait);
-    VOID(pthread_mutex_unlock(&lock->mutex));
+    pthread_mutex_unlock(&lock->mutex);
     puts("");
   }
   fflush(stdout);
@@ -1636,7 +1636,7 @@ static void *test_thread(void *arg)
   thr_print_locks();
   pthread_mutex_lock(&LOCK_thread_count);
   thread_count--;
-  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
   pthread_mutex_unlock(&LOCK_thread_count);
   free((uchar*) arg);
   return 0;
@@ -1697,7 +1697,7 @@ int main(int argc __attribute__((unused)
   }
 #endif
 #ifdef HAVE_THR_SETCONCURRENCY
-  VOID(thr_setconcurrency(2));
+  (void) thr_setconcurrency(2);
 #endif
   for (i=0 ; i < (int) array_elements(lock_counts) ; i++)
   {
diff -Nrup a/sql/derror.cc b/sql/derror.cc
--- a/sql/derror.cc	2007-10-09 23:56:29 +02:00
+++ b/sql/derror.cc	2008-04-08 12:29:13 +02:00
@@ -137,7 +137,7 @@ Error message file '%s' had only %d erro
 but it should contain at least %d error messages.\n\
 Check that the above file is the right version for this program!",
 		    name,count,error_messages);
-    VOID(my_close(file,MYF(MY_WME)));
+    (void) my_close(file,MYF(MY_WME));
     DBUG_RETURN(1);
   }
 
@@ -164,7 +164,7 @@ Check that the above file is the right v
   {
     point[i]= *point +uint2korr(head+10+i+i);
   }
-  VOID(my_close(file,MYF(0)));
+  (void) my_close(file,MYF(0));
   DBUG_RETURN(0);
 
 err:
@@ -182,7 +182,7 @@ err:
   sql_print_error(errmsg, name);
 err1:
   if (file != FERR)
-    VOID(my_close(file,MYF(MY_WME)));
+    (void) my_close(file,MYF(MY_WME));
   DBUG_RETURN(1);
 } /* read_texts */
 
diff -Nrup a/sql/des_key_file.cc b/sql/des_key_file.cc
--- a/sql/des_key_file.cc	2007-10-09 23:56:29 +02:00
+++ b/sql/des_key_file.cc	2008-04-08 12:29:13 +02:00
@@ -43,7 +43,7 @@ load_des_key_file(const char *file_name)
   DBUG_ENTER("load_des_key_file");
   DBUG_PRINT("enter",("name: %s",file_name));
 
-  VOID(pthread_mutex_lock(&LOCK_des_key_file));
+  pthread_mutex_lock(&LOCK_des_key_file);
   if ((file=my_open(file_name,O_RDONLY | O_BINARY ,MYF(MY_WME))) < 0 ||
       init_io_cache(&io, file, IO_SIZE*2, READ_CACHE, 0, 0, MYF(MY_WME)))
     goto error;
@@ -96,7 +96,7 @@ error:
     my_close(file,MYF(0));
     end_io_cache(&io);
   }
-  VOID(pthread_mutex_unlock(&LOCK_des_key_file));
+  pthread_mutex_unlock(&LOCK_des_key_file);
   DBUG_RETURN(result);
 }
 #endif /* HAVE_OPENSSL */
diff -Nrup a/sql/discover.cc b/sql/discover.cc
--- a/sql/discover.cc	2007-10-09 23:56:29 +02:00
+++ b/sql/discover.cc	2008-04-08 12:29:14 +02:00
@@ -82,7 +82,7 @@ int readfrm(const char *name, uchar **fr
   
  err:
   if (file > 0)
-    VOID(my_close(file,MYF(MY_WME)));
+    (void) my_close(file,MYF(MY_WME));
   
  err_end:		      /* Here when no file */
   DBUG_RETURN (error);
@@ -118,7 +118,7 @@ int writefrm(const char *name, const uch
   {
     if (my_write(file, frmdata, len,MYF(MY_WME | MY_NABP)))
       error= 2;
-    VOID(my_close(file,MYF(0)));
+    (void) my_close(file,MYF(0));
   }
   DBUG_RETURN(error);
 } /* writefrm */
diff -Nrup a/sql/field.cc b/sql/field.cc
--- a/sql/field.cc	2008-04-01 18:37:52 +02:00
+++ b/sql/field.cc	2008-04-08 12:29:14 +02:00
@@ -4176,7 +4176,7 @@ String *Field_float::val_str(String *val
     char buff[70],*pos=buff;
     int decpt,sign,tmp_dec=dec;
 
-    VOID(sfconvert(&nr,tmp_dec,&decpt,&sign,buff));
+    (void) sfconvert(&nr,tmp_dec,&decpt,&sign,buff);
     if (sign)
     {
       *to++='-';
@@ -4534,7 +4534,7 @@ String *Field_double::val_str(String *va
     char *pos= buff;
     int decpt,sign,tmp_dec=dec;
 
-    VOID(fconvert(nr,tmp_dec,&decpt,&sign,buff));
+    (void) fconvert(nr,tmp_dec,&decpt,&sign,buff);
     if (sign)
     {
       *to++='-';
diff -Nrup a/sql/filesort.cc b/sql/filesort.cc
--- a/sql/filesort.cc	2008-03-12 09:21:09 +01:00
+++ b/sql/filesort.cc	2008-04-08 12:29:14 +02:00
@@ -1277,7 +1277,7 @@ int merge_buffers(SORTPARAM *param, IO_C
         if (!(error= (int) read_to_buffer(from_file,buffpek,
                                           rec_length)))
         {
-          VOID(queue_remove(&queue,0));
+          (void) queue_remove(&queue,0);
           reuse_freed_buff(&queue, buffpek, rec_length);
           break;                        /* One buffer have been removed */
         }
diff -Nrup a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
--- a/sql/ha_ndbcluster.cc	2008-03-29 08:59:07 +01:00
+++ b/sql/ha_ndbcluster.cc	2008-04-08 12:29:15 +02:00
@@ -6842,7 +6842,7 @@ int ndbcluster_drop_database_impl(const 
   while ((tabname=it++))
   {
     tablename_to_filename(tabname, tmp, FN_REFLEN - (tmp - full_path)-1);
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     if (ha_ndbcluster::delete_table(0, ndb, full_path, dbname, tabname))
     {
       const NdbError err= dict->getNdbError();
@@ -6852,7 +6852,7 @@ int ndbcluster_drop_database_impl(const 
         ret= ndb_to_mysql_error(&err);
       }
     }
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
   }
   DBUG_RETURN(ret);      
 }
diff -Nrup a/sql/ha_partition.cc b/sql/ha_partition.cc
--- a/sql/ha_partition.cc	2008-03-28 11:03:01 +01:00
+++ b/sql/ha_partition.cc	2008-04-08 12:29:15 +02:00
@@ -640,7 +640,7 @@ int ha_partition::drop_partitions(const 
         part_elem->part_state= PART_IS_DROPPED;
     }
   } while (++i < no_parts);
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   DBUG_RETURN(error);
 }
 
@@ -730,7 +730,7 @@ int ha_partition::rename_partitions(cons
           part_elem->log_entry= NULL; /* Indicate success */
       }
     } while (++i < temp_partitions);
-    VOID(sync_ddl_log());
+    (void) sync_ddl_log();
   }
   i= 0;
   do
@@ -782,7 +782,7 @@ int ha_partition::rename_partitions(cons
               error= ret_error;
             else if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
               error= 1;
-            VOID(sync_ddl_log());
+            (void) sync_ddl_log();
           }
           file= m_new_file[part];
           create_subpartition_name(part_name_buff, path,
@@ -813,7 +813,7 @@ int ha_partition::rename_partitions(cons
             error= ret_error;
           else if (deactivate_ddl_log_entry(part_elem->log_entry->entry_pos))
             error= 1;
-          VOID(sync_ddl_log());
+          (void) sync_ddl_log();
         }
         file= m_new_file[i];
         create_partition_name(part_name_buff, path,
@@ -831,7 +831,7 @@ int ha_partition::rename_partitions(cons
       }
     }
   } while (++i < no_parts);
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   DBUG_RETURN(error);
 }
 
@@ -1173,7 +1173,7 @@ int ha_partition::prepare_new_partition(
   DBUG_RETURN(0);
 error:
   if (create_flag)
-    VOID(file->ha_delete_table(part_name));
+    (void) file->ha_delete_table(part_name);
   DBUG_RETURN(error);
 }
 
@@ -1751,7 +1751,7 @@ create_error:
   {
     create_partition_name(from_buff, from, name_buffer_ptr, NORMAL_PART_NAME,
                           FALSE);
-    VOID((*file)->ha_delete_table((const char*) from_buff));
+    (void) (*file)->ha_delete_table((const char*) from_buff);
     name_buffer_ptr= strend(name_buffer_ptr) + 1;
   }
   DBUG_RETURN(error);
@@ -2025,7 +2025,7 @@ bool ha_partition::create_handler_file(c
   {
     result= my_write(file, (uchar *) file_buffer, tot_len_byte,
                      MYF(MY_WME | MY_NABP)) != 0;
-    VOID(my_close(file, MYF(0)));
+    (void) my_close(file, MYF(0));
   }
   else
     result= TRUE;
@@ -2211,7 +2211,7 @@ bool ha_partition::get_from_handler_file
   len_bytes= 4 * len_words;
   if (!(file_buffer= (char*) my_malloc(len_bytes, MYF(0))))
     goto err1;
-  VOID(my_seek(file, 0, MY_SEEK_SET, MYF(0)));
+  my_seek(file, 0, MY_SEEK_SET, MYF(0));
   if (my_read(file, (uchar *) file_buffer, len_bytes, MYF(MY_NABP)))
     goto err2;
 
@@ -2233,7 +2233,7 @@ bool ha_partition::get_from_handler_file
   if (len_words != (tot_partition_words + tot_name_words + 4))
     goto err3;
   name_buffer_ptr= file_buffer + 16 + 4 * tot_partition_words;
-  VOID(my_close(file, MYF(0)));
+  (void) my_close(file, MYF(0));
   m_file_buffer= file_buffer;          // Will be freed in clear_handler_file()
   m_name_buffer_ptr= name_buffer_ptr;
   
@@ -2258,7 +2258,7 @@ err3:
 err2:
   my_free(file_buffer, MYF(0));
 err1:
-  VOID(my_close(file, MYF(0)));
+  (void) my_close(file, MYF(0));
   DBUG_RETURN(TRUE);
 }
 
@@ -5185,9 +5185,9 @@ void ha_partition::late_extra_cache(uint
     DBUG_VOID_RETURN;
   file= m_file[partition_id];
   if (m_extra_cache_size == 0)
-    VOID(file->extra(HA_EXTRA_CACHE));
+    (void) file->extra(HA_EXTRA_CACHE);
   else
-    VOID(file->extra_opt(HA_EXTRA_CACHE, m_extra_cache_size));
+    (void) file->extra_opt(HA_EXTRA_CACHE, m_extra_cache_size);
   DBUG_VOID_RETURN;
 }
 
@@ -5211,7 +5211,7 @@ void ha_partition::late_extra_no_cache(u
   if (!m_extra_cache)
     DBUG_VOID_RETURN;
   file= m_file[partition_id];
-  VOID(file->extra(HA_EXTRA_NO_CACHE));
+  (void) file->extra(HA_EXTRA_NO_CACHE);
   DBUG_VOID_RETURN;
 }
 
@@ -5838,7 +5838,7 @@ static PARTITION_SHARE *get_share(const 
     if (!partition_init)
     {
       partition_init++;
-      VOID(pthread_mutex_init(&partition_mutex, MY_MUTEX_INIT_FAST));
+      pthread_mutex_init(&partition_mutex, MY_MUTEX_INIT_FAST);
       (void) hash_init(&partition_open_tables, system_charset_info, 32, 0, 0,
 		       (hash_get_key) partition_get_key, 0, 0);
     }
diff -Nrup a/sql/handler.cc b/sql/handler.cc
--- a/sql/handler.cc	2008-03-26 11:32:17 +01:00
+++ b/sql/handler.cc	2008-04-08 12:29:16 +02:00
@@ -2795,7 +2795,7 @@ static bool update_frm_version(TABLE *ta
   }
 err:
   if (file >= 0)
-    VOID(my_close(file,MYF(MY_WME)));
+    (void) my_close(file,MYF(MY_WME));
   DBUG_RETURN(result);
 }
 
@@ -3475,7 +3475,7 @@ int ha_create_table(THD *thd, const char
   name= check_lowercase_names(table.file, share.path.str, name_buff);
 
   error= table.file->ha_create(name, &table, create_info);
-  VOID(closefrm(&table, 0));
+  (void) closefrm(&table, 0);
   if (error)
   {
     strxmov(name_buff, db, ".", table_name, NullS);
@@ -3546,7 +3546,7 @@ int ha_create_table_from_engine(THD* thd
 
   check_lowercase_names(table.file, path, path);
   error=table.file->ha_create(path, &table, &create_info);
-  VOID(closefrm(&table, 1));
+  (void) closefrm(&table, 1);
 
   DBUG_RETURN(error != 0);
 }
diff -Nrup a/sql/hostname.cc b/sql/hostname.cc
--- a/sql/hostname.cc	2007-10-11 19:29:05 +02:00
+++ b/sql/hostname.cc	2008-04-08 12:29:16 +02:00
@@ -87,7 +87,7 @@ static void add_hostname(struct in_addr 
 {
   if (!(specialflag & SPECIAL_NO_HOST_CACHE))
   {
-    VOID(pthread_mutex_lock(&hostname_cache->lock));
+    pthread_mutex_lock(&hostname_cache->lock);
     host_entry *entry;
     if (!(entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
     {
@@ -106,7 +106,7 @@ static void add_hostname(struct in_addr 
 	(void) hostname_cache->add(entry);
       }
     }
-    VOID(pthread_mutex_unlock(&hostname_cache->lock));
+    pthread_mutex_unlock(&hostname_cache->lock);
   }
 }
 
@@ -118,20 +118,20 @@ inline void add_wrong_ip(struct in_addr 
 
 void inc_host_errors(struct in_addr *in)
 {
-  VOID(pthread_mutex_lock(&hostname_cache->lock));
+  pthread_mutex_lock(&hostname_cache->lock);
   host_entry *entry;
   if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
     entry->errors++;
-  VOID(pthread_mutex_unlock(&hostname_cache->lock));
+  pthread_mutex_unlock(&hostname_cache->lock);
 }
 
 void reset_host_errors(struct in_addr *in)
 {
-  VOID(pthread_mutex_lock(&hostname_cache->lock));
+  pthread_mutex_lock(&hostname_cache->lock);
   host_entry *entry;
   if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
     entry->errors=0;
-  VOID(pthread_mutex_unlock(&hostname_cache->lock));
+  pthread_mutex_unlock(&hostname_cache->lock);
 }
 
 /* Deal with systems that don't defined INADDR_LOOPBACK */
@@ -153,7 +153,7 @@ char * ip_to_hostname(struct in_addr *in
   /* Check first if we have name in cache */
   if (!(specialflag & SPECIAL_NO_HOST_CACHE))
   {
-    VOID(pthread_mutex_lock(&hostname_cache->lock));
+    pthread_mutex_lock(&hostname_cache->lock);
     if ((entry=(host_entry*) hostname_cache->search((uchar*) &in->s_addr,0)))
     {
       char *name;
@@ -162,10 +162,10 @@ char * ip_to_hostname(struct in_addr *in
       else
 	name=my_strdup(entry->hostname,MYF(0));
       *errors= entry->errors;
-      VOID(pthread_mutex_unlock(&hostname_cache->lock));
+      pthread_mutex_unlock(&hostname_cache->lock);
       DBUG_RETURN(name);
     }
-    VOID(pthread_mutex_unlock(&hostname_cache->lock));
+    pthread_mutex_unlock(&hostname_cache->lock);
   }
 
   struct hostent *hp, *check;
@@ -214,10 +214,10 @@ char * ip_to_hostname(struct in_addr *in
   }
   my_gethostbyname_r_free();
 #else
-  VOID(pthread_mutex_lock(&LOCK_hostname));
+  pthread_mutex_lock(&LOCK_hostname);
   if (!(hp=gethostbyaddr((char*) in,sizeof(*in), AF_INET)))
   {
-    VOID(pthread_mutex_unlock(&LOCK_hostname));
+    pthread_mutex_unlock(&LOCK_hostname);
     DBUG_PRINT("error",("gethostbyaddr returned %d",errno));
 
     if (errno == HOST_NOT_FOUND || errno == NO_DATA)
@@ -227,17 +227,17 @@ char * ip_to_hostname(struct in_addr *in
   }
   if (!hp->h_name[0])				// Don't allow empty hostnames
   {
-    VOID(pthread_mutex_unlock(&LOCK_hostname));
+    pthread_mutex_unlock(&LOCK_hostname);
     DBUG_PRINT("error",("Got an empty hostname"));
     goto add_wrong_ip_and_return;
   }
   if (!(name=my_strdup(hp->h_name,MYF(0))))
   {
-    VOID(pthread_mutex_unlock(&LOCK_hostname));
+    pthread_mutex_unlock(&LOCK_hostname);
     DBUG_RETURN(0);				// out of memory
   }
   check=gethostbyname(name);
-  VOID(pthread_mutex_unlock(&LOCK_hostname));
+  pthread_mutex_unlock(&LOCK_hostname);
   if (!check)
   {
     DBUG_PRINT("error",("gethostbyname returned %d",errno));
diff -Nrup a/sql/init.cc b/sql/init.cc
--- a/sql/init.cc	2008-04-03 19:14:52 +02:00
+++ b/sql/init.cc	2008-04-08 12:29:17 +02:00
@@ -40,7 +40,7 @@ void unireg_init(ulong options)
   my_abort_hook=unireg_abort;		/* Abort with close of databases */
 #endif
 
-  VOID(strmov(reg_ext,".frm"));
+  (void) strmov(reg_ext,".frm");
   reg_ext_length= 4;
   specialflag=SPECIAL_SAME_DB_NAME | options;  /* Set options from argv */
   DBUG_VOID_RETURN;
diff -Nrup a/sql/item.cc b/sql/item.cc
--- a/sql/item.cc	2008-03-28 16:09:12 +01:00
+++ b/sql/item.cc	2008-04-08 12:29:17 +02:00
@@ -1188,7 +1188,7 @@ void Item_case_expr::print(String *str, 
 {
   if (str->reserve(MAX_INT_WIDTH + sizeof("case_expr@")))
     return;                                    /* purecov: inspected */
-  VOID(str->append(STRING_WITH_LEN("case_expr@")));
+  (void) str->append(STRING_WITH_LEN("case_expr@"));
   str->qs_append(m_case_expr_id);
 }
 
diff -Nrup a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
--- a/sql/item_cmpfunc.cc	2008-03-28 19:03:46 +01:00
+++ b/sql/item_cmpfunc.cc	2008-04-08 12:29:18 +02:00
@@ -4117,7 +4117,7 @@ void Item_cond::neg_arguments(THD *thd)
       if (!(new_item= new Item_func_not(item)))
 	return;					// Fatal OEM error
     }
-    VOID(li.replace(new_item));
+    (void) li.replace(new_item);
   }
 }
 
diff -Nrup a/sql/item_strfunc.cc b/sql/item_strfunc.cc
--- a/sql/item_strfunc.cc	2008-02-22 11:30:30 +01:00
+++ b/sql/item_strfunc.cc	2008-04-08 12:29:18 +02:00
@@ -462,18 +462,18 @@ String *Item_func_des_encrypt::val_str(S
   if (arg_count == 1)
   {
     /* Protect against someone doing FLUSH DES_KEY_FILE */
-    VOID(pthread_mutex_lock(&LOCK_des_key_file));
+    pthread_mutex_lock(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number=des_default_key];
-    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
+    pthread_mutex_unlock(&LOCK_des_key_file);
   }
   else if (args[1]->result_type() == INT_RESULT)
   {
     key_number= (uint) args[1]->val_int();
     if (key_number > 9)
       goto error;
-    VOID(pthread_mutex_lock(&LOCK_des_key_file));
+    pthread_mutex_lock(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number];
-    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
+    pthread_mutex_unlock(&LOCK_des_key_file);
   }
   else
   {
@@ -559,9 +559,9 @@ String *Item_func_des_decrypt::val_str(S
         key_number > 9)
       goto error;
 
-    VOID(pthread_mutex_lock(&LOCK_des_key_file));
+    pthread_mutex_lock(&LOCK_des_key_file);
     keyschedule= des_keyschedule[key_number];
-    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
+    pthread_mutex_unlock(&LOCK_des_key_file);
   }
   else
   {
diff -Nrup a/sql/lock.cc b/sql/lock.cc
--- a/sql/lock.cc	2008-03-29 16:55:56 +01:00
+++ b/sql/lock.cc	2008-04-08 12:29:19 +02:00
@@ -280,7 +280,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, 
     if (rc > 1)                                 /* a timeout or a deadlock */
     {
       if (sql_lock->table_count)
-        VOID(unlock_external(thd, sql_lock->table, sql_lock->table_count));
+        (void) unlock_external(thd, sql_lock->table, sql_lock->table_count);
       my_error(rc, MYF(0));
       my_free((uchar*) sql_lock,MYF(0));
       sql_lock= 0;
@@ -388,7 +388,7 @@ void mysql_unlock_tables(THD *thd, MYSQL
   if (sql_lock->lock_count)
     thr_multi_unlock(sql_lock->locks,sql_lock->lock_count);
   if (sql_lock->table_count)
-    VOID(unlock_external(thd,sql_lock->table,sql_lock->table_count));
+    (void) unlock_external(thd,sql_lock->table,sql_lock->table_count);
   my_free((uchar*) sql_lock,MYF(0));
   DBUG_VOID_RETURN;
 }
@@ -452,7 +452,7 @@ void mysql_unlock_read_tables(THD *thd, 
   /* Unlock all read locked tables */
   if (i != found)
   {
-    VOID(unlock_external(thd,table,i-found));
+    (void) unlock_external(thd,table,i-found);
     sql_lock->table_count=found;
   }
   /* Fix the lock positions in TABLE */
@@ -970,7 +970,7 @@ int lock_and_wait_for_table_name(THD *th
 
   if (wait_if_global_read_lock(thd, 0, 1))
     DBUG_RETURN(1);
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   if ((lock_retcode = lock_table_name(thd, table_list, TRUE)) < 0)
     goto end;
   if (lock_retcode && wait_for_locked_table_names(thd, table_list))
@@ -1595,8 +1595,8 @@ bool make_global_read_lock_block_commit(
 
 void broadcast_refresh(void)
 {
-  VOID(pthread_cond_broadcast(&COND_refresh));
-  VOID(pthread_cond_broadcast(&COND_global_read_lock));
+  pthread_cond_broadcast(&COND_refresh);
+  pthread_cond_broadcast(&COND_global_read_lock);
 }
 
 /**
diff -Nrup a/sql/log.cc b/sql/log.cc
--- a/sql/log.cc	2008-03-31 10:55:41 +02:00
+++ b/sql/log.cc	2008-04-08 12:29:19 +02:00
@@ -2815,7 +2815,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
     thread. If the transaction involved MyISAM tables, it should go
     into binlog even on rollback.
   */
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
 
   /* Save variables so that we can reopen the log */
   save_name=name;
@@ -2895,7 +2895,7 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
   my_free((uchar*) save_name, MYF(0));
 
 err:
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   pthread_mutex_unlock(&LOCK_index);
   pthread_mutex_unlock(&LOCK_log);
   DBUG_RETURN(error);
@@ -3851,7 +3851,7 @@ bool MYSQL_BIN_LOG::write(Log_event *eve
     if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
 	(!binlog_filter->db_ok(local_db)))
     {
-      VOID(pthread_mutex_unlock(&LOCK_log));
+      pthread_mutex_unlock(&LOCK_log);
       DBUG_RETURN(0);
     }
 #endif /* HAVE_REPLICATION */
@@ -4260,7 +4260,7 @@ int MYSQL_BIN_LOG::write_cache(IO_CACHE 
 bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)
 {
   DBUG_ENTER("MYSQL_BIN_LOG::write(THD *, IO_CACHE *, Log_event *)");
-  VOID(pthread_mutex_lock(&LOCK_log));
+  pthread_mutex_lock(&LOCK_log);
 
   /* NULL would represent nothing to replicate after ROLLBACK */
   DBUG_ASSERT(commit_event != NULL);
@@ -4346,7 +4346,7 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_C
     else
       rotate_and_purge(RP_LOCK_LOG_IS_ALREADY_LOCKED);
   }
-  VOID(pthread_mutex_unlock(&LOCK_log));
+  pthread_mutex_unlock(&LOCK_log);
 
   DBUG_RETURN(0);
 
@@ -4356,7 +4356,7 @@ err:
     write_error= 1;
     sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
   }
-  VOID(pthread_mutex_unlock(&LOCK_log));
+  pthread_mutex_unlock(&LOCK_log);
   DBUG_RETURN(1);
 }
 
@@ -4548,7 +4548,7 @@ bool flush_error_log()
     char err_renamed[FN_REFLEN], *end;
     end= strmake(err_renamed,log_error_file,FN_REFLEN-4);
     strmov(end, "-old");
-    VOID(pthread_mutex_lock(&LOCK_error_log));
+    pthread_mutex_lock(&LOCK_error_log);
 #ifdef __WIN__
     char err_temp[FN_REFLEN+4];
     /*
@@ -4587,7 +4587,7 @@ bool flush_error_log()
    else
      result= 1;
 #endif
-    VOID(pthread_mutex_unlock(&LOCK_error_log));
+    pthread_mutex_unlock(&LOCK_error_log);
   }
    return result;
 }
@@ -4661,7 +4661,7 @@ static void print_buffer_to_file(enum lo
   DBUG_ENTER("print_buffer_to_file");
   DBUG_PRINT("enter",("buffer: %s", buffer));
 
-  VOID(pthread_mutex_lock(&LOCK_error_log));
+  pthread_mutex_lock(&LOCK_error_log);
 
   skr= my_time(0);
   localtime_r(&skr, &tm_tmp);
@@ -4680,7 +4680,7 @@ static void print_buffer_to_file(enum lo
 
   fflush(stderr);
 
-  VOID(pthread_mutex_unlock(&LOCK_error_log));
+  pthread_mutex_unlock(&LOCK_error_log);
   DBUG_VOID_RETURN;
 }
 
diff -Nrup a/sql/log_event.cc b/sql/log_event.cc
--- a/sql/log_event.cc	2008-03-28 14:52:30 +01:00
+++ b/sql/log_event.cc	2008-04-08 12:29:20 +02:00
@@ -2329,9 +2329,9 @@ int Query_log_event::do_apply_event(Rela
     thd->set_time((time_t)when);
     thd->query_length= q_len_arg;
     thd->query= (char*)query_arg;
-    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_lock(&LOCK_thread_count);
     thd->query_id = next_query_id();
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    pthread_mutex_unlock(&LOCK_thread_count);
     thd->variables.pseudo_thread_id= thread_id;		// for temp tables
     DBUG_PRINT("query",("%s",thd->query));
 
@@ -2530,7 +2530,7 @@ Default database: '%s'. Query: '%s'",
   } /* End of if (db_ok(... */
 
 end:
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   /*
     Probably we have set thd->query, thd->db, thd->catalog to point to places
     in the data_buf of this event. Now the event is going to be deleted
@@ -2546,7 +2546,7 @@ end:
   DBUG_PRINT("info", ("end: query= 0"));
   thd->query= 0;			// just to be sure
   thd->query_length= 0;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   close_thread_tables(thd);      
   /*
     As a disk space optimization, future masters will not log an event for
@@ -3767,9 +3767,9 @@ int Load_log_event::do_apply_event(NET* 
   if (rpl_filter->db_ok(thd->db))
   {
     thd->set_time((time_t)when);
-    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_lock(&LOCK_thread_count);
     thd->query_id = next_query_id();
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    pthread_mutex_unlock(&LOCK_thread_count);
     /*
       Initing thd->row_count is not necessary in theory as this variable has no
       influence in the case of the slave SQL thread (it is used to generate a
@@ -3923,12 +3923,12 @@ int Load_log_event::do_apply_event(NET* 
 error:
   thd->net.vio = 0; 
   const char *remember_db= thd->db;
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   thd->catalog= 0;
   thd->set_db(NULL, 0);                   /* will free the current database */
   thd->query= 0;
   thd->query_length= 0;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   close_thread_tables(thd);
 
   DBUG_EXECUTE_IF("LOAD_DATA_INFILE_has_fatal_error",
diff -Nrup a/sql/mysqld.cc b/sql/mysqld.cc
--- a/sql/mysqld.cc	2008-04-02 00:42:29 +02:00
+++ b/sql/mysqld.cc	2008-04-08 12:29:20 +02:00
@@ -970,14 +970,14 @@ static void close_server_sock()
   {
     ip_sock=INVALID_SOCKET;
     DBUG_PRINT("info",("calling shutdown on TCP/IP socket"));
-    VOID(shutdown(tmp_sock, SHUT_RDWR));
+    (void) shutdown(tmp_sock, SHUT_RDWR);
 #if defined(__NETWARE__)
     /*
       The following code is disabled for normal systems as it causes MySQL
       to hang on AIX 4.3 during shutdown
     */
     DBUG_PRINT("info",("calling closesocket on TCP/IP socket"));
-    VOID(closesocket(tmp_sock));
+    (void) closesocket(tmp_sock);
 #endif
   }
   tmp_sock=unix_sock;
@@ -985,16 +985,16 @@ static void close_server_sock()
   {
     unix_sock=INVALID_SOCKET;
     DBUG_PRINT("info",("calling shutdown on unix socket"));
-    VOID(shutdown(tmp_sock, SHUT_RDWR));
+    (void) shutdown(tmp_sock, SHUT_RDWR);
 #if defined(__NETWARE__)
     /*
       The following code is disabled for normal systems as it may cause MySQL
       to hang on AIX 4.3 during shutdown
     */
     DBUG_PRINT("info",("calling closesocket on unix/IP socket"));
-    VOID(closesocket(tmp_sock));
+    (void) closesocket(tmp_sock);
 #endif
-    VOID(unlink(mysqld_unix_port));
+    (void) unlink(mysqld_unix_port);
   }
   DBUG_VOID_RETURN;
 #endif
@@ -5004,7 +5004,7 @@ pthread_handler_t handle_connections_soc
     if (!(thd= new THD))
     {
       (void) shutdown(new_sock, SHUT_RDWR);
-      VOID(closesocket(new_sock));
+      (void) closesocket(new_sock);
       continue;
     }
     if (!(vio_tmp=vio_new(new_sock,
diff -Nrup a/sql/opt_range.h b/sql/opt_range.h
--- a/sql/opt_range.h	2007-11-06 19:57:39 +01:00
+++ b/sql/opt_range.h	2008-04-08 12:29:21 +02:00
@@ -726,7 +726,7 @@ class SQL_SELECT :public Sql_alloc {
 class FT_SELECT: public QUICK_RANGE_SELECT {
 public:
   FT_SELECT(THD *thd, TABLE *table, uint key) :
-      QUICK_RANGE_SELECT (thd, table, key, 1) { VOID(init()); }
+      QUICK_RANGE_SELECT (thd, table, key, 1) { (void) init(); }
   ~FT_SELECT() { file->ft_end(); }
   int init() { return error=file->ft_init(); }
   int reset() { return 0; }
diff -Nrup a/sql/parse_file.cc b/sql/parse_file.cc
--- a/sql/parse_file.cc	2007-10-11 20:37:42 +02:00
+++ b/sql/parse_file.cc	2008-04-08 12:29:21 +02:00
@@ -386,8 +386,8 @@ my_bool rename_in_schema_file(const char
     ulonglong limit= ((revision > num_view_backups) ?
                       revision - num_view_backups : 0);
 
-    VOID(tablename_to_filename(old_name, old_name_buf, sizeof(old_name_buf)));
-    VOID(tablename_to_filename(new_name, new_name_buf, sizeof(new_name_buf)));
+    (void) tablename_to_filename(old_name, old_name_buf, sizeof(old_name_buf));
+    (void) tablename_to_filename(new_name, new_name_buf, sizeof(new_name_buf));
 
     for (; revision > limit ; revision--)
     {
diff -Nrup a/sql/protocol.cc b/sql/protocol.cc
--- a/sql/protocol.cc	2008-02-19 13:45:16 +01:00
+++ b/sql/protocol.cc	2008-04-08 12:29:22 +02:00
@@ -162,8 +162,8 @@ net_send_ok(THD *thd,
 
   if (message && message[0])
     pos= net_store_data(pos, (uchar*) message, strlen(message));
-  VOID(my_net_write(net, buff, (size_t) (pos-buff)));
-  VOID(net_flush(net));
+  (void) my_net_write(net, buff, (size_t) (pos-buff));
+  (void) net_flush(net);
 
   thd->main_da.can_overwrite_status= FALSE;
   DBUG_PRINT("info", ("OK sent, so no more error sending allowed"));
@@ -202,7 +202,7 @@ net_send_eof(THD *thd, uint server_statu
   {
     thd->main_da.can_overwrite_status= TRUE;
     write_eof_packet(thd, net, server_status, total_warn_count);
-    VOID(net_flush(net));
+    (void) net_flush(net);
     thd->main_da.can_overwrite_status= FALSE;
     DBUG_PRINT("info", ("EOF sent, so no more error sending allowed"));
   }
@@ -237,10 +237,10 @@ static void write_eof_packet(THD *thd, N
     if (thd->is_fatal_error)
       server_status&= ~SERVER_MORE_RESULTS_EXISTS;
     int2store(buff + 3, server_status);
-    VOID(my_net_write(net, buff, 5));
+    (void) my_net_write(net, buff, 5);
   }
   else
-    VOID(my_net_write(net, eof_buff, 1));
+    (void) my_net_write(net, eof_buff, 1);
 }
 
 /**
@@ -301,8 +301,8 @@ void net_send_error_packet(THD *thd, uin
     length=(uint) strlen(err);
     set_if_smaller(length,MYSQL_ERRMSG_SIZE-1);
   }
-  VOID(net_write_command(net,(uchar) 255, (uchar*) "", 0, (uchar*) err,
-                         length));
+  (void) net_write_command(net,(uchar) 255, (uchar*) "", 0, (uchar*) err,
+                         length);
   DBUG_VOID_RETURN;
 }
 
diff -Nrup a/sql/records.cc b/sql/records.cc
--- a/sql/records.cc	2007-12-14 16:33:35 +01:00
+++ b/sql/records.cc	2008-04-08 12:29:22 +02:00
@@ -153,7 +153,7 @@ void init_read_record(READ_RECORD *info,
   
   if (table->s->tmp_table == NON_TRANSACTIONAL_TMP_TABLE &&
       !table->sort.addon_field)
-    VOID(table->file->extra(HA_EXTRA_MMAP));
+    (void) table->file->extra(HA_EXTRA_MMAP);
   
   if (table->sort.addon_field)
   {
@@ -239,8 +239,8 @@ void init_read_record(READ_RECORD *info,
 	 !(table->s->db_options_in_use & HA_OPTION_PACK_RECORD) ||
 	 (use_record_cache < 0 &&
 	  !(table->file->ha_table_flags() & HA_NOT_DELETE_WITH_CACHE))))
-      VOID(table->file->extra_opt(HA_EXTRA_CACHE,
-				  thd->variables.read_buff_size));
+      (void) table->file->extra_opt(HA_EXTRA_CACHE,
+				  thd->variables.read_buff_size);
   }
   /* Condition pushdown to storage engine */
   if (thd->variables.engine_condition_pushdown && 
diff -Nrup a/sql/slave.cc b/sql/slave.cc
--- a/sql/slave.cc	2008-03-31 10:55:42 +02:00
+++ b/sql/slave.cc	2008-04-08 12:29:23 +02:00
@@ -2503,10 +2503,10 @@ err:
   // print the current replication position
   sql_print_information("Slave I/O thread exiting, read up to log '%s', position %s",
                   IO_RPL_LOG_NAME, llstr(mi->master_log_pos,llbuff));
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   thd->query = thd->db = 0; // extra safety
   thd->query_length= thd->db_length= 0;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   if (mysql)
   {
     /*
@@ -2789,7 +2789,7 @@ the slave SQL thread with \"SLAVE START\
     must "proactively" clear playgrounds:
   */
   rli->cleanup_context(thd, 1);
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   /*
     Some extra safety, which should not been needed (normally, event deletion
     should already have done these assignments (each event which sets these
@@ -2797,7 +2797,7 @@ the slave SQL thread with \"SLAVE START\
   */
   thd->query= thd->db= thd->catalog= 0;
   thd->query_length= thd->db_length= 0;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   thd_proc_info(thd, "Waiting for slave mutex on exit");
   pthread_mutex_lock(&rli->run_lock);
   /* We need data_lock, at least to wake up any waiting master_pos_wait() */
diff -Nrup a/sql/sp_head.cc b/sql/sp_head.cc
--- a/sql/sp_head.cc	2008-02-22 11:30:30 +01:00
+++ b/sql/sp_head.cc	2008-04-08 12:29:23 +02:00
@@ -1718,9 +1718,9 @@ sp_head::execute_function(THD *thd, Item
       as one select and not resetting THD::user_var_events before
       each invocation.
     */
-    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_lock(&LOCK_thread_count);
     q= global_query_id;
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    pthread_mutex_unlock(&LOCK_thread_count);
     mysql_bin_log.start_union_events(thd, q + 1);
     binlog_save_options= thd->options;
     thd->options&= ~OPTION_BIN_LOG;
@@ -2663,9 +2663,9 @@ sp_lex_keeper::reset_lex_and_exec_core(T
   */
   thd->lex= m_lex;
 
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   thd->query_id= next_query_id();
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
 
   if (thd->prelocked_mode == NON_PRELOCKED)
   {
diff -Nrup a/sql/sp_pcontext.cc b/sql/sp_pcontext.cc
--- a/sql/sp_pcontext.cc	2008-03-21 19:07:59 +01:00
+++ b/sql/sp_pcontext.cc	2008-04-08 12:29:24 +02:00
@@ -62,21 +62,21 @@ sp_pcontext::sp_pcontext()
   m_context_handlers(0), m_parent(NULL), m_pboundary(0),
   m_label_scope(LABEL_DEFAULT_SCOPE)
 {
-  VOID(my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
+  (void) my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
   m_label.empty();
   m_children.empty();
 
@@ -90,21 +90,21 @@ sp_pcontext::sp_pcontext(sp_pcontext *pr
   m_context_handlers(0), m_parent(prev), m_pboundary(0),
   m_label_scope(label_scope)
 {
-  VOID(my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
+  (void) my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
-  VOID(my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
+  (void) my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *),
                              PCONTEXT_ARRAY_INIT_ALLOC,
-                             PCONTEXT_ARRAY_INCREMENT_ALLOC));
+                             PCONTEXT_ARRAY_INCREMENT_ALLOC);
   m_label.empty();
   m_children.empty();
 
diff -Nrup a/sql/sql_acl.cc b/sql/sql_acl.cc
--- a/sql/sql_acl.cc	2008-03-28 10:28:48 +01:00
+++ b/sql/sql_acl.cc	2008-04-08 12:29:24 +02:00
@@ -326,7 +326,7 @@ static my_bool acl_load(THD *thd, TABLE_
   init_sql_alloc(&mem, ACL_ALLOC_BLOCK_SIZE, 0);
   init_read_record(&read_record_info,thd,table= tables[0].table,NULL,1,0);
   table->use_all_columns();
-  VOID(my_init_dynamic_array(&acl_hosts,sizeof(ACL_HOST),20,50));
+  (void) my_init_dynamic_array(&acl_hosts,sizeof(ACL_HOST),20,50);
   while (!(read_record_info.read_record(&read_record_info)))
   {
     ACL_HOST host;
@@ -366,7 +366,7 @@ static my_bool acl_load(THD *thd, TABLE_
 	host.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL | CREATE_TMP_ACL;
     }
 #endif
-    VOID(push_dynamic(&acl_hosts,(uchar*) &host));
+    (void) push_dynamic(&acl_hosts,(uchar*) &host);
   }
   my_qsort((uchar*) dynamic_element(&acl_hosts,0,ACL_HOST*),acl_hosts.elements,
 	   sizeof(ACL_HOST),(qsort_cmp) acl_compare);
@@ -375,7 +375,7 @@ static my_bool acl_load(THD *thd, TABLE_
 
   init_read_record(&read_record_info,thd,table=tables[1].table,NULL,1,0);
   table->use_all_columns();
-  VOID(my_init_dynamic_array(&acl_users,sizeof(ACL_USER),50,100));
+  (void) my_init_dynamic_array(&acl_users,sizeof(ACL_USER),50,100);
   password_length= table->field[2]->field_length /
     table->field[2]->charset()->mbmaxlen;
   if (password_length < SCRAMBLED_PASSWORD_CHAR_LENGTH_323)
@@ -550,7 +550,7 @@ static my_bool acl_load(THD *thd, TABLE_
           user.access|= SUPER_ACL | EXECUTE_ACL;
 #endif
       }
-      VOID(push_dynamic(&acl_users,(uchar*) &user));
+      (void) push_dynamic(&acl_users,(uchar*) &user);
       if (!user.host.hostname ||
 	  (user.host.hostname[0] == wild_many && !user.host.hostname[1]))
         allow_all_hosts=1;			// Anyone can connect
@@ -563,7 +563,7 @@ static my_bool acl_load(THD *thd, TABLE_
 
   init_read_record(&read_record_info,thd,table=tables[2].table,NULL,1,0);
   table->use_all_columns();
-  VOID(my_init_dynamic_array(&acl_dbs,sizeof(ACL_DB),50,100));
+  (void) my_init_dynamic_array(&acl_dbs,sizeof(ACL_DB),50,100);
   while (!(read_record_info.read_record(&read_record_info)))
   {
     ACL_DB db;
@@ -613,7 +613,7 @@ static my_bool acl_load(THD *thd, TABLE_
 	db.access|=REFERENCES_ACL | INDEX_ACL | ALTER_ACL;
     }
 #endif
-    VOID(push_dynamic(&acl_dbs,(uchar*) &db));
+    (void) push_dynamic(&acl_dbs,(uchar*) &db);
   }
   my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
 	   sizeof(ACL_DB),(qsort_cmp) acl_compare);
@@ -704,7 +704,7 @@ my_bool acl_reload(THD *thd)
   }
 
   if ((old_initialized=initialized))
-    VOID(pthread_mutex_lock(&acl_cache->lock));
+    pthread_mutex_lock(&acl_cache->lock);
 
   old_acl_hosts=acl_hosts;
   old_acl_users=acl_users;
@@ -731,7 +731,7 @@ my_bool acl_reload(THD *thd)
     delete_dynamic(&old_acl_dbs);
   }
   if (old_initialized)
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
 end:
   close_thread_tables(thd);
   DBUG_RETURN(return_val);
@@ -883,7 +883,7 @@ int acl_getroot(THD *thd, USER_RESOURCES
     DBUG_RETURN(0);
   }
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   /*
     Find acl entry in user database. Note, that find_acl_user is not the same,
@@ -1055,7 +1055,7 @@ int acl_getroot(THD *thd, USER_RESOURCES
     else
       *sctx->priv_host= 0;
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   DBUG_RETURN(res);
 }
 
@@ -1102,7 +1102,7 @@ bool acl_getroot_no_password(Security_co
     DBUG_RETURN(FALSE);
   }
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   sctx->master_access= 0;
   sctx->db_access= 0;
@@ -1156,7 +1156,7 @@ bool acl_getroot_no_password(Security_co
     else
       *sctx->priv_host= 0;
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   DBUG_RETURN(res);
 }
 
@@ -1245,7 +1245,7 @@ static void acl_insert_user(const char *
 
   set_user_salt(&acl_user, password, password_len);
 
-  VOID(push_dynamic(&acl_users,(uchar*) &acl_user));
+  (void) push_dynamic(&acl_users,(uchar*) &acl_user);
   if (!acl_user.host.hostname ||
       (acl_user.host.hostname[0] == wild_many && !acl_user.host.hostname[1]))
     allow_all_hosts=1;		// Anyone can connect /* purecov: tested */
@@ -1311,7 +1311,7 @@ static void acl_insert_db(const char *us
   acl_db.db=strdup_root(&mem,db);
   acl_db.access=privileges;
   acl_db.sort=get_sort(3,acl_db.host.hostname,acl_db.db,acl_db.user);
-  VOID(push_dynamic(&acl_dbs,(uchar*) &acl_db));
+  (void) push_dynamic(&acl_dbs,(uchar*) &acl_db);
   my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
 	   sizeof(ACL_DB),(qsort_cmp) acl_compare);
 }
@@ -1335,7 +1335,7 @@ ulong acl_get(const char *host, const ch
   acl_entry *entry;
   DBUG_ENTER("acl_get");
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
   end=strmov((tmp_db=strmov(strmov(key, ip ? ip : "")+1,user)+1),db);
   if (lower_case_table_names)
   {
@@ -1347,7 +1347,7 @@ ulong acl_get(const char *host, const ch
                                                               key_length)))
   {
     db_access=entry->access;
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
     DBUG_PRINT("exit", ("access: 0x%lx", db_access));
     DBUG_RETURN(db_access);
   }
@@ -1401,7 +1401,7 @@ exit:
     memcpy((uchar*) entry->key,key,key_length);
     acl_cache->add(entry);
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   DBUG_PRINT("exit", ("access: 0x%lx", db_access & host_access));
   DBUG_RETURN(db_access & host_access);
 }
@@ -1417,10 +1417,10 @@ exit:
 static void init_check_host(void)
 {
   DBUG_ENTER("init_check_host");
-  VOID(my_init_dynamic_array(&acl_wild_hosts,sizeof(struct acl_host_and_ip),
-			  acl_users.elements,1));
-  VOID(hash_init(&acl_check_hosts,system_charset_info,acl_users.elements,0,0,
-		 (hash_get_key) check_get_key,0,0));
+  (void) my_init_dynamic_array(&acl_wild_hosts,sizeof(struct acl_host_and_ip),
+			  acl_users.elements,1);
+  (void) hash_init(&acl_check_hosts,system_charset_info,acl_users.elements,0,0,
+		 (hash_get_key) check_get_key,0,0);
   if (!allow_all_hosts)
   {
     for (uint i=0 ; i < acl_users.elements ; i++)
@@ -1481,12 +1481,12 @@ bool acl_check_host(const char *host, co
 {
   if (allow_all_hosts)
     return 0;
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   if (host && hash_search(&acl_check_hosts,(uchar*) host,strlen(host)) ||
       ip && hash_search(&acl_check_hosts,(uchar*) ip, strlen(ip)))
   {
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
     return 0;					// Found host
   }
   for (uint i=0 ; i < acl_wild_hosts.elements ; i++)
@@ -1494,11 +1494,11 @@ bool acl_check_host(const char *host, co
     acl_host_and_ip *acl=dynamic_element(&acl_wild_hosts,i,acl_host_and_ip*);
     if (compare_hostname(acl, host, ip))
     {
-      VOID(pthread_mutex_unlock(&acl_cache->lock));
+      pthread_mutex_unlock(&acl_cache->lock);
       return 0;					// Host ok
     }
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   return 1;					// Host is not allowed
 }
 
@@ -1612,11 +1612,11 @@ bool change_password(THD *thd, const cha
   if (!(table= open_ltable(thd, &tables, TL_WRITE, 0)))
     DBUG_RETURN(1);
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
   ACL_USER *acl_user;
   if (!(acl_user= find_acl_user(host, user, TRUE)))
   {
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
     my_message(ER_PASSWORD_NO_MATCH, ER(ER_PASSWORD_NO_MATCH), MYF(0));
     goto end;
   }
@@ -1628,12 +1628,12 @@ bool change_password(THD *thd, const cha
 			acl_user->user ? acl_user->user : "",
 			new_password, new_password_len))
   {
-    VOID(pthread_mutex_unlock(&acl_cache->lock)); /* purecov: deadcode */
+    pthread_mutex_unlock(&acl_cache->lock); /* purecov: deadcode */
     goto end;
   }
 
   acl_cache->clear(1);				// Clear locked hostname cache
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   result= 0;
   if (mysql_bin_log.is_open())
   {
@@ -1673,9 +1673,9 @@ bool is_acl_user(const char *host, const
   if (!initialized)
     return TRUE;
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
   res= find_acl_user(host, user, TRUE) != NULL;
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   return res;
 }
 
@@ -3425,7 +3425,7 @@ bool mysql_grant(THD *thd, const char *d
 
   /* go through users in user_list */
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
   grant_version++;
 
   int result=0;
@@ -3457,7 +3457,7 @@ bool mysql_grant(THD *thd, const char *d
       }
     }
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   if (!result)
   {
@@ -4491,12 +4491,12 @@ bool mysql_show_grants(THD *thd,LEX_USER
   }
 
   rw_rdlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   acl_user= find_acl_user(lex_user->host.str, lex_user->user.str, TRUE);
   if (!acl_user)
   {
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
     rw_unlock(&LOCK_grant);
 
     my_error(ER_NONEXISTING_GRANT, MYF(0),
@@ -4514,7 +4514,7 @@ bool mysql_show_grants(THD *thd,LEX_USER
   if (protocol->send_fields(&field_list,
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
   {
-    VOID(pthread_mutex_unlock(&acl_cache->lock));
+    pthread_mutex_unlock(&acl_cache->lock);
     rw_unlock(&LOCK_grant);
 
     DBUG_RETURN(TRUE);
@@ -4825,7 +4825,7 @@ bool mysql_show_grants(THD *thd,LEX_USER
   }
 
 end:
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   rw_unlock(&LOCK_grant);
 
   my_eof(thd);
@@ -5614,7 +5614,7 @@ bool mysql_create_user(THD *thd, List <L
     DBUG_RETURN(result != 1);
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   while ((tmp_user_name= user_list++))
   {
@@ -5644,7 +5644,7 @@ bool mysql_create_user(THD *thd, List <L
     }
   }
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "CREATE USER", wrong_users.c_ptr_safe());
@@ -5693,7 +5693,7 @@ bool mysql_drop_user(THD *thd, List <LEX
     DBUG_RETURN(result != 1);
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   while ((tmp_user_name= user_list++))
   {
@@ -5715,7 +5715,7 @@ bool mysql_drop_user(THD *thd, List <LEX
   /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
   rebuild_check_host();
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "DROP USER", wrong_users.c_ptr_safe());
@@ -5765,7 +5765,7 @@ bool mysql_rename_user(THD *thd, List <L
     DBUG_RETURN(result != 1);
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   while ((tmp_user_from= user_list++))
   {
@@ -5799,7 +5799,7 @@ bool mysql_rename_user(THD *thd, List <L
   /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
   rebuild_check_host();
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   if (result)
     my_error(ER_CANNOT_USER, MYF(0), "RENAME USER", wrong_users.c_ptr_safe());
@@ -5846,7 +5846,7 @@ bool mysql_revoke_all(THD *thd,  List <L
     DBUG_RETURN(result != 1);
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   LEX_USER *lex_user, *tmp_lex_user;
   List_iterator <LEX_USER> user_list(list);
@@ -5985,7 +5985,7 @@ bool mysql_revoke_all(THD *thd,  List <L
     } while (revoked);
   }
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   write_bin_log(thd, FALSE, thd->query, thd->query_length);
 
@@ -6086,7 +6086,7 @@ bool sp_revoke_privileges(THD *thd, cons
   thd->push_internal_handler(&error_handler);
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   /*
     This statement will be replicated as a statement, even when using
@@ -6124,7 +6124,7 @@ bool sp_revoke_privileges(THD *thd, cons
     }
   } while (revoked);
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   rw_unlock(&LOCK_grant);
   close_thread_tables(thd);
 
@@ -6165,7 +6165,7 @@ int sp_grant_privileges(THD *thd, const 
 
   combo->user.str= sctx->user;
 
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   if ((au= find_acl_user(combo->host.str=(char*)sctx->host_or_ip,combo->user.str,FALSE)))
     goto found_acl;
@@ -6176,11 +6176,11 @@ int sp_grant_privileges(THD *thd, const 
   if((au= find_acl_user(combo->host.str=(char*)"%", combo->user.str, FALSE)))
     goto found_acl;
 
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
   DBUG_RETURN(TRUE);
 
  found_acl:
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   bzero((char*)tables, sizeof(TABLE_LIST));
   user_list.empty();
diff -Nrup a/sql/sql_base.cc b/sql/sql_base.cc
--- a/sql/sql_base.cc	2008-03-27 12:54:43 +01:00
+++ b/sql/sql_base.cc	2008-04-08 12:29:25 +02:00
@@ -467,7 +467,7 @@ found:
          oldest_unused_share->next)
   {
     pthread_mutex_lock(&oldest_unused_share->mutex);
-    VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
+    hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
   }
 
   DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
@@ -779,7 +779,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *t
   TABLE_LIST table_list;
   DBUG_ENTER("list_open_tables");
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   bzero((char*) &table_list,sizeof(table_list));
   start_list= &open_list;
   open_list=0;
@@ -832,7 +832,7 @@ OPEN_TABLE_LIST *list_open_tables(THD *t
     start_list= &(*start_list)->next;
     *start_list=0;
   }
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   DBUG_RETURN(open_list);
 }
 
@@ -852,7 +852,7 @@ void intern_close_table(TABLE *table)
   free_io_cache(table);
   delete table->triggers;
   if (table->file)                              // Not true if name lock
-    VOID(closefrm(table, 1));			// close file
+    (void) closefrm(table, 1);			// close file
   DBUG_VOID_RETURN;
 }
 
@@ -929,7 +929,7 @@ bool close_cached_tables(THD *thd, TABLE
   DBUG_ASSERT(thd || (!wait_for_refresh && !tables));
 
   if (!have_lock)
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
   if (!tables)
   {
     refresh_version++;				// Force close of open tables
@@ -939,14 +939,14 @@ bool close_cached_tables(THD *thd, TABLE
       if (hash_delete(&open_cache,(uchar*) unused_tables))
 	printf("Warning: Couldn't delete open table from hash\n");
 #else
-      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
+      hash_delete(&open_cache,(uchar*) unused_tables);
 #endif
     }
     /* Free table shares */
     while (oldest_unused_share->next)
     {
       pthread_mutex_lock(&oldest_unused_share->mutex);
-      VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
+      hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
     }
     DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                           refresh_version));
@@ -1083,7 +1083,7 @@ bool close_cached_tables(THD *thd, TABLE
     }
   }
   if (!have_lock)
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
   if (wait_for_refresh)
   {
     pthread_mutex_lock(&thd->mysys_var->mutex);
@@ -1113,7 +1113,7 @@ bool close_cached_connection_tables(THD 
   bzero(&tmp, sizeof(TABLE_LIST));
 
   if (!have_lock)
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
 
   for (idx= 0; idx < table_def_cache.records; idx++)
   {
@@ -1146,7 +1146,7 @@ bool close_cached_connection_tables(THD 
     result= close_cached_tables(thd, tables, TRUE, FALSE, FALSE);
 
   if (!have_lock)
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
 
   if (if_wait_for_refresh)
   {
@@ -1242,7 +1242,7 @@ static void close_open_tables(THD *thd)
 
   safe_mutex_assert_not_owner(&LOCK_open);
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
 
   DBUG_PRINT("info", ("thd->open_tables: 0x%lx", (long) thd->open_tables));
 
@@ -1252,7 +1252,7 @@ static void close_open_tables(THD *thd)
 
   /* Free tables to hold down open files */
   while (open_cache.records > table_cache_size && unused_tables)
-    VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
+    hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
   check_unused();
   if (found_old_table)
   {
@@ -1260,7 +1260,7 @@ static void close_open_tables(THD *thd)
     broadcast_refresh();
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 }
 
 
@@ -1438,7 +1438,7 @@ bool close_thread_table(THD *thd, TABLE 
   if (table->needs_reopen_or_name_lock() ||
       thd->version != refresh_version || !table->db_stat)
   {
-    VOID(hash_delete(&open_cache,(uchar*) table));
+    hash_delete(&open_cache,(uchar*) table);
     found_old_table=1;
   }
   else
@@ -2147,7 +2147,7 @@ void unlink_open_table(THD *thd, TABLE *
       /* Remove table from open_tables list. */
       *prev= list->next;
       /* Close table. */
-      VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
+      hash_delete(&open_cache,(uchar*) list); // Close table
     }
     else
     {
@@ -2189,14 +2189,14 @@ void drop_open_table(THD *thd, TABLE *ta
   else
   {
     handlerton *table_type= table->s->db_type();
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     /*
       unlink_open_table() also tells threads waiting for refresh or close
       that something has happened.
     */
     unlink_open_table(thd, table, FALSE);
     quick_rm_table(table_type, db_name, table_name, 0);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
   }
 }
 
@@ -2450,24 +2450,24 @@ bool lock_table_name_if_not_cached(THD *
   DBUG_ENTER("lock_table_name_if_not_cached");
 
   key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
 
   if (hash_search(&open_cache, (uchar *)key, key_length))
   {
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     DBUG_PRINT("info", ("Table is cached, name-lock is not obtained"));
     *table= 0;
     DBUG_RETURN(FALSE);
   }
   if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
   {
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     DBUG_RETURN(TRUE);
   }
   (*table)->open_placeholder= 1;
   (*table)->next= thd->open_tables;
   thd->open_tables= *table;
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   DBUG_RETURN(FALSE);
 }
 
@@ -2740,15 +2740,15 @@ TABLE *open_table(THD *thd, TABLE_LIST *
         */
         TABLE tab;
         table= &tab;
-        VOID(pthread_mutex_lock(&LOCK_open));
+        pthread_mutex_lock(&LOCK_open);
         if (!open_unireg_entry(thd, table, table_list, alias,
                               key, key_length, mem_root, 0))
         {
           DBUG_ASSERT(table_list->view != 0);
-          VOID(pthread_mutex_unlock(&LOCK_open));
+          pthread_mutex_unlock(&LOCK_open);
           DBUG_RETURN(0); // VIEW
         }
-        VOID(pthread_mutex_unlock(&LOCK_open));
+        pthread_mutex_unlock(&LOCK_open);
       }
     }
     /*
@@ -2781,7 +2781,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
     on disk.
   */
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
 
   /*
     If it's the first table from a list of tables used in a query,
@@ -2799,7 +2799,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
     /* Someone did a refresh while thread was opening tables */
     if (refresh)
       *refresh=1;
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     DBUG_RETURN(0);
   }
 
@@ -2865,7 +2865,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
       /* Avoid self-deadlocks by detecting self-dependencies. */
       if (table->open_placeholder && table->in_use == thd)
       {
-	VOID(pthread_mutex_unlock(&LOCK_open));
+	pthread_mutex_unlock(&LOCK_open);
         my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
         DBUG_RETURN(0);
       }
@@ -2906,7 +2906,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
       }
       else
       {
-	VOID(pthread_mutex_unlock(&LOCK_open));
+	pthread_mutex_unlock(&LOCK_open);
       }
       /*
         There is a refresh in progress for this table.
@@ -2939,7 +2939,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
     DBUG_PRINT("tcache", ("opening new table"));
     /* Free cache if too big */
     while (open_cache.records > table_cache_size && unused_tables)
-      VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
+      hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
 
     if (table_list->create)
     {
@@ -2947,7 +2947,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
 
       if (check_if_table_exists(thd, table_list, &exists))
       {
-        VOID(pthread_mutex_unlock(&LOCK_open));
+        pthread_mutex_unlock(&LOCK_open);
         DBUG_RETURN(NULL);
       }
 
@@ -2958,7 +2958,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
         */
         if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
         {
-          VOID(pthread_mutex_unlock(&LOCK_open));
+          pthread_mutex_unlock(&LOCK_open);
           DBUG_RETURN(NULL);
         }
         /*
@@ -2969,7 +2969,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
         table->open_placeholder= 1;
         table->next= thd->open_tables;
         thd->open_tables= table;
-        VOID(pthread_mutex_unlock(&LOCK_open));
+        pthread_mutex_unlock(&LOCK_open);
         DBUG_RETURN(table);
       }
       /* Table exists. Let us try to open it. */
@@ -2978,7 +2978,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
     /* make a new table */
     if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
     {
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       DBUG_RETURN(NULL);
     }
 
@@ -2987,7 +2987,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
     if (error > 0)
     {
       my_free((uchar*)table, MYF(0));
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       DBUG_RETURN(NULL);
     }
     if (table_list->view || error < 0)
@@ -3000,18 +3000,18 @@ TABLE *open_table(THD *thd, TABLE_LIST *
         table_list->view= (st_lex*)1;
 
       my_free((uchar*)table, MYF(0));
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       DBUG_RETURN(0); // VIEW
     }
     DBUG_PRINT("info", ("inserting table '%s'.'%s' 0x%lx into the cache",
                         table->s->db.str, table->s->table_name.str,
                         (long) table));
-    VOID(my_hash_insert(&open_cache,(uchar*) table));
+    (void) my_hash_insert(&open_cache,(uchar*) table);
   }
 
   check_unused();				// Debugging call
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   if (refresh)
   {
     table->next=thd->open_tables;		/* Link into simple list */
@@ -3148,13 +3148,13 @@ bool reopen_table(TABLE *table)
       fix_merge_after_open(table->child_l, table->child_last_l,
                            tmp.child_l, tmp.child_last_l))
   {
-    VOID(closefrm(&tmp, 1)); // close file, free everything
+    (void) closefrm(&tmp, 1); // close file, free everything
     goto end;
   }
 
   delete table->triggers;
   if (table->file)
-    VOID(closefrm(table, 1));		// close file, free everything
+    (void) closefrm(table, 1);		// close file, free everything
 
   *table= tmp;
   table->default_column_bitmaps();
@@ -3392,7 +3392,7 @@ bool reopen_tables(THD *thd, bool get_lo
       */
       if (table->child_l || table->parent)
         detach_merge_children(table, TRUE);
-      VOID(hash_delete(&open_cache,(uchar*) table));
+      hash_delete(&open_cache,(uchar*) table);
       error=1;
     }
     else
@@ -3421,7 +3421,7 @@ bool reopen_tables(THD *thd, bool get_lo
   {
     while (err_tables)
     {
-      VOID(hash_delete(&open_cache, (uchar*) err_tables));
+      hash_delete(&open_cache, (uchar*) err_tables);
       err_tables= err_tables->next;
     }
   }
@@ -3703,7 +3703,7 @@ TABLE *drop_locked_tables(THD *thd,const
       else
       {
         /* We already have a name lock, remove copy */
-        VOID(hash_delete(&open_cache,(uchar*) table));
+        hash_delete(&open_cache,(uchar*) table);
       }
     }
     else
@@ -4199,7 +4199,7 @@ void detach_merge_children(TABLE *table,
   */
   if ((first_detach= parent->children_attached))
   {
-    VOID(parent->file->extra(HA_EXTRA_DETACH_CHILDREN));
+    (void) parent->file->extra(HA_EXTRA_DETACH_CHILDREN);
     parent->children_attached= FALSE;
     DBUG_PRINT("myrg", ("detached parent: '%s'.'%s' 0x%lx", parent->s->db.str,
                         parent->s->table_name.str, (long) parent));
@@ -8112,7 +8112,7 @@ my_bool mysql_rm_tmp_tables(void)
           So we hide error messages which happnes during deleting of these
           files(MYF(0)).
         */
-        VOID(my_delete(filePath, MYF(0))); 
+        (void) my_delete(filePath, MYF(0)); 
       }
     }
     my_dirend(dirp);
@@ -8154,7 +8154,7 @@ void remove_db_from_cache(const char *db
     }
   }
   while (unused_tables && !unused_tables->s->version)
-    VOID(hash_delete(&open_cache,(uchar*) unused_tables));
+    hash_delete(&open_cache,(uchar*) unused_tables);
 }
 
 
@@ -8278,7 +8278,7 @@ bool remove_table_from_cache(THD *thd, c
       }
     }
     while (unused_tables && !unused_tables->s->version)
-      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
+      hash_delete(&open_cache,(uchar*) unused_tables);
 
     DBUG_PRINT("info", ("Removing table from table_def_cache"));
     /* Remove table from table definition cache if it's not in use */
@@ -8291,7 +8291,7 @@ bool remove_table_from_cache(THD *thd, c
       if (share->ref_count == 0)
       {
         pthread_mutex_lock(&share->mutex);
-        VOID(hash_delete(&table_def_cache, (uchar*) share));
+        hash_delete(&table_def_cache, (uchar*) share);
       }
     }
 
@@ -8468,12 +8468,12 @@ int abort_and_upgrade_lock(ALTER_PARTITI
   DBUG_ENTER("abort_and_upgrade_locks");
 
   lpt->old_lock_type= lpt->table->reginfo.lock_type;
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   /* If MERGE child, forward lock handling to parent. */
   mysql_lock_abort(lpt->thd, lpt->table->parent ? lpt->table->parent :
                    lpt->table, TRUE);
-  VOID(remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags));
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  (void) remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name, flags);
+  pthread_mutex_unlock(&LOCK_open);
   DBUG_RETURN(0);
 }
 
@@ -8495,10 +8495,10 @@ int abort_and_upgrade_lock(ALTER_PARTITI
 /* purecov: begin deadcode */
 void close_open_tables_and_downgrade(ALTER_PARTITION_PARAM_TYPE *lpt)
 {
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   remove_table_from_cache(lpt->thd, lpt->db, lpt->table_name,
                           RTFC_WAIT_OTHER_THREAD_FLAG);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   /* If MERGE child, forward lock handling to parent. */
   mysql_lock_downgrade_write(lpt->thd, lpt->table->parent ? lpt->table->parent :
                              lpt->table, lpt->old_lock_type);
@@ -8537,7 +8537,7 @@ void mysql_wait_completed_table(ALTER_PA
   DBUG_ENTER("mysql_wait_completed_table");
 
   key_length=(uint) (strmov(strmov(key,lpt->db)+1,lpt->table_name)-key)+1;
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   HASH_SEARCH_STATE state;
   for (table= (TABLE*) hash_first(&open_cache,(uchar*) key,key_length,
                                   &state) ;
@@ -8595,7 +8595,7 @@ void mysql_wait_completed_table(ALTER_PA
   */
   mysql_lock_abort(lpt->thd, my_table->parent ? my_table->parent : my_table,
                    FALSE);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   DBUG_VOID_RETURN;
 }
 
diff -Nrup a/sql/sql_cache.cc b/sql/sql_cache.cc
--- a/sql/sql_cache.cc	2008-03-28 20:00:28 +01:00
+++ b/sql/sql_cache.cc	2008-04-08 12:29:25 +02:00
@@ -1951,8 +1951,8 @@ ulong Query_cache::init_cache()
 
   DUMP(this);
 
-  VOID(hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
-		 query_cache_query_get_key, 0, 0));
+  (void) hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
+		 query_cache_query_get_key, 0, 0);
 #ifndef FN_NO_CASE_SENCE
   /*
     If lower_case_table_names!=0 then db and table names are already 
@@ -1962,8 +1962,8 @@ ulong Query_cache::init_cache()
     lower_case_table_names == 0 then we should distinguish my_table
     and MY_TABLE cases and so again can use binary collation.
   */
-  VOID(hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
-		 query_cache_table_get_key, 0, 0));
+  (void) hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
+		 query_cache_table_get_key, 0, 0);
 #else
   /*
     On windows, OS/2, MacOS X with HFS+ or any other case insensitive
@@ -1973,10 +1973,10 @@ ulong Query_cache::init_cache()
     file system) and so should use case insensitive collation for
     comparison.
   */
-  VOID(hash_init(&tables,
+  (void) hash_init(&tables,
 		 lower_case_table_names ? &my_charset_bin :
 		 files_charset_info,
-		 def_table_hash_size, 0, 0,query_cache_table_get_key, 0, 0));
+		 def_table_hash_size, 0, 0,query_cache_table_get_key, 0, 0);
 #endif
 
   queries_in_cache = 0;
diff -Nrup a/sql/sql_connect.cc b/sql/sql_connect.cc
--- a/sql/sql_connect.cc	2008-03-28 09:41:50 +01:00
+++ b/sql/sql_connect.cc	2008-04-08 12:29:26 +02:00
@@ -405,7 +405,7 @@ check_user(THD *thd, enum enum_server_co
         pthread_mutex_lock(&LOCK_connection_count);
         bool count_ok= connection_count <= max_connections ||
                        (thd->main_security_ctx.master_access & SUPER_ACL);
-        VOID(pthread_mutex_unlock(&LOCK_connection_count));
+        pthread_mutex_unlock(&LOCK_connection_count);
 
         if (!count_ok)
         {                                         // too many connections
diff -Nrup a/sql/sql_db.cc b/sql/sql_db.cc
--- a/sql/sql_db.cc	2008-03-27 23:34:08 +01:00
+++ b/sql/sql_db.cc	2008-04-08 12:29:26 +02:00
@@ -643,7 +643,7 @@ int mysql_create_db(THD *thd, char *db, 
     goto exit2;
   }
 
-  VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
+  pthread_mutex_lock(&LOCK_mysql_create_db);
 
   /* Check directory */
   path_len= build_table_filename(path, sizeof(path), db, "", "", 0);
@@ -753,7 +753,7 @@ int mysql_create_db(THD *thd, char *db, 
   }
 
 exit:
-  VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
+  pthread_mutex_unlock(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -784,7 +784,7 @@ bool mysql_alter_db(THD *thd, const char
   if ((error=wait_if_global_read_lock(thd,0,1)))
     goto exit2;
 
-  VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
+  pthread_mutex_lock(&LOCK_mysql_create_db);
 
   /* 
      Recreate db options file: /dbpath/.db.opt
@@ -829,7 +829,7 @@ bool mysql_alter_db(THD *thd, const char
   my_ok(thd, result);
 
 exit:
-  VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
+  pthread_mutex_unlock(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -881,7 +881,7 @@ bool mysql_rm_db(THD *thd,char *db,bool 
     goto exit2;
   }
 
-  VOID(pthread_mutex_lock(&LOCK_mysql_create_db));
+  pthread_mutex_lock(&LOCK_mysql_create_db);
 
   /*
     This statement will be replicated as a statement, even when using
@@ -1010,7 +1010,7 @@ exit:
   */
   if (thd->db && !strcmp(thd->db, db))
     mysql_change_db_impl(thd, NULL, 0, thd->variables.collation_server);
-  VOID(pthread_mutex_unlock(&LOCK_mysql_create_db));
+  pthread_mutex_unlock(&LOCK_mysql_create_db);
   start_waiting_global_read_lock(thd);
 exit2:
   DBUG_RETURN(error);
@@ -1120,9 +1120,9 @@ static long mysql_rm_known_files(THD *th
         goto err;
       table_list->db= (char*) (table_list+1);
       table_list->table_name= strmov(table_list->db, db) + 1;
-      VOID(filename_to_tablename(file->name, table_list->table_name,
+      (void) filename_to_tablename(file->name, table_list->table_name,
                                  MYSQL50_TABLE_NAME_PREFIX_LENGTH +
-                                 strlen(file->name) + 1));
+                                 strlen(file->name) + 1);
       table_list->alias= table_list->table_name;	// If lower_case_table_names=2
       table_list->internal_tmp_table= is_prefix(file->name, tmp_file_prefix);
       /* Link into list */
diff -Nrup a/sql/sql_delete.cc b/sql/sql_delete.cc
--- a/sql/sql_delete.cc	2008-03-27 13:03:58 +01:00
+++ b/sql/sql_delete.cc	2008-04-08 12:29:26 +02:00
@@ -1020,10 +1020,10 @@ bool mysql_truncate(THD *thd, TABLE_LIST
   // crashes, replacement works.  *(path + path_length - reg_ext_length)=
   // '\0';
   path[path_length - reg_ext_length] = 0;
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   error= ha_create_table(thd, path, table_list->db, table_list->table_name,
                          &create_info, 1);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   query_cache_invalidate3(thd, table_list, 0);
 
 end:
@@ -1038,15 +1038,15 @@ end:
       write_bin_log(thd, TRUE, thd->query, thd->query_length);
       my_ok(thd);		// This should return record count
     }
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     unlock_table_name(thd, table_list);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
   }
   else if (error)
   {
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     unlock_table_name(thd, table_list);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
   }
   DBUG_RETURN(error);
 
diff -Nrup a/sql/sql_handler.cc b/sql/sql_handler.cc
--- a/sql/sql_handler.cc	2008-02-19 13:57:59 +01:00
+++ b/sql/sql_handler.cc	2008-04-08 12:29:27 +02:00
@@ -143,14 +143,14 @@ static void mysql_ha_close_table(THD *th
   {
     (*table_ptr)->file->ha_index_or_rnd_end();
     if (! is_locked)
-      VOID(pthread_mutex_lock(&LOCK_open));
+      pthread_mutex_lock(&LOCK_open);
     if (close_thread_table(thd, table_ptr))
     {
       /* Tell threads waiting for refresh that something has happened */
       broadcast_refresh();
     }
     if (! is_locked)
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
   }
   else if (tables->table)
   {
diff -Nrup a/sql/sql_insert.cc b/sql/sql_insert.cc
--- a/sql/sql_insert.cc	2008-03-28 18:58:21 +01:00
+++ b/sql/sql_insert.cc	2008-04-08 12:29:27 +02:00
@@ -1026,7 +1026,7 @@ static bool check_view_insertability(THD
 
   DBUG_ASSERT(view->table != 0 && view->field_translation != 0);
 
-  VOID(bitmap_init(&used_fields, used_fields_buff, table->s->fields, 0));
+  (void) bitmap_init(&used_fields, used_fields_buff, table->s->fields, 0);
   bitmap_clear_all(&used_fields);
 
   view->contain_auto_increment= 0;
@@ -1719,9 +1719,9 @@ public:
     pthread_mutex_init(&mutex,MY_MUTEX_INIT_FAST);
     pthread_cond_init(&cond,NULL);
     pthread_cond_init(&cond_client,NULL);
-    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_lock(&LOCK_thread_count);
     delayed_insert_threads++;
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    pthread_mutex_unlock(&LOCK_thread_count);
   }
   ~Delayed_insert()
   {
@@ -1731,7 +1731,7 @@ public:
       delete row;
     if (table)
       close_thread_tables(&thd);
-    VOID(pthread_mutex_lock(&LOCK_thread_count));
+    pthread_mutex_lock(&LOCK_thread_count);
     pthread_mutex_destroy(&mutex);
     pthread_cond_destroy(&cond);
     pthread_cond_destroy(&cond_client);
@@ -1740,8 +1740,8 @@ public:
     thd.security_ctx->user= thd.security_ctx->host=0;
     thread_count--;
     delayed_insert_threads--;
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
-    VOID(pthread_cond_broadcast(&COND_thread_count)); /* Tell main we are ready */
+    pthread_mutex_unlock(&LOCK_thread_count);
+    pthread_cond_broadcast(&COND_thread_count); /* Tell main we are ready */
   }
 
   /* The following is for checking when we can delete ourselves */
@@ -2204,7 +2204,7 @@ static void end_delayed_insert(THD *thd)
 
 void kill_delayed_threads(void)
 {
-  VOID(pthread_mutex_lock(&LOCK_delayed_insert)); // For unlink from list
+  pthread_mutex_lock(&LOCK_delayed_insert); // For unlink from list
 
   I_List_iterator<Delayed_insert> it(delayed_threads);
   Delayed_insert *di;
@@ -2229,7 +2229,7 @@ void kill_delayed_threads(void)
       pthread_mutex_unlock(&di->thd.mysys_var->mutex);
     }
   }
-  VOID(pthread_mutex_unlock(&LOCK_delayed_insert)); // For unlink from list
+  pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
 }
 
 
@@ -3404,7 +3404,7 @@ static TABLE *create_table_from_items(TH
 
       if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
       {
-        VOID(pthread_mutex_lock(&LOCK_open));
+        pthread_mutex_lock(&LOCK_open);
         if (reopen_name_locked_table(thd, create_table, FALSE))
         {
           quick_rm_table(create_info->db_type, create_table->db,
@@ -3413,7 +3413,7 @@ static TABLE *create_table_from_items(TH
         }
         else
           table= create_table->table;
-        VOID(pthread_mutex_unlock(&LOCK_open));
+        pthread_mutex_unlock(&LOCK_open);
       }
       else
       {
diff -Nrup a/sql/sql_map.cc b/sql/sql_map.cc
--- a/sql/sql_map.cc	2007-10-23 11:28:37 +02:00
+++ b/sql/sql_map.cc	2008-04-08 12:29:28 +02:00
@@ -48,12 +48,12 @@ mapped_files::mapped_files(const char * 
     if (map && memcmp(map,magic,magic_length))
     {
       my_error(ER_WRONG_MAGIC, MYF(0), name);
-      VOID(my_munmap((char*) map,(size_t)size));
+      (void) my_munmap((char*) map,(size_t)size);
       map=0;
     }
     if (!map)
     {
-      VOID(my_close(file,MYF(0)));
+      (void) my_close(file,MYF(0));
       file= -1;
     }
   }
@@ -66,8 +66,8 @@ mapped_files::~mapped_files()
 #ifdef HAVE_MMAP
   if (file >= 0)
   {
-    VOID(my_munmap((char*) map,(size_t)size));
-    VOID(my_close(file,MYF(0)));
+    (void) my_munmap((char*) map,(size_t)size);
+    (void) my_close(file,MYF(0));
     file= -1; map=0;
   }
   my_free(name,MYF(0));
@@ -85,7 +85,7 @@ static I_List<mapped_files> maps_in_use;
 mapped_files *map_file(const char * name,uchar *magic,uint magic_length)
 {
 #ifdef HAVE_MMAP
-  VOID(pthread_mutex_lock(&LOCK_mapped_file));
+  pthread_mutex_lock(&LOCK_mapped_file);
   I_List_iterator<mapped_files> list(maps_in_use);
   mapped_files *map;
   char path[FN_REFLEN];
@@ -108,7 +108,7 @@ mapped_files *map_file(const char * name
     if (!map->map)
       my_error(ER_NO_FILE_MAPPING, MYF(0), path, map->error);
   }
-  VOID(pthread_mutex_unlock(&LOCK_mapped_file));
+  pthread_mutex_unlock(&LOCK_mapped_file);
   return map;
 #else
   return NULL;
@@ -122,10 +122,10 @@ mapped_files *map_file(const char * name
 void unmap_file(mapped_files *map)
 {
 #ifdef HAVE_MMAP
-  VOID(pthread_mutex_lock(&LOCK_mapped_file));
+  pthread_mutex_lock(&LOCK_mapped_file);
   if (!map->use_count--)
     delete map;
-  VOID(pthread_mutex_unlock(&LOCK_mapped_file));
+  pthread_mutex_unlock(&LOCK_mapped_file);
 #endif
 }
 
diff -Nrup a/sql/sql_parse.cc b/sql/sql_parse.cc
--- a/sql/sql_parse.cc	2008-03-28 11:03:03 +01:00
+++ b/sql/sql_parse.cc	2008-04-08 12:29:28 +02:00
@@ -893,13 +893,13 @@ bool dispatch_command(enum enum_server_c
   thd->enable_slow_log= TRUE;
   thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
   thd->set_time();
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
   thd->query_id= global_query_id;
   if (command != COM_STATISTICS && command != COM_PING)
     next_query_id();
   thread_running++;
   /* TODO: set thd->lex->sql_command to SQLCOM_END here */
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
 
   thd->server_status&=
            ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
@@ -1147,13 +1147,13 @@ bool dispatch_command(enum enum_server_c
       thd->profiling.set_query_source(beginning_of_next_stmt, length);
 #endif
 
-      VOID(pthread_mutex_lock(&LOCK_thread_count));
+      pthread_mutex_lock(&LOCK_thread_count);
       thd->query_length= length;
       thd->query= beginning_of_next_stmt;
       thd->query_id= next_query_id();
       thd->set_time(); /* Reset the query start time. */
       /* TODO: set thd->lex->sql_command to SQLCOM_END here */
-      VOID(pthread_mutex_unlock(&LOCK_thread_count));
+      pthread_mutex_unlock(&LOCK_thread_count);
       mysql_parse(thd, beginning_of_next_stmt, length, &end_of_stmt);
     }
 
@@ -1399,8 +1399,8 @@ bool dispatch_command(enum enum_server_c
     }
 #endif
 #ifndef EMBEDDED_LIBRARY
-    VOID(my_net_write(net, (uchar*) buff, length));
-    VOID(net_flush(net));
+    (void) my_net_write(net, (uchar*) buff, length);
+    (void) net_flush(net);
     thd->main_da.disable_status();
 #endif
     break;
@@ -1494,13 +1494,13 @@ bool dispatch_command(enum enum_server_c
   log_slow_statement(thd);
 
   thd_proc_info(thd, "cleaning up");
-  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
+  pthread_mutex_lock(&LOCK_thread_count); // For process list
   thd_proc_info(thd, 0);
   thd->command=COM_SLEEP;
   thd->query=0;
   thd->query_length=0;
   thread_running--;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
   free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
   DBUG_RETURN(error);
@@ -6627,7 +6627,7 @@ uint kill_one_thread(THD *thd, ulong id,
   uint error=ER_NO_SUCH_THREAD;
   DBUG_ENTER("kill_one_thread");
   DBUG_PRINT("enter", ("id=%lu only_kill=%d", id, only_kill_query));
-  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
+  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
   I_List_iterator<THD> it(threads);
   while ((tmp=it++))
   {
@@ -6639,7 +6639,7 @@ uint kill_one_thread(THD *thd, ulong id,
       break;
     }
   }
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   if (tmp)
   {
     if ((thd->security_ctx->master_access & SUPER_ACL) ||
diff -Nrup a/sql/sql_select.cc b/sql/sql_select.cc
--- a/sql/sql_select.cc	2008-03-31 09:40:36 +02:00
+++ b/sql/sql_select.cc	2008-04-08 12:29:29 +02:00
@@ -3489,7 +3489,7 @@ add_key_part(DYNAMIC_ARRAY *keyuse_array
 	  keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;
           keyuse.null_rejecting= key_field->null_rejecting;
           keyuse.cond_guard= key_field->cond_guard;
-	  VOID(insert_dynamic(keyuse_array,(uchar*) &keyuse));
+	  (void) insert_dynamic(keyuse_array,(uchar*) &keyuse);
 	}
       }
     }
@@ -3556,7 +3556,7 @@ add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
   keyuse.used_tables=cond_func->key_item()->used_tables();
   keyuse.optimize= 0;
   keyuse.keypart_map= 0;
-  VOID(insert_dynamic(keyuse_array,(uchar*) &keyuse));
+  (void) insert_dynamic(keyuse_array,(uchar*) &keyuse);
 }
 
 
@@ -3773,7 +3773,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_AR
 	  (qsort_cmp) sort_keyuse);
 
     bzero((char*) &key_end,sizeof(key_end));    /* Add for easy testing */
-    VOID(insert_dynamic(keyuse,(uchar*) &key_end));
+    (void) insert_dynamic(keyuse,(uchar*) &key_end);
 
     use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
     prev= &key_end;
@@ -3808,7 +3808,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_AR
       save_pos++;
     }
     i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);
-    VOID(set_dynamic(keyuse,(uchar*) &key_end,i));
+    (void) set_dynamic(keyuse,(uchar*) &key_end,i);
     keyuse->elements=i;
   }
   return FALSE;
@@ -8908,7 +8908,7 @@ remove_eq_conds(THD *thd, COND *cond, It
 	li.remove();
       else if (item != new_item)
       {
-	VOID(li.replace(new_item));
+	(void) li.replace(new_item);
 	should_fix_fields=1;
       }
       if (*cond_value == Item::COND_UNDEF)
@@ -10746,7 +10746,7 @@ do_select(JOIN *join,List<Item> *fields,
 
   if (table)
   {
-    VOID(table->file->extra(HA_EXTRA_WRITE_CACHE));
+    (void) table->file->extra(HA_EXTRA_WRITE_CACHE);
     empty_record(table);
     if (table->group && join->tmp_table_param.sum_func_count &&
         table->s->keys && !table->file->inited)
@@ -12040,7 +12040,7 @@ end_send_group(JOIN *join, JOIN_TAB *joi
       if (end_of_records)
 	DBUG_RETURN(NESTED_LOOP_OK);
       join->first_record=1;
-      VOID(test_if_group_changed(join->group_fields));
+      (void) test_if_group_changed(join->group_fields);
     }
     if (idx < (int) join->send_group_parts)
     {
@@ -12303,7 +12303,7 @@ end_write_group(JOIN *join, JOIN_TAB *jo
       if (end_of_records)
 	DBUG_RETURN(NESTED_LOOP_OK);
       join->first_record=1;
-      VOID(test_if_group_changed(join->group_fields));
+      (void) test_if_group_changed(join->group_fields);
     }
     if (idx < (int) join->send_group_parts)
     {
diff -Nrup a/sql/sql_servers.cc b/sql/sql_servers.cc
--- a/sql/sql_servers.cc	2008-03-21 09:45:58 +01:00
+++ b/sql/sql_servers.cc	2008-04-08 12:29:29 +02:00
@@ -662,7 +662,7 @@ delete_server_record_in_cache(LEX_SERVER
                      server->server_name,
                      server->server_name_length));
 
-  VOID(hash_delete(&servers_cache, (uchar*) server));
+  hash_delete(&servers_cache, (uchar*) server);
   
   error= 0;
 
@@ -769,7 +769,7 @@ int update_server_record_in_cache(FOREIG
   /*
     delete the existing server struct from the server cache
   */
-  VOID(hash_delete(&servers_cache, (uchar*)existing));
+  hash_delete(&servers_cache, (uchar*)existing);
 
   /*
     Insert the altered server struct into the server cache
diff -Nrup a/sql/sql_show.cc b/sql/sql_show.cc
--- a/sql/sql_show.cc	2008-03-28 11:03:04 +01:00
+++ b/sql/sql_show.cc	2008-04-08 12:29:30 +02:00
@@ -559,7 +559,7 @@ find_files(THD *thd, List<LEX_STRING> *f
   DBUG_PRINT("info",("found: %d files", files->elements));
   my_dirend(dirp);
 
-  VOID(ha_find_files(thd, db, path, wild, dir, files));
+  (void) ha_find_files(thd, db, path, wild, dir, files);
 
   DBUG_RETURN(FIND_FILES_OK);
 }
@@ -889,7 +889,7 @@ append_identifier(THD *thd, String *pack
    it's a keyword
   */
 
-  VOID(packet->reserve(length*2 + 2));
+  (void) packet->reserve(length*2 + 2);
   quote_char= (char) q;
   packet->append(&quote_char, 1, system_charset_info);
 
@@ -1657,7 +1657,7 @@ void mysqld_list_processes(THD *thd,cons
                             Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
     DBUG_VOID_RETURN;
 
-  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
+  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
   if (!thd->killed)
   {
     I_List_iterator<THD> it(threads);
@@ -1725,7 +1725,7 @@ void mysqld_list_processes(THD *thd,cons
       }
     }
   }
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
 
   thread_info *thd_info;
   time_t now= my_time(0);
@@ -1764,7 +1764,7 @@ int fill_schema_processlist(THD* thd, TA
   user= thd->security_ctx->master_access & PROCESS_ACL ?
         NullS : thd->security_ctx->priv_user;
 
-  VOID(pthread_mutex_lock(&LOCK_thread_count));
+  pthread_mutex_lock(&LOCK_thread_count);
 
   if (!thd->killed)
   {
@@ -1853,13 +1853,13 @@ int fill_schema_processlist(THD* thd, TA
 
       if (schema_table_store_record(thd, table))
       {
-        VOID(pthread_mutex_unlock(&LOCK_thread_count));
+        pthread_mutex_unlock(&LOCK_thread_count);
         DBUG_RETURN(1);
       }
     }
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   DBUG_RETURN(0);
 }
 
@@ -2202,7 +2202,7 @@ void calc_sum_of_all_status(STATUS_VAR *
   DBUG_ENTER("calc_sum_of_all_status");
 
   /* Ensure that thread id not killed during loop */
-  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
+  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
   I_List_iterator<THD> it(threads);
   THD *tmp;
@@ -2214,7 +2214,7 @@ void calc_sum_of_all_status(STATUS_VAR *
   while ((tmp= it++))
     add_to_status(to, &tmp->status_var);
   
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   DBUG_VOID_RETURN;
 }
 
@@ -2769,9 +2769,9 @@ make_table_name_list(THD *thd, List<LEX_
         Check that table is relevant in current transaction.
         (used for ndb engine, see ndbcluster_find_files(), ha_ndbcluster.cc)
       */
-      VOID(ha_find_files(thd, db_name->str, path,
+      (void) ha_find_files(thd, db_name->str, path,
                          lookup_field_vals->table_value.str, 0,
-                         table_names));
+                         table_names);
     }
     return 0;
   }
diff -Nrup a/sql/sql_string.cc b/sql/sql_string.cc
--- a/sql/sql_string.cc	2008-02-29 14:56:48 +01:00
+++ b/sql/sql_string.cc	2008-04-08 12:29:30 +02:00
@@ -122,7 +122,7 @@ bool String::set_real(double num,uint de
   int decpt,sign;
   char *pos,*to;
 
-  VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
+  (void) fconvert(num,(int) decimals,&decpt,&sign,buff+1);
   if (!my_isdigit(&my_charset_latin1, buff[1]))
   {						// Nan or Inf
     pos=buff+1;
diff -Nrup a/sql/sql_table.cc b/sql/sql_table.cc
--- a/sql/sql_table.cc	2008-03-28 11:03:05 +01:00
+++ b/sql/sql_table.cc	2008-04-08 12:29:31 +02:00
@@ -196,9 +196,9 @@ uint build_table_filename(char *buff, si
   if (flags & FN_IS_TMP) // FN_FROM_IS_TMP | FN_TO_IS_TMP
     strnmov(tbbuff, table_name, sizeof(tbbuff));
   else
-    VOID(tablename_to_filename(table_name, tbbuff, sizeof(tbbuff)));
+    (void) tablename_to_filename(table_name, tbbuff, sizeof(tbbuff));
 
-  VOID(tablename_to_filename(db, dbbuff, sizeof(dbbuff)));
+  (void) tablename_to_filename(db, dbbuff, sizeof(dbbuff));
 
   char *end = buff + bufflen;
   /* Don't add FN_ROOTDIR if mysql_data_home already includes it */
@@ -398,7 +398,7 @@ static bool write_ddl_log_header()
     sql_print_error("Error writing ddl log header");
     DBUG_RETURN(TRUE);
   }
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   DBUG_RETURN(error);
 }
 
@@ -466,7 +466,7 @@ static uint read_ddl_log_header()
   global_ddl_log.first_free= NULL;
   global_ddl_log.first_used= NULL;
   global_ddl_log.num_entries= 0;
-  VOID(pthread_mutex_init(&LOCK_gdl, MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&LOCK_gdl, MY_MUTEX_INIT_FAST);
   global_ddl_log.do_release= true;
   DBUG_RETURN(entry_no);
 }
@@ -548,7 +548,7 @@ static bool init_ddl_log()
   global_ddl_log.inited= TRUE;
   if (write_ddl_log_header())
   {
-    VOID(my_close(global_ddl_log.file_id, MYF(MY_WME)));
+    (void) my_close(global_ddl_log.file_id, MYF(MY_WME));
     global_ddl_log.inited= FALSE;
     DBUG_RETURN(TRUE);
   }
@@ -625,7 +625,7 @@ static int execute_ddl_log_action(THD *t
           }
 #ifdef WITH_PARTITION_STORAGE_ENGINE
           strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
-          VOID(my_delete(to_path, MYF(MY_WME)));
+          (void) my_delete(to_path, MYF(MY_WME));
 #endif
         }
         else
@@ -638,7 +638,7 @@ static int execute_ddl_log_action(THD *t
         }
         if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
           break;
-        VOID(sync_ddl_log());
+        (void) sync_ddl_log();
         error= FALSE;
         if (ddl_log_entry->action_type == DDL_LOG_DELETE_ACTION)
           break;
@@ -662,7 +662,7 @@ static int execute_ddl_log_action(THD *t
 #ifdef WITH_PARTITION_STORAGE_ENGINE
         strxmov(to_path, ddl_log_entry->name, par_ext, NullS);
         strxmov(from_path, ddl_log_entry->from_name, par_ext, NullS);
-        VOID(my_rename(from_path, to_path, MYF(MY_WME)));
+        (void) my_rename(from_path, to_path, MYF(MY_WME));
 #endif
       }
       else
@@ -673,7 +673,7 @@ static int execute_ddl_log_action(THD *t
       }
       if ((deactivate_ddl_log_entry(ddl_log_entry->entry_pos)))
         break;
-      VOID(sync_ddl_log());
+      (void) sync_ddl_log();
       error= FALSE;
       break;
     }
@@ -802,7 +802,7 @@ bool write_ddl_log_entry(DDL_LOG_ENTRY *
   }
   if (write_header && !error)
   {
-    VOID(sync_ddl_log());
+    (void) sync_ddl_log();
     if (write_ddl_log_header())
       error= TRUE;
   }
@@ -859,7 +859,7 @@ bool write_execute_ddl_log_entry(uint fi
       any log entries before, we are only here to write the execute
       entry to indicate it is done.
     */
-    VOID(sync_ddl_log());
+    (void) sync_ddl_log();
     file_entry_buf[DDL_LOG_ENTRY_TYPE_POS]= (char)DDL_LOG_EXECUTE_CODE;
   }
   else
@@ -883,7 +883,7 @@ bool write_execute_ddl_log_entry(uint fi
     release_ddl_log_memory_entry(*active_entry);
     DBUG_RETURN(TRUE);
   }
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   if (write_header)
   {
     if (write_ddl_log_header())
@@ -1075,7 +1075,7 @@ static void close_ddl_log()
   DBUG_ENTER("close_ddl_log");
   if (global_ddl_log.file_id >= 0)
   {
-    VOID(my_close(global_ddl_log.file_id, MYF(MY_WME)));
+    (void) my_close(global_ddl_log.file_id, MYF(MY_WME));
     global_ddl_log.file_id= (File) -1;
   }
   DBUG_VOID_RETURN;
@@ -1135,7 +1135,7 @@ void execute_ddl_log_recovery()
   }
   close_ddl_log();
   create_ddl_log_file_name(file_name);
-  VOID(my_delete(file_name, MYF(0)));
+  (void) my_delete(file_name, MYF(0));
   global_ddl_log.recovery_phase= FALSE;
   delete thd;
   /* Remember that we don't have a THD */
@@ -1177,7 +1177,7 @@ void release_ddl_log()
   close_ddl_log();
   global_ddl_log.inited= 0;
   pthread_mutex_unlock(&LOCK_gdl);
-  VOID(pthread_mutex_destroy(&LOCK_gdl));
+  pthread_mutex_destroy(&LOCK_gdl);
   global_ddl_log.do_release= false;
   DBUG_VOID_RETURN;
 }
@@ -1354,7 +1354,7 @@ bool mysql_write_frm(ALTER_PARTITION_PAR
       completing this we write a new phase to the log entry that will
       deactivate it.
     */
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     if (my_delete(frm_name, MYF(MY_WME)) ||
 #ifdef WITH_PARTITION_STORAGE_ENGINE
         lpt->table->file->ha_create_handler_files(path, shadow_path,
@@ -1405,11 +1405,11 @@ bool mysql_write_frm(ALTER_PARTITION_PAR
 #endif
 
 err:
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
 #ifdef WITH_PARTITION_STORAGE_ENGINE
     deactivate_ddl_log_entry(part_info->frm_log_entry->entry_pos);
     part_info->frm_log_entry= NULL;
-    VOID(sync_ddl_log());
+    (void) sync_ddl_log();
 #endif
   }
 
@@ -3453,7 +3453,7 @@ bool mysql_create_table_no_lock(THD *thd
     goto err;
   }
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   if (!internal_tmp_table && !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
   {
     if (!access(path,F_OK))
@@ -3579,7 +3579,7 @@ bool mysql_create_table_no_lock(THD *thd
     write_bin_log(thd, TRUE, thd->query, thd->query_length);
   error= FALSE;
 unlock_and_end:
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 
 err:
   thd_proc_info(thd, "After create");
@@ -3830,7 +3830,7 @@ void wait_while_table_is_used(THD *thd, 
 
   safe_mutex_assert_owner(&LOCK_open);
 
-  VOID(table->file->extra(function));
+  (void) table->file->extra(function);
   /* Mark all tables that are in use as 'old' */
   mysql_lock_abort(thd, table, TRUE);	/* end threads waiting on lock */
 
@@ -3912,7 +3912,7 @@ static int prepare_for_restore(THD* thd,
     char* table_name= table->table_name;
     char* db= table->db;
 
-    VOID(tablename_to_filename(table->table_name, uname, sizeof(uname)));
+    (void) tablename_to_filename(table->table_name, uname, sizeof(uname));
 
     if (fn_format_relative_to_data_home(src_path, uname, backup_dir, reg_ext))
       DBUG_RETURN(-1); // protect buffer overflow
@@ -4845,12 +4845,12 @@ bool mysql_create_like_table(THD* thd, T
     Also some engines (e.g. NDB cluster) require that LOCK_open should be held
     during the call to ha_create_table(). See bug #28614 for more info.
   */
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   if (src_table->schema_table)
   {
     if (mysql_create_like_schema_frm(thd, src_table, dst_path, create_info))
     {
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       goto err;
     }
   }
@@ -4860,7 +4860,7 @@ bool mysql_create_like_table(THD* thd, T
       my_error(ER_BAD_DB_ERROR,MYF(0),db);
     else
       my_error(ER_CANT_CREATE_FILE,MYF(0),dst_path,my_errno);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     goto err;
   }
 
@@ -4889,7 +4889,7 @@ bool mysql_create_like_table(THD* thd, T
   if (thd->variables.keep_files_on_create)
     create_info->options|= HA_CREATE_KEEP_FILES;
   err= ha_create_table(thd, dst_path, db, table_name, create_info, 1);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 
   if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
   {
@@ -4944,13 +4944,13 @@ bool mysql_create_like_table(THD* thd, T
           of this function.
         */
         table->table= name_lock;
-        VOID(pthread_mutex_lock(&LOCK_open));
+        pthread_mutex_lock(&LOCK_open);
         if (reopen_name_locked_table(thd, table, FALSE))
         {
-          VOID(pthread_mutex_unlock(&LOCK_open));
+          pthread_mutex_unlock(&LOCK_open);
           goto err;
         }
-        VOID(pthread_mutex_unlock(&LOCK_open));
+        pthread_mutex_unlock(&LOCK_open);
 
         IF_DBUG(int result=) store_create_info(thd, table, &query,
                                                create_info);
@@ -6025,7 +6025,7 @@ bool mysql_alter_table(THD *thd,char *ne
 
     if (wait_if_global_read_lock(thd,0,1))
       DBUG_RETURN(TRUE);
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     if (lock_table_names(thd, table_list))
     {
       error= 1;
@@ -6194,17 +6194,17 @@ view_err:
         while the fact that the table is still open gives us protection
         from concurrent DDL statements.
       */
-      VOID(pthread_mutex_lock(&LOCK_open));
+      pthread_mutex_lock(&LOCK_open);
       wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       DBUG_EXECUTE_IF("sleep_alter_enable_indexes", my_sleep(6000000););
       error= table->file->ha_enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
       /* COND_refresh will be signaled in close_thread_tables() */
       break;
     case DISABLE:
-      VOID(pthread_mutex_lock(&LOCK_open));
+      pthread_mutex_lock(&LOCK_open);
       wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
-      VOID(pthread_mutex_unlock(&LOCK_open));
+      pthread_mutex_unlock(&LOCK_open);
       error=table->file->ha_disable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
       /* COND_refresh will be signaled in close_thread_tables() */
       break;
@@ -6221,7 +6221,7 @@ view_err:
 			  table->alias);
     }
 
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     /*
       Unlike to the above case close_cached_table() below will remove ALL
       instances of TABLE from table cache (it will also remove table lock
@@ -6260,8 +6260,8 @@ view_err:
         else if (Table_triggers_list::change_table_name(thd, db, table_name,
                                                         new_db, new_alias))
         {
-          VOID(mysql_rename_table(old_db_type, new_db, new_alias, db,
-                                  table_name, 0));
+          (void) mysql_rename_table(old_db_type, new_db, new_alias, db,
+                                  table_name, 0);
           error= -1;
         }
       }
@@ -6287,7 +6287,7 @@ view_err:
     }
     if (name_lock)
       unlink_open_table(thd, name_lock, FALSE);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     table_list->table= NULL;                    // For query cache
     query_cache_invalidate3(thd, table_list, 0);
     DBUG_RETURN(error);
@@ -6589,9 +6589,9 @@ view_err:
   }
   else
   {
-    VOID(pthread_mutex_lock(&LOCK_open));
+    pthread_mutex_lock(&LOCK_open);
     wait_while_table_is_used(thd, table, HA_EXTRA_FORCE_REOPEN);
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    pthread_mutex_unlock(&LOCK_open);
     alter_table_manage_keys(table, table->file->indexes_are_disabled(),
                             alter_info->keys_onoff);
     error= ha_autocommit_or_rollback(thd, 0);
@@ -6720,11 +6720,11 @@ view_err:
     intern_close_table(new_table);
     my_free(new_table,MYF(0));
   }
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   if (error)
   {
-    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
-    VOID(pthread_mutex_unlock(&LOCK_open));
+    (void) quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP);
+    pthread_mutex_unlock(&LOCK_open);
     goto err;
   }
 
@@ -6779,7 +6779,7 @@ view_err:
                          FN_TO_IS_TMP))
   {
     error=1;
-    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
+    (void) quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP);
   }
   else if (mysql_rename_table(new_db_type, new_db, tmp_name, new_db,
                               new_alias, FN_FROM_IS_TMP) ||
@@ -6792,10 +6792,10 @@ view_err:
   {
     /* Try to get everything back. */
     error=1;
-    VOID(quick_rm_table(new_db_type,new_db,new_alias, 0));
-    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
-    VOID(mysql_rename_table(old_db_type, db, old_name, db, alias,
-                            FN_FROM_IS_TMP));
+    (void) quick_rm_table(new_db_type,new_db,new_alias, 0);
+    (void) quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP);
+    (void) mysql_rename_table(old_db_type, db, old_name, db, alias,
+                            FN_FROM_IS_TMP);
   }
 
   if (error)
@@ -6847,7 +6847,7 @@ view_err:
     }
   }
 
-  VOID(quick_rm_table(old_db_type, db, old_name, FN_IS_TMP));
+  (void) quick_rm_table(old_db_type, db, old_name, FN_IS_TMP);
 
   if (thd->locked_tables && new_name == table_name && new_db == db)
   {
@@ -6857,7 +6857,7 @@ view_err:
     if (error)
       goto err_with_placeholders;
   }
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 
   thd_proc_info(thd, "end");
 
@@ -6925,7 +6925,7 @@ err1:
     close_temporary_table(thd, new_table, 1, 1);
   }
   else
-    VOID(quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP));
+    (void) quick_rm_table(new_db_type, new_db, tmp_name, FN_IS_TMP);
 
 err:
   /*
@@ -6977,7 +6977,7 @@ err_with_placeholders:
   unlink_open_table(thd, table, FALSE);
   if (name_lock)
     unlink_open_table(thd, name_lock, FALSE);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   DBUG_RETURN(TRUE);
 }
 /* mysql_alter_table */
diff -Nrup a/sql/sql_test.cc b/sql/sql_test.cc
--- a/sql/sql_test.cc	2008-03-07 10:25:36 +01:00
+++ b/sql/sql_test.cc	2008-04-08 12:29:31 +02:00
@@ -74,7 +74,7 @@ void print_cached_tables(void)
   TABLE *start_link,*lnk;
 
   /* purecov: begin tested */
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   puts("DB             Table                            Version  Thread  Open  Lock");
 
   for (idx=unused=0 ; idx < open_cache.records ; idx++)
@@ -110,7 +110,7 @@ void print_cached_tables(void)
   if (hash_check(&open_cache))
     printf("Error: File hash table is corrupted\n");
   fflush(stdout);
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   /* purecov: end */
   return;
 }
@@ -149,7 +149,7 @@ void TEST_filesort(SORT_FIELD *sortorder
   }
   out.append('\0');				// Purify doesn't like c_ptr()
   DBUG_LOCK_FILE;
-  VOID(fputs("\nInfo about FILESORT\n",DBUG_FILE));
+  (void) fputs("\nInfo about FILESORT\n",DBUG_FILE);
   fprintf(DBUG_FILE,"Sortorder: %s\n",out.ptr());
   DBUG_UNLOCK_FILE;
   DBUG_VOID_RETURN;
@@ -163,7 +163,7 @@ TEST_join(JOIN *join)
   DBUG_ENTER("TEST_join");
 
   DBUG_LOCK_FILE;
-  VOID(fputs("\nInfo about JOIN\n",DBUG_FILE));
+  (void) fputs("\nInfo about JOIN\n",DBUG_FILE);
   for (i=0 ; i < join->tables ; i++)
   {
     JOIN_TAB *tab=join->join_tab+i;
@@ -189,17 +189,17 @@ TEST_join(JOIN *join)
         tab->select->quick->dbug_dump(18, FALSE);
       }
       else
-	VOID(fputs("                  select used\n",DBUG_FILE));
+	(void) fputs("                  select used\n",DBUG_FILE);
     }
     if (tab->ref.key_parts)
     {
-      VOID(fputs("                  refs: ",DBUG_FILE));
+      (void) fputs("                  refs: ",DBUG_FILE);
       for (ref=0 ; ref < tab->ref.key_parts ; ref++)
       {
 	Item *item=tab->ref.items[ref];
 	fprintf(DBUG_FILE,"%s  ", item->full_name());
       }
-      VOID(fputc('\n',DBUG_FILE));
+      (void) fputc('\n',DBUG_FILE);
     }
   }
   DBUG_UNLOCK_FILE;
@@ -349,7 +349,7 @@ static void push_locks_into_array(DYNAMI
       table_lock_info.lock_text=text;
       // lock_type is also obtainable from THR_LOCK_DATA
       table_lock_info.type=table->reginfo.lock_type;
-      VOID(push_dynamic(ar,(uchar*) &table_lock_info));
+      (void) push_dynamic(ar,(uchar*) &table_lock_info);
     }
   }
 }
@@ -374,13 +374,13 @@ static void display_table_locks(void) 
   LIST *list;
   DYNAMIC_ARRAY saved_table_locks;
 
-  VOID(my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO),open_cache.records + 20,50));
-  VOID(pthread_mutex_lock(&THR_LOCK_lock));
+  (void) my_init_dynamic_array(&saved_table_locks,sizeof(TABLE_LOCK_INFO),open_cache.records + 20,50);
+  pthread_mutex_lock(&THR_LOCK_lock);
   for (list= thr_lock_thread_list; list; list= list_rest(list))
   {
     THR_LOCK *lock=(THR_LOCK*) list->data;
 
-    VOID(pthread_mutex_lock(&lock->mutex));
+    pthread_mutex_lock(&lock->mutex);
     push_locks_into_array(&saved_table_locks, lock->write.data, FALSE,
 			  "Locked - write");
     push_locks_into_array(&saved_table_locks, lock->write_wait.data, TRUE,
@@ -389,9 +389,9 @@ static void display_table_locks(void) 
 			  "Locked - read");
     push_locks_into_array(&saved_table_locks, lock->read_wait.data, TRUE,
 			  "Waiting - read");
-    VOID(pthread_mutex_unlock(&lock->mutex));
+    pthread_mutex_unlock(&lock->mutex);
   }
-  VOID(pthread_mutex_unlock(&THR_LOCK_lock));
+  pthread_mutex_unlock(&THR_LOCK_lock);
   if (!saved_table_locks.elements) goto end;
   
   qsort((uchar*) dynamic_element(&saved_table_locks,0,TABLE_LOCK_INFO *),saved_table_locks.elements,sizeof(TABLE_LOCK_INFO),(qsort_cmp) dl_compare);
@@ -456,7 +456,7 @@ void mysql_print_status()
 
   calc_sum_of_all_status(&tmp);
   printf("\nStatus information:\n\n");
-  VOID(my_getwd(current_dir, sizeof(current_dir),MYF(0)));
+  (void) my_getwd(current_dir, sizeof(current_dir),MYF(0));
   printf("Current dir: %s\n", current_dir);
   printf("Running threads: %d  Stack size: %ld\n", thread_count,
 	 (long) my_thread_stack_size);
diff -Nrup a/sql/sql_trigger.cc b/sql/sql_trigger.cc
--- a/sql/sql_trigger.cc	2008-02-19 13:45:17 +01:00
+++ b/sql/sql_trigger.cc	2008-04-08 12:29:32 +02:00
@@ -387,7 +387,7 @@ bool mysql_create_or_drop_trigger(THD *t
       !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
     DBUG_RETURN(TRUE);
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
 
   if (!create)
   {
@@ -510,7 +510,7 @@ end:
     write_bin_log(thd, TRUE, stmt_query.ptr(), stmt_query.length());
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 
   if (need_start_waiting)
     start_waiting_global_read_lock(thd);
diff -Nrup a/sql/sql_update.cc b/sql/sql_update.cc
--- a/sql/sql_update.cc	2008-03-27 13:03:59 +01:00
+++ b/sql/sql_update.cc	2008-04-08 12:29:32 +02:00
@@ -764,7 +764,7 @@ int mysql_update(THD *thd,
   end_read_record(&info);
   delete select;
   thd_proc_info(thd, "end");
-  VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY));
+  (void) table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
 
   /*
     Invalidate the table in the query cache if something changed.
@@ -1728,7 +1728,7 @@ void multi_update::abort()
          todo/fixme: do_update() is never called with the arg 1.
          should it change the signature to become argless?
       */
-      VOID(do_updates());
+      (void) do_updates();
     }
   }
   if (thd->transaction.stmt.modified_non_trans_table)
diff -Nrup a/sql/sql_view.cc b/sql/sql_view.cc
--- a/sql/sql_view.cc	2008-02-26 14:19:21 +01:00
+++ b/sql/sql_view.cc	2008-04-08 12:29:33 +02:00
@@ -609,7 +609,7 @@ bool mysql_create_view(THD *thd, TABLE_L
     res= TRUE;
     goto err;
   }
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   res= mysql_register_view(thd, view, mode);
 
   if (mysql_bin_log.is_open())
@@ -654,7 +654,7 @@ bool mysql_create_view(THD *thd, TABLE_L
                       buff.ptr(), buff.length(), FALSE, FALSE);
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   if (view->revision != 1)
     query_cache_invalidate3(thd, view, 0);
   start_waiting_global_read_lock(thd);
@@ -1566,7 +1566,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIS
   bool something_wrong= FALSE;
   DBUG_ENTER("mysql_drop_view");
 
-  VOID(pthread_mutex_lock(&LOCK_open));
+  pthread_mutex_lock(&LOCK_open);
   for (view= views; view; view= view->next_local)
   {
     TABLE_SHARE *share;
@@ -1643,7 +1643,7 @@ bool mysql_drop_view(THD *thd, TABLE_LIS
     write_bin_log(thd, !something_wrong, thd->query, thd->query_length);
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   
   if (something_wrong)
   {
diff -Nrup a/sql/stacktrace.c b/sql/stacktrace.c
--- a/sql/stacktrace.c	2008-02-21 01:53:33 +01:00
+++ b/sql/stacktrace.c	2008-04-08 12:29:33 +02:00
@@ -13,9 +13,6 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-/* Workaround for Bug#32082: VOID redefinition on Win results in compile errors*/
-#define DONT_DEFINE_VOID 1
-
 #include <my_global.h>
 #include "stacktrace.h"
 
diff -Nrup a/sql/table.cc b/sql/table.cc
--- a/sql/table.cc	2008-03-28 11:03:06 +01:00
+++ b/sql/table.cc	2008-04-08 12:29:34 +02:00
@@ -741,7 +741,7 @@ static int open_binary_frm(THD *thd, TAB
 
   /* Read keyinformation */
   key_info_length= (uint) uint2korr(head+28);
-  VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
+  my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0));
   if (read_string(file,(uchar**) &disk_buff,key_info_length))
     goto err;                                   /* purecov: inspected */
   if (disk_buff[0] & 0x80)
@@ -1008,7 +1008,7 @@ static int open_binary_frm(THD *thd, TAB
                record_offset, MYF(MY_NABP)))
     goto err;                                   /* purecov: inspected */
 
-  VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
+  my_seek(file,pos,MY_SEEK_SET,MYF(0));
   if (my_read(file, head,288,MYF(MY_NABP)))
     goto err;
 #ifdef HAVE_CRYPTED_FRM
@@ -2020,7 +2020,7 @@ ulong get_form_pos(File file, uchar *hea
   if (names)
   {
     length=uint2korr(head+4);
-    VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
+    my_seek(file,64L,MY_SEEK_SET,MYF(0));
     if (!(buf= (uchar*) my_malloc((size_t) length+a_length+names*4,
 				  MYF(MY_WME))) ||
 	my_read(file, buf+a_length, (size_t) (length+names*4),
@@ -2099,17 +2099,17 @@ ulong make_new_entry(File file, uchar *f
 
     while (endpos > maxlength)
     {
-      VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
+      my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0));
       if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
 	DBUG_RETURN(0L);
-      VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
-		   MYF(0)));
+      my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
+		   MYF(0));
       if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))
 	DBUG_RETURN(0);
       endpos-=bufflength; bufflength=IO_SIZE;
     }
     bzero(buff,IO_SIZE);			/* Null new block */
-    VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
+    my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0));
     if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
 	DBUG_RETURN(0L);
     maxlength+=IO_SIZE;				/* Fix old ref */
@@ -2125,11 +2125,11 @@ ulong make_new_entry(File file, uchar *f
   if (n_length == 1 )
   {						/* First name */
     length++;
-    VOID(strxmov((char*) buff,"/",newname,"/",NullS));
+    (void) strxmov((char*) buff,"/",newname,"/",NullS);
   }
   else
-    VOID(strxmov((char*) buff,newname,"/",NullS)); /* purecov: inspected */
-  VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
+    (void) strxmov((char*) buff,newname,"/",NullS); /* purecov: inspected */
+  my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0));
   if (my_write(file, buff, (size_t) length+1,MYF(MY_NABP+MY_WME)) ||
       (names && my_write(file,(uchar*) (*formnames->type_names+n_length-1),
 			 names*4, MYF(MY_NABP+MY_WME))) ||
@@ -2138,7 +2138,7 @@ ulong make_new_entry(File file, uchar *f
 
   int2store(fileinfo+8,names+1);
   int2store(fileinfo+4,n_length+length);
-  VOID(my_chsize(file, newpos, 0, MYF(MY_WME)));/* Append file with '\0' */
+  (void) my_chsize(file, newpos, 0, MYF(MY_WME));/* Append file with '\0' */
   DBUG_RETURN(newpos);
 } /* make_new_entry */
 
@@ -2489,8 +2489,8 @@ File create_frm(THD *thd, const char *na
     {
       if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
       {
-	VOID(my_close(file,MYF(0)));
-	VOID(my_delete(name,MYF(0)));
+	(void) my_close(file,MYF(0));
+	(void) my_delete(name,MYF(0));
 	return(-1);
       }
     }
@@ -2527,8 +2527,8 @@ int
 rename_file_ext(const char * from,const char * to,const char * ext)
 {
   char from_b[FN_REFLEN],to_b[FN_REFLEN];
-  VOID(strxmov(from_b,from,ext,NullS));
-  VOID(strxmov(to_b,to,ext,NullS));
+  (void) strxmov(from_b,from,ext,NullS);
+  (void) strxmov(to_b,to,ext,NullS);
   return (my_rename(from_b,to_b,MYF(MY_WME)));
 }
 
diff -Nrup a/sql/tztime.cc b/sql/tztime.cc
--- a/sql/tztime.cc	2008-04-03 19:20:57 +02:00
+++ b/sql/tztime.cc	2008-04-08 12:29:34 +02:00
@@ -1592,7 +1592,7 @@ my_tz_init(THD *org_thd, const char *def
     goto end;
   }
   init_alloc_root(&tz_storage, 32 * 1024, 0);
-  VOID(pthread_mutex_init(&tz_LOCK, MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&tz_LOCK, MY_MUTEX_INIT_FAST);
   tz_inited= 1;
 
   /* Add 'SYSTEM' time zone to tz_names hash */
@@ -1770,7 +1770,7 @@ void my_tz_free()
   if (tz_inited)
   {
     tz_inited= 0;
-    VOID(pthread_mutex_destroy(&tz_LOCK));
+    pthread_mutex_destroy(&tz_LOCK);
     hash_free(&offset_tzs);
     hash_free(&tz_names);
     free_root(&tz_storage, MYF(0));
@@ -2231,7 +2231,7 @@ my_tz_find(THD *thd, const String *name)
   if (!name)
     DBUG_RETURN(0);
 
-  VOID(pthread_mutex_lock(&tz_LOCK));
+  pthread_mutex_lock(&tz_LOCK);
 
   if (!str_to_offset(name->ptr(), name->length(), &offset))
   {
@@ -2273,7 +2273,7 @@ my_tz_find(THD *thd, const String *name)
     }
   }
 
-  VOID(pthread_mutex_unlock(&tz_LOCK));
+  pthread_mutex_unlock(&tz_LOCK);
 
   DBUG_RETURN(result_tz);
 }
diff -Nrup a/sql/udf_example.c b/sql/udf_example.c
--- a/sql/udf_example.c	2007-11-27 16:19:50 +01:00
+++ b/sql/udf_example.c	2008-04-08 12:29:35 +02:00
@@ -762,14 +762,14 @@ char *lookup(UDF_INIT *initid __attribut
     return 0;
   }
 #else
-  VOID(pthread_mutex_lock(&LOCK_hostname));
+  pthread_mutex_lock(&LOCK_hostname);
   if (!(hostent= gethostbyname((char*) name_buff)))
   {
-    VOID(pthread_mutex_unlock(&LOCK_hostname));
+    pthread_mutex_unlock(&LOCK_hostname);
     *null_value= 1;
     return 0;
   }
-  VOID(pthread_mutex_unlock(&LOCK_hostname));
+  pthread_mutex_unlock(&LOCK_hostname);
 #endif
   memcpy_fixed((char*) &in,(char*) *hostent->h_addr_list, sizeof(in.s_addr));
   *res_length= (ulong) (strmov(result, inet_ntoa(in)) - result);
@@ -866,14 +866,14 @@ char *reverse_lookup(UDF_INIT *initid __
     return 0;
   }
 #else
-  VOID(pthread_mutex_lock(&LOCK_hostname));
+  pthread_mutex_lock(&LOCK_hostname);
   if (!(hp= gethostbyaddr((char*) &taddr, sizeof(taddr), AF_INET)))
   {
-    VOID(pthread_mutex_unlock(&LOCK_hostname));
+    pthread_mutex_unlock(&LOCK_hostname);
     *null_value= 1;
     return 0;
   }
-  VOID(pthread_mutex_unlock(&LOCK_hostname));
+  pthread_mutex_unlock(&LOCK_hostname);
 #endif
   *res_length=(ulong) (strmov(result,hp->h_name) - result);
   return result;
diff -Nrup a/sql/uniques.cc b/sql/uniques.cc
--- a/sql/uniques.cc	2007-07-04 10:40:10 +02:00
+++ b/sql/uniques.cc	2008-04-08 12:29:35 +02:00
@@ -66,8 +66,8 @@ Unique::Unique(qsort_cmp2 comp_func, voi
   */
   max_elements= (ulong) (max_in_memory_size /
                          ALIGN_SIZE(sizeof(TREE_ELEMENT)+size));
-  VOID(open_cached_file(&file, mysql_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
-		   MYF(MY_WME)));
+  (void) open_cached_file(&file, mysql_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
+		   MYF(MY_WME));
 }
 
 
diff -Nrup a/sql/unireg.cc b/sql/unireg.cc
--- a/sql/unireg.cc	2008-03-28 11:03:06 +01:00
+++ b/sql/unireg.cc	2008-04-08 12:29:36 +02:00
@@ -195,7 +195,7 @@ bool mysql_create_frm(THD *thd, const ch
   key_buff_length= uint4korr(fileinfo+47);
   keybuff=(uchar*) my_malloc(key_buff_length, MYF(0));
   key_info_length= pack_keys(keybuff, keys, key_info, data_offset);
-  VOID(get_form_pos(file,fileinfo,&formnames));
+  (void) get_form_pos(file,fileinfo,&formnames);
   if (!(filepos=make_new_entry(file,fileinfo,&formnames,"")))
     goto err;
   maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));
@@ -248,9 +248,9 @@ bool mysql_create_frm(THD *thd, const ch
       my_pwrite(file, keybuff, key_info_length,
 		(ulong) uint2korr(fileinfo+6),MYF_RW))
     goto err;
-  VOID(my_seek(file,
+  my_seek(file,
 	       (ulong) uint2korr(fileinfo+6)+ (ulong) key_buff_length,
-	       MY_SEEK_SET,MYF(0)));
+	       MY_SEEK_SET,MYF(0));
   if (make_empty_rec(thd,file,ha_legacy_type(create_info->db_type),
                      create_info->table_options,
 		     create_fields,reclength, data_offset, db_file))
@@ -296,7 +296,7 @@ bool mysql_create_frm(THD *thd, const ch
     }
   }
 
-  VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
+  my_seek(file,filepos,MY_SEEK_SET,MYF(0));
   if (my_write(file, forminfo, 288, MYF_RW) ||
       my_write(file, screen_buff, info_length, MYF_RW) ||
       pack_fields(file, create_fields, data_offset))
@@ -310,7 +310,7 @@ bool mysql_create_frm(THD *thd, const ch
     if (!crypted || my_pwrite(file,&tmp,1,26,MYF_RW))	// Mark crypted
       goto err;
     uint read_length=uint2korr(forminfo)-256;
-    VOID(my_seek(file,filepos+256,MY_SEEK_SET,MYF(0)));
+    my_seek(file,filepos+256,MY_SEEK_SET,MYF(0));
     if (read_string(file,(uchar**) &disk_buff,read_length))
       goto err;
     crypted->encode(disk_buff,read_length);
@@ -357,7 +357,7 @@ err:
   my_free(screen_buff, MYF(0));
   my_free(keybuff, MYF(0));
 err2:
-  VOID(my_close(file,MYF(MY_WME)));
+  (void) my_close(file,MYF(MY_WME));
 err3:
   my_delete(file_name,MYF(0));
   DBUG_RETURN(1);
@@ -411,7 +411,7 @@ int rea_create_table(THD *thd, const cha
   DBUG_RETURN(0);
 
 err_handler:
-  VOID(file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info));
+  (void) file->ha_create_handler_files(path, NULL, CHF_DELETE_FLAG, create_info);
   my_delete(frm_name, MYF(0));
   DBUG_RETURN(1);
 } /* rea_create_table */
diff -Nrup a/storage/archive/ha_archive.cc b/storage/archive/ha_archive.cc
--- a/storage/archive/ha_archive.cc	2007-12-20 21:24:07 +01:00
+++ b/storage/archive/ha_archive.cc	2008-04-08 12:29:36 +02:00
@@ -174,7 +174,7 @@ int archive_db_init(void *p)
   if (hash_init(&archive_open_tables, system_charset_info, 32, 0, 0,
                 (hash_get_key) archive_get_key, 0, 0))
   {
-    VOID(pthread_mutex_destroy(&archive_mutex));
+    pthread_mutex_destroy(&archive_mutex);
   }
   else
   {
@@ -198,7 +198,7 @@ error:
 int archive_db_done(void *p)
 {
   hash_free(&archive_open_tables);
-  VOID(pthread_mutex_destroy(&archive_mutex));
+  pthread_mutex_destroy(&archive_mutex);
 
   return 0;
 }
@@ -345,7 +345,7 @@ ARCHIVE_SHARE *ha_archive::get_share(con
     /*
       We will use this lock for rows.
     */
-    VOID(pthread_mutex_init(&share->mutex,MY_MUTEX_INIT_FAST));
+    pthread_mutex_init(&share->mutex,MY_MUTEX_INIT_FAST);
     
     /*
       We read the meta file, but do not mark it dirty. Since we are not
@@ -362,7 +362,7 @@ ARCHIVE_SHARE *ha_archive::get_share(con
     share->crashed= archive_tmp.dirty;
     azclose(&archive_tmp);
 
-    VOID(my_hash_insert(&archive_open_tables, (uchar*) share));
+    (void) my_hash_insert(&archive_open_tables, (uchar*) share);
     thr_lock_init(&share->lock);
   }
   share->use_count++;
@@ -395,7 +395,7 @@ int ha_archive::free_share()
   {
     hash_delete(&archive_open_tables, (uchar*) share);
     thr_lock_delete(&share->lock);
-    VOID(pthread_mutex_destroy(&share->mutex));
+    pthread_mutex_destroy(&share->mutex);
     /* 
       We need to make sure we don't reset the crashed state.
       If we open a crashed file, wee need to close it as crashed unless
@@ -1468,7 +1468,7 @@ int ha_archive::info(uint flag)
   {
     MY_STAT file_stat;  // Stat information for the data file
 
-    VOID(my_stat(share->data_file_name, &file_stat, MYF(MY_WME)));
+    (void) my_stat(share->data_file_name, &file_stat, MYF(MY_WME));
 
     stats.mean_rec_length= table->s->reclength + buffer.alloced_length();
     stats.data_file_length= file_stat.st_size;
diff -Nrup a/storage/blackhole/ha_blackhole.cc b/storage/blackhole/ha_blackhole.cc
--- a/storage/blackhole/ha_blackhole.cc	2008-03-29 13:24:00 +01:00
+++ b/storage/blackhole/ha_blackhole.cc	2008-04-08 12:29:36 +02:00
@@ -303,7 +303,7 @@ static int blackhole_init(void *p)
   blackhole_hton->create= blackhole_create_handler;
   blackhole_hton->flags= HTON_CAN_RECREATE;
   
-  VOID(pthread_mutex_init(&blackhole_mutex, MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&blackhole_mutex, MY_MUTEX_INIT_FAST);
   (void) hash_init(&blackhole_open_tables, system_charset_info,32,0,0,
                    (hash_get_key) blackhole_get_key,
                    (hash_free_key) blackhole_free_key, 0);
diff -Nrup a/storage/csv/ha_tina.cc b/storage/csv/ha_tina.cc
--- a/storage/csv/ha_tina.cc	2008-03-29 16:56:12 +01:00
+++ b/storage/csv/ha_tina.cc	2008-04-08 12:29:37 +02:00
@@ -109,7 +109,7 @@ static int tina_init_func(void *p)
   handlerton *tina_hton;
 
   tina_hton= (handlerton *)p;
-  VOID(pthread_mutex_init(&tina_mutex,MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&tina_mutex,MY_MUTEX_INIT_FAST);
   (void) hash_init(&tina_open_tables,system_charset_info,32,0,0,
                    (hash_get_key) tina_get_key,0,0);
   tina_hton->state= SHOW_OPTION_YES;
@@ -240,7 +240,7 @@ static int read_meta_file(File meta_file
 
   DBUG_ENTER("ha_tina::read_meta_file");
 
-  VOID(my_seek(meta_file, 0, MY_SEEK_SET, MYF(0)));
+  my_seek(meta_file, 0, MY_SEEK_SET, MYF(0));
   if (my_read(meta_file, (uchar*)meta_buffer, META_BUFFER_SIZE, 0)
       != META_BUFFER_SIZE)
     DBUG_RETURN(HA_ERR_CRASHED_ON_USAGE);
@@ -309,7 +309,7 @@ static int write_meta_file(File meta_fil
   ptr+= 3*sizeof(ulonglong);
   *ptr= (uchar)dirty;
 
-  VOID(my_seek(meta_file, 0, MY_SEEK_SET, MYF(0)));
+  my_seek(meta_file, 0, MY_SEEK_SET, MYF(0));
   if (my_write(meta_file, (uchar *)meta_buffer, META_BUFFER_SIZE, 0)
       != META_BUFFER_SIZE)
     DBUG_RETURN(-1);
diff -Nrup a/storage/csv/transparent_file.cc b/storage/csv/transparent_file.cc
--- a/storage/csv/transparent_file.cc	2007-05-10 11:59:31 +02:00
+++ b/storage/csv/transparent_file.cc	2008-04-08 12:29:37 +02:00
@@ -35,7 +35,7 @@ void Transparent_file::init_buff(File fi
   filedes= filedes_arg;
   /* read the beginning of the file */
   lower_bound= 0;
-  VOID(my_seek(filedes, 0, MY_SEEK_SET, MYF(0)));
+  my_seek(filedes, 0, MY_SEEK_SET, MYF(0));
   if (filedes && buff)
     upper_bound= my_read(filedes, buff, buff_size, MYF(0));
 }
@@ -85,7 +85,7 @@ char Transparent_file::get_value(off_t o
   if ((lower_bound <= offset) && (offset < upper_bound))
     return buff[offset - lower_bound];
 
-  VOID(my_seek(filedes, offset, MY_SEEK_SET, MYF(0)));
+  my_seek(filedes, offset, MY_SEEK_SET, MYF(0));
   /* read appropriate portion of the file */
   if ((bytes_read= my_read(filedes, buff, buff_size,
                            MYF(0))) == MY_FILE_ERROR)
diff -Nrup a/storage/example/ha_example.cc b/storage/example/ha_example.cc
--- a/storage/example/ha_example.cc	2008-02-24 14:12:15 +01:00
+++ b/storage/example/ha_example.cc	2008-04-08 12:29:38 +02:00
@@ -131,7 +131,7 @@ static int example_init_func(void *p)
   DBUG_ENTER("example_init_func");
 
   example_hton= (handlerton *)p;
-  VOID(pthread_mutex_init(&example_mutex,MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&example_mutex,MY_MUTEX_INIT_FAST);
   (void) hash_init(&example_open_tables,system_charset_info,32,0,0,
                    (hash_get_key) example_get_key,0,0);
 
diff -Nrup a/storage/federated/ha_federated.cc b/storage/federated/ha_federated.cc
--- a/storage/federated/ha_federated.cc	2008-03-29 08:59:27 +01:00
+++ b/storage/federated/ha_federated.cc	2008-04-08 12:29:38 +02:00
@@ -464,7 +464,7 @@ int federated_db_init(void *p)
     DBUG_RETURN(FALSE);
   }
 
-  VOID(pthread_mutex_destroy(&federated_mutex));
+  pthread_mutex_destroy(&federated_mutex);
 error:
   DBUG_RETURN(TRUE);
 }
@@ -483,7 +483,7 @@ error:
 int federated_done(void *p)
 {
   hash_free(&federated_open_tables);
-  VOID(pthread_mutex_destroy(&federated_mutex));
+  pthread_mutex_destroy(&federated_mutex);
 
   return 0;
 }
@@ -1558,7 +1558,7 @@ static int free_share(FEDERATED_SHARE *s
   {
     hash_delete(&federated_open_tables, (uchar*) share);
     thr_lock_delete(&share->lock);
-    VOID(pthread_mutex_destroy(&share->mutex));
+    pthread_mutex_destroy(&share->mutex);
     free_root(&mem_root, MYF(0));
   }
   pthread_mutex_unlock(&federated_mutex);
diff -Nrup a/storage/heap/hp_clear.c b/storage/heap/hp_clear.c
--- a/storage/heap/hp_clear.c	2007-05-10 11:59:31 +02:00
+++ b/storage/heap/hp_clear.c	2008-04-08 12:29:39 +02:00
@@ -31,8 +31,8 @@ void hp_clear(HP_SHARE *info)
   DBUG_ENTER("hp_clear");
 
   if (info->block.levels)
-    VOID(hp_free_level(&info->block,info->block.levels,info->block.root,
-			(uchar*) 0));
+    (void) hp_free_level(&info->block,info->block.levels,info->block.root,
+			(uchar*) 0);
   info->block.levels=0;
   hp_clear_keys(info);
   info->records= info->deleted= 0;
@@ -94,7 +94,7 @@ void hp_clear_keys(HP_SHARE *info)
     {
       HP_BLOCK *block= &keyinfo->block;
       if (block->levels)
-        VOID(hp_free_level(block,block->levels,block->root,(uchar*) 0));
+        (void) hp_free_level(block,block->levels,block->root,(uchar*) 0);
       block->levels=0;
       block->last_allocated=0;
       keyinfo->hash_buckets= 0;
diff -Nrup a/storage/heap/hp_create.c b/storage/heap/hp_create.c
--- a/storage/heap/hp_create.c	2007-07-25 00:58:06 +02:00
+++ b/storage/heap/hp_create.c	2008-04-08 12:29:39 +02:00
@@ -194,7 +194,7 @@ int heap_create(const char *name, uint k
     }
 #ifdef THREAD
     thr_lock_init(&share->lock);
-    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
+    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
 #endif
     if (!create_info->internal_table)
     {
@@ -298,7 +298,7 @@ void hp_free(HP_SHARE *share)
   hp_clear(share);			/* Remove blocks from memory */
 #ifdef THREAD
   thr_lock_delete(&share->lock);
-  VOID(pthread_mutex_destroy(&share->intern_lock));
+  pthread_mutex_destroy(&share->intern_lock);
 #endif
   my_free((uchar*) share->name, MYF(0));
   my_free((uchar*) share, MYF(0));
diff -Nrup a/storage/heap/hp_test1.c b/storage/heap/hp_test1.c
--- a/storage/heap/hp_test1.c	2007-08-13 15:11:15 +02:00
+++ b/storage/heap/hp_test1.c	2008-04-08 12:29:40 +02:00
@@ -91,7 +91,7 @@ int main(int argc, char **argv)
   printf("- Removing records\n");
   for (i=1 ; i<=10 ; i++)
   {
-    if (i == remove_ant) { VOID(heap_close(file)) ; return (0) ; }
+    if (i == remove_ant) { (void) heap_close(file); return (0) ; }
     sprintf((char*) key,"%6d",(j=(int) ((rand() & 32767)/32767.*25)));
     if ((error = heap_rkey(file,record,0,key,6,HA_READ_KEY_EXACT)))
     {
diff -Nrup a/storage/heap/hp_test2.c b/storage/heap/hp_test2.c
--- a/storage/heap/hp_test2.c	2008-03-29 08:59:35 +01:00
+++ b/storage/heap/hp_test2.c	2008-04-08 12:29:40 +02:00
@@ -610,7 +610,7 @@ end:
   return(0);
 err:
   printf("Got error: %d when using heap-database\n",my_errno);
-  VOID(heap_close(file));
+  (void) heap_close(file);
   return(1);
 } /* main */
 
diff -Nrup a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
--- a/storage/innobase/handler/ha_innodb.cc	2008-04-03 17:23:53 +02:00
+++ b/storage/innobase/handler/ha_innodb.cc	2008-04-08 12:29:41 +02:00
@@ -707,7 +707,7 @@ void
 innobase_mysql_prepare_print_arbitrary_thd(void)
 /*============================================*/
 {
-	VOID(pthread_mutex_lock(&LOCK_thread_count));
+	pthread_mutex_lock(&LOCK_thread_count);
 }
 
 /*****************************************************************
@@ -719,7 +719,7 @@ void
 innobase_mysql_end_print_arbitrary_thd(void)
 /*========================================*/
 {
-	VOID(pthread_mutex_unlock(&LOCK_thread_count));
+	pthread_mutex_unlock(&LOCK_thread_count);
 }
 
 /*****************************************************************
diff -Nrup a/storage/myisam/ft_eval.c b/storage/myisam/ft_eval.c
--- a/storage/myisam/ft_eval.c	2007-10-11 17:07:36 +02:00
+++ b/storage/myisam/ft_eval.c	2008-04-08 12:29:41 +02:00
@@ -236,8 +236,8 @@ static void print_error(int exit_code, c
 
   va_start(args,fmt);
   fprintf(stderr,"%s: error: ",my_progname);
-  VOID(vfprintf(stderr, fmt, args));
-  VOID(fputc('\n',stderr));
+  (void) vfprintf(stderr, fmt, args);
+  (void) fputc('\n',stderr);
   fflush(stderr);
   va_end(args);
   exit(exit_code);
diff -Nrup a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
--- a/storage/myisam/ha_myisam.cc	2008-03-28 11:03:06 +01:00
+++ b/storage/myisam/ha_myisam.cc	2008-04-08 12:29:42 +02:00
@@ -681,11 +681,11 @@ int ha_myisam::open(const char *name, in
   }
   
   if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
-    VOID(mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0));
+    (void) mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0);
 
   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
   if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
-    VOID(mi_extra(file, HA_EXTRA_WAIT_LOCK, 0));
+    (void) mi_extra(file, HA_EXTRA_WAIT_LOCK, 0);
   if (!table->s->db_record_offset)
     int_table_flags|=HA_REC_NOT_IN_SEQ;
   if (file->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
@@ -876,8 +876,8 @@ int ha_myisam::restore(THD* thd, HA_CHEC
   const char* errmsg;
   DBUG_ENTER("restore");
 
-  VOID(tablename_to_filename(table->s->table_name.str, table_name,
-                             sizeof(table_name)));
+  (void) tablename_to_filename(table->s->table_name.str, table_name,
+                             sizeof(table_name));
 
   if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
 				      MI_NAME_DEXT))
@@ -919,8 +919,8 @@ int ha_myisam::backup(THD* thd, HA_CHECK
   const char *errmsg;
   DBUG_ENTER("ha_myisam::backup");
 
-  VOID(tablename_to_filename(table->s->table_name.str, table_name,
-                             sizeof(table_name)));
+  (void) tablename_to_filename(table->s->table_name.str, table_name,
+                             sizeof(table_name));
 
   if (fn_format_relative_to_data_home(dst_path, table_name, backup_dir,
 				      reg_ext))
diff -Nrup a/storage/myisam/mi_changed.c b/storage/myisam/mi_changed.c
--- a/storage/myisam/mi_changed.c	2006-12-31 01:06:39 +01:00
+++ b/storage/myisam/mi_changed.c	2008-04-08 12:29:42 +02:00
@@ -25,7 +25,7 @@ int mi_is_changed(MI_INFO *info)
   DBUG_ENTER("mi_is_changed");
   if (fast_mi_readinfo(info))
     DBUG_RETURN(-1);
-  VOID(_mi_writeinfo(info,0));
+  (void) _mi_writeinfo(info,0);
   result=(int) info->data_changed;
   info->data_changed=0;
   DBUG_PRINT("exit",("result: %d",result));
diff -Nrup a/storage/myisam/mi_check.c b/storage/myisam/mi_check.c
--- a/storage/myisam/mi_check.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_check.c	2008-04-08 12:29:42 +02:00
@@ -1183,8 +1183,8 @@ int chk_data_link(MI_CHECK *param, MI_IN
 	goto err;
       start_recpos=pos;
       splits++;
-      VOID(_mi_pack_get_block_info(info, &info->bit_buff, &block_info,
-                                   &info->rec_buff, -1, start_recpos));
+      (void) _mi_pack_get_block_info(info, &info->bit_buff, &block_info,
+                                   &info->rec_buff, -1, start_recpos);
       pos=block_info.filepos+block_info.rec_len;
       if (block_info.rec_len < (uint) info->s->min_pack_length ||
 	  block_info.rec_len > (uint) info->s->max_pack_length)
@@ -1220,7 +1220,7 @@ int chk_data_link(MI_CHECK *param, MI_IN
       records++;
       if (param->testflag & T_WRITE_LOOP && records % WRITE_COUNT == 0)
       {
-	printf("%s\r", llstr(records,llbuff)); VOID(fflush(stdout));
+	printf("%s\r", llstr(records,llbuff)); (void) fflush(stdout);
       }
 
       /* Check if keys match the record */
@@ -1273,7 +1273,7 @@ int chk_data_link(MI_CHECK *param, MI_IN
   }
   if (param->testflag & T_WRITE_LOOP)
   {
-    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
+    (void) fputs("          \r",stdout); (void) fflush(stdout);
   }
   if (records != info->state->records)
   {
@@ -1547,8 +1547,8 @@ int mi_repair(MI_CHECK *param, register 
     param->testflag|=T_CALC_CHECKSUM;
 
   if (!param->using_global_keycache)
-    VOID(init_key_cache(dflt_key_cache, param->key_cache_block_size,
-                        param->use_buffers, 0, 0));
+    (void) init_key_cache(dflt_key_cache, param->key_cache_block_size,
+                        param->use_buffers, 0, 0);
 
   if (init_io_cache(&param->read_cache,info->dfile,
 		    (uint) param->read_buffer_length,
@@ -1641,8 +1641,8 @@ int mi_repair(MI_CHECK *param, register 
 			  llstr(info->dupp_key_pos,llbuff2));
       if (param->testflag & T_VERBOSE)
       {
-	VOID(_mi_make_key(info,(uint) info->errkey,info->lastkey,
-			  sort_param.record,0L));
+	(void) _mi_make_key(info,(uint) info->errkey,info->lastkey,
+			  sort_param.record,0L);
 	_mi_print_key(stdout,share->keyinfo[info->errkey].seg,info->lastkey,
 		      USE_WHOLE_KEY);
       }
@@ -1664,7 +1664,7 @@ int mi_repair(MI_CHECK *param, register 
 
   if (param->testflag & T_WRITE_LOOP)
   {
-    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
+    (void) fputs("          \r",stdout); (void) fflush(stdout);
   }
   if (my_chsize(share->kfile,info->state->key_file_length,0,MYF(0)))
   {
@@ -1746,9 +1746,9 @@ err:
 		  llstr(sort_param.start_recpos,llbuff));
     if (new_file >= 0)
     {
-      VOID(my_close(new_file,MYF(0)));
-      VOID(my_raid_delete(param->temp_filename,info->s->base.raid_chunks,
-			  MYF(MY_WME)));
+      (void) my_close(new_file,MYF(0));
+      (void) my_raid_delete(param->temp_filename,info->s->base.raid_chunks,
+			  MYF(MY_WME));
       info->rec_cache.file=-1; /* don't flush data to new_file, it's closed */
     }
     mi_mark_crashed_on_repair(info);
@@ -1758,9 +1758,9 @@ err:
   my_free(mi_get_rec_buff_ptr(info, sort_param.record),
           MYF(MY_ALLOW_ZERO_PTR));
   my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
-  VOID(end_io_cache(&param->read_cache));
+  (void) end_io_cache(&param->read_cache);
   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
-  VOID(end_io_cache(&info->rec_cache));
+  (void) end_io_cache(&info->rec_cache);
   got_error|=flush_blocks(param, share->key_cache, share->kfile);
   if (!got_error && param->testflag & T_UNPACK)
   {
@@ -1987,9 +1987,9 @@ int mi_sort_index(MI_CHECK *param, regis
 	/* Put same locks as old file */
   share->r_locks= share->w_locks= share->tot_locks= 0;
   (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
-  VOID(my_close(share->kfile,MYF(MY_WME)));
+  (void) my_close(share->kfile,MYF(MY_WME));
   share->kfile = -1;
-  VOID(my_close(new_file,MYF(MY_WME)));
+  (void) my_close(new_file,MYF(MY_WME));
   if (change_to_newfile(share->index_file_name,MI_NAME_IEXT,INDEX_TMP_EXT,0,
 			MYF(0)) ||
       mi_open_keyfile(share))
@@ -2013,9 +2013,9 @@ int mi_sort_index(MI_CHECK *param, regis
   DBUG_RETURN(0);
 
 err:
-  VOID(my_close(new_file,MYF(MY_WME)));
+  (void) my_close(new_file,MYF(MY_WME));
 err2:
-  VOID(my_delete(param->temp_filename,MYF(MY_WME)));
+  (void) my_delete(param->temp_filename,MYF(MY_WME));
   DBUG_RETURN(-1);
 } /* mi_sort_index */
 
@@ -2172,7 +2172,7 @@ int filecopy(MI_CHECK *param, File to,Fi
     buff=tmp_buff; buff_length=IO_SIZE;
   }
 
-  VOID(my_seek(from,start,MY_SEEK_SET,MYF(0)));
+  my_seek(from,start,MY_SEEK_SET,MYF(0));
   while (length > buff_length)
   {
     if (my_read(from,(uchar*) buff,buff_length,MYF(MY_NABP)) ||
@@ -2483,7 +2483,7 @@ int mi_repair_by_sort(MI_CHECK *param, r
 
   if (param->testflag & T_WRITE_LOOP)
   {
-    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
+    (void) fputs("          \r",stdout); (void) fflush(stdout);
   }
 
   if (rep_quick && del+sort_info.dupp != info->state->del)
@@ -2536,7 +2536,7 @@ int mi_repair_by_sort(MI_CHECK *param, r
 
 err:
   got_error|= flush_blocks(param, share->key_cache, share->kfile);
-  VOID(end_io_cache(&info->rec_cache));
+  (void) end_io_cache(&info->rec_cache);
   if (!got_error)
   {
     /* Replace the actual file with the temporary file */
@@ -2558,9 +2558,9 @@ err:
       mi_check_print_error(param,"%d when fixing table",my_errno);
     if (new_file >= 0)
     {
-      VOID(my_close(new_file,MYF(0)));
-      VOID(my_raid_delete(param->temp_filename,share->base.raid_chunks,
-			  MYF(MY_WME)));
+      (void) my_close(new_file,MYF(0));
+      (void) my_raid_delete(param->temp_filename,share->base.raid_chunks,
+			  MYF(MY_WME));
       if (info->dfile == new_file)
 	info->dfile= -1;
     }
@@ -2577,7 +2577,7 @@ err:
   my_free((uchar*) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));
   my_free((uchar*) sort_info.ft_buf, MYF(MY_ALLOW_ZERO_PTR));
   my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
-  VOID(end_io_cache(&param->read_cache));
+  (void) end_io_cache(&param->read_cache);
   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
   if (!got_error && (param->testflag & T_UNPACK))
   {
@@ -3060,7 +3060,7 @@ err:
     the share by remove_io_thread() or it was not yet started (if the
     error happend before creating the thread).
   */
-  VOID(end_io_cache(&info->rec_cache));
+  (void) end_io_cache(&info->rec_cache);
   /*
     Destroy the new data cache in case of non-quick repair. All slave
     threads did either detach from the share by remove_io_thread()
@@ -3068,7 +3068,7 @@ err:
     creating the threads).
   */
   if (!rep_quick)
-    VOID(end_io_cache(&new_data_cache));
+    (void) end_io_cache(&new_data_cache);
   if (!got_error)
   {
     /* Replace the actual file with the temporary file */
@@ -3090,9 +3090,9 @@ err:
       mi_check_print_error(param,"%d when fixing table",my_errno);
     if (new_file >= 0)
     {
-      VOID(my_close(new_file,MYF(0)));
-      VOID(my_raid_delete(param->temp_filename,share->base.raid_chunks,
-			  MYF(MY_WME)));
+      (void) my_close(new_file,MYF(0));
+      (void) my_raid_delete(param->temp_filename,share->base.raid_chunks,
+			  MYF(MY_WME));
       if (info->dfile == new_file)
 	info->dfile= -1;
     }
@@ -3109,7 +3109,7 @@ err:
   my_free((uchar*) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));
   my_free((uchar*) sort_param,MYF(MY_ALLOW_ZERO_PTR));
   my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
-  VOID(end_io_cache(&param->read_cache));
+  (void) end_io_cache(&param->read_cache);
   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
   if (!got_error && (param->testflag & T_UNPACK))
   {
@@ -3763,7 +3763,7 @@ int sort_write_record(MI_SORT_PARAM *sor
     {
       char llbuff[22];
       printf("%s\r", llstr(info->state->records,llbuff));
-      VOID(fflush(stdout));
+      (void) fflush(stdout);
     }
   }
   DBUG_RETURN(0);
@@ -4037,7 +4037,7 @@ static int sort_insert_key(MI_SORT_PARAM
   key_block->end_pos+=t_length;
   if (a_length <= keyinfo->block_length)
   {
-    VOID(_mi_move_key(keyinfo,key_block->lastkey,key));
+    (void) _mi_move_key(keyinfo,key_block->lastkey,key);
     key_block->last_length=a_length-t_length;
     DBUG_RETURN(0);
   }
@@ -4316,7 +4316,7 @@ int recreate_table(MI_CHECK *param, MI_I
   set_if_bigger(file_length,tmp_length);
   set_if_bigger(file_length,(ulonglong) share.base.max_data_file_length);
 
-  VOID(mi_close(*org_info));
+  (void) mi_close(*org_info);
   bzero((char*) &create_info,sizeof(create_info));
   create_info.max_rows=max(max_records,share.base.records);
   create_info.reloc_rows=share.base.reloc;
@@ -4357,7 +4357,7 @@ int recreate_table(MI_CHECK *param, MI_I
   }
   /* We are modifing */
   (*org_info)->s->options&= ~HA_OPTION_READ_ONLY_DATA;
-  VOID(_mi_readinfo(*org_info,F_WRLCK,0));
+  (void) _mi_readinfo(*org_info,F_WRLCK,0);
   (*org_info)->state->records=info.state->records;
   if (share.state.create_time)
     (*org_info)->s->state.create_time=share.state.create_time;
diff -Nrup a/storage/myisam/mi_close.c b/storage/myisam/mi_close.c
--- a/storage/myisam/mi_close.c	2007-05-10 11:59:32 +02:00
+++ b/storage/myisam/mi_close.c	2008-04-08 12:29:43 +02:00
@@ -92,13 +92,13 @@ int mi_close(register MI_INFO *info)
     }
 #ifdef THREAD
     thr_lock_delete(&share->lock);
-    VOID(pthread_mutex_destroy(&share->intern_lock));
+    pthread_mutex_destroy(&share->intern_lock);
     {
       int i,keys;
       keys = share->state.header.keys;
-      VOID(rwlock_destroy(&share->mmap_lock));
+      (void) rwlock_destroy(&share->mmap_lock);
       for(i=0; i<keys; i++) {
-	VOID(rwlock_destroy(&share->key_root_lock[i]));
+	(void) rwlock_destroy(&share->key_root_lock[i]);
       }
     }
 #endif
diff -Nrup a/storage/myisam/mi_create.c b/storage/myisam/mi_create.c
--- a/storage/myisam/mi_create.c	2007-10-11 17:07:36 +02:00
+++ b/storage/myisam/mi_create.c	2008-04-08 12:29:43 +02:00
@@ -837,17 +837,17 @@ err:
   save_errno=my_errno;
   switch (errpos) {
   case 3:
-    VOID(my_close(dfile,MYF(0)));
+    (void) my_close(dfile,MYF(0));
     /* fall through */
   case 2:
+    /* QQ: Tnu should add a call to my_raid_delete() here */
   if (! (flags & HA_DONT_TOUCH_DATA))
     my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_DEXT,
                                      MY_UNPACK_FILENAME | MY_APPEND_EXT),
 			   MYF(0));
     /* fall through */
   case 1:
-    VOID(my_close(file,MYF(0)));
+    (void) my_close(file,MYF(0));
     if (! (flags & HA_DONT_TOUCH_DATA))
       my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_IEXT,
                                        MY_UNPACK_FILENAME | MY_APPEND_EXT),
diff -Nrup a/storage/myisam/mi_dbug.c b/storage/myisam/mi_dbug.c
--- a/storage/myisam/mi_dbug.c	2006-12-31 01:06:39 +01:00
+++ b/storage/myisam/mi_dbug.c	2008-04-08 12:29:44 +02:00
@@ -30,12 +30,12 @@ void _mi_print_key(FILE *stream, registe
   const uchar *end;
   const uchar *key_end=key+length;
 
-  VOID(fputs("Key: \"",stream));
+  (void) fputs("Key: \"",stream);
   flag=0;
   for (; keyseg->type && key < key_end ;keyseg++)
   {
     if (flag++)
-      VOID(putc('-',stream));
+      (void) putc('-',stream);
     end= key+ keyseg->length;
     if (keyseg->flag & HA_NULL_PART)
     {
@@ -51,7 +51,7 @@ void _mi_print_key(FILE *stream, registe
     case HA_KEYTYPE_BINARY:
       if (!(keyseg->flag & HA_SPACE_PACK) && keyseg->length == 1)
       {						/* packed binary digit */
-	VOID(fprintf(stream,"%d",(uint) *key++));
+	(void) fprintf(stream,"%d",(uint) *key++);
 	break;
       }
       /* fall through */
@@ -59,58 +59,58 @@ void _mi_print_key(FILE *stream, registe
     case HA_KEYTYPE_NUM:
       if (keyseg->flag & HA_SPACE_PACK)
       {
-	VOID(fprintf(stream,"%.*s",(int) *key,key+1));
+	(void) fprintf(stream,"%.*s",(int) *key,key+1);
 	key+= (int) *key+1;
       }
       else
       {
-	VOID(fprintf(stream,"%.*s",(int) keyseg->length,key));
+	(void) fprintf(stream,"%.*s",(int) keyseg->length,key);
 	key=end;
       }
       break;
     case HA_KEYTYPE_INT8:
-      VOID(fprintf(stream,"%d",(int) *((signed char*) key)));
+      (void) fprintf(stream,"%d",(int) *((signed char*) key));
       key=end;
       break;
     case HA_KEYTYPE_SHORT_INT:
       s_1= mi_sint2korr(key);
-      VOID(fprintf(stream,"%d",(int) s_1));
+      (void) fprintf(stream,"%d",(int) s_1);
       key=end;
       break;
     case HA_KEYTYPE_USHORT_INT:
       {
 	ushort u_1;
 	u_1= mi_uint2korr(key);
-	VOID(fprintf(stream,"%u",(uint) u_1));
+	(void) fprintf(stream,"%u",(uint) u_1);
 	key=end;
 	break;
       }
     case HA_KEYTYPE_LONG_INT:
       l_1=mi_sint4korr(key);
-      VOID(fprintf(stream,"%ld",l_1));
+      (void) fprintf(stream,"%ld",l_1);
       key=end;
       break;
     case HA_KEYTYPE_ULONG_INT:
       l_1=mi_sint4korr(key);
-      VOID(fprintf(stream,"%lu",(ulong) l_1));
+      (void) fprintf(stream,"%lu",(ulong) l_1);
       key=end;
       break;
     case HA_KEYTYPE_INT24:
-      VOID(fprintf(stream,"%ld",(long) mi_sint3korr(key)));
+      (void) fprintf(stream,"%ld",(long) mi_sint3korr(key));
       key=end;
       break;
     case HA_KEYTYPE_UINT24:
-      VOID(fprintf(stream,"%lu",(ulong) mi_uint3korr(key)));
+      (void) fprintf(stream,"%lu",(ulong) mi_uint3korr(key));
       key=end;
       break;
     case HA_KEYTYPE_FLOAT:
       mi_float4get(f_1,key);
-      VOID(fprintf(stream,"%g",(double) f_1));
+      (void) fprintf(stream,"%g",(double) f_1);
       key=end;
       break;
     case HA_KEYTYPE_DOUBLE:
       mi_float8get(d_1,key);
-      VOID(fprintf(stream,"%g",d_1));
+      (void) fprintf(stream,"%g",d_1);
       key=end;
       break;
 #ifdef HAVE_LONG_LONG
@@ -118,7 +118,7 @@ void _mi_print_key(FILE *stream, registe
     {
       char buff[21];
       longlong2str(mi_sint8korr(key),buff,-10);
-      VOID(fprintf(stream,"%s",buff));
+      (void) fprintf(stream,"%s",buff);
       key=end;
       break;
     }
@@ -126,7 +126,7 @@ void _mi_print_key(FILE *stream, registe
     {
       char buff[21];
       longlong2str(mi_sint8korr(key),buff,10);
-      VOID(fprintf(stream,"%s",buff));
+      (void) fprintf(stream,"%s",buff);
       key=end;
       break;
     }
@@ -152,14 +152,14 @@ void _mi_print_key(FILE *stream, registe
 	The following command sometimes gives a warning from valgrind.
 	Not yet sure if the bug is in valgrind, glibc or mysqld
       */
-      VOID(fprintf(stream,"%.*s",(int) tmp_length,key));
+      (void) fprintf(stream,"%.*s",(int) tmp_length,key);
       key+=tmp_length;
       break;
     }
     default: break;			/* This never happens */
     }
   }
-  VOID(fputs("\"\n",stream));
+  (void) fputs("\"\n",stream);
   return;
 } /* print_key */
 
diff -Nrup a/storage/myisam/mi_delete.c b/storage/myisam/mi_delete.c
--- a/storage/myisam/mi_delete.c	2008-03-29 09:00:49 +01:00
+++ b/storage/myisam/mi_delete.c	2008-04-08 12:29:44 +02:00
@@ -101,7 +101,7 @@ int mi_delete(MI_INFO *info,const uchar 
 
   mi_sizestore(lastpos,info->lastpos);
   myisam_log_command(MI_LOG_DELETE,info,(uchar*) lastpos,sizeof(lastpos),0);
-  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
   allow_break();			/* Allow SIGHUP & SIGINT */
   if (info->invalidator != 0)
   {
@@ -120,7 +120,7 @@ err:
     mi_print_error(info->s, HA_ERR_CRASHED);
     mi_mark_crashed(info);		/* mark table crashed */
   }
-  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
   info->update|=HA_STATE_WRITTEN;	/* Buffer changed */
   allow_break();			/* Allow SIGHUP & SIGINT */
   my_errno=save_errno;
diff -Nrup a/storage/myisam/mi_delete_all.c b/storage/myisam/mi_delete_all.c
--- a/storage/myisam/mi_delete_all.c	2008-03-28 16:16:49 +01:00
+++ b/storage/myisam/mi_delete_all.c	2008-04-08 12:29:45 +02:00
@@ -60,7 +60,7 @@ int mi_delete_all_rows(MI_INFO *info)
   if (my_chsize(info->dfile, 0, 0, MYF(MY_WME)) ||
       my_chsize(share->kfile, share->base.keystart, 0, MYF(MY_WME))  )
     goto err;
-  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
 #ifdef HAVE_MMAP
   /* Map again */
   if (share->file_map)
@@ -72,7 +72,7 @@ int mi_delete_all_rows(MI_INFO *info)
 err:
   {
     int save_errno=my_errno;
-    VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+    (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
     info->update|=HA_STATE_WRITTEN;	/* Buffer changed */
     allow_break();			/* Allow SIGHUP & SIGINT */
     DBUG_RETURN(my_errno=save_errno);
diff -Nrup a/storage/myisam/mi_dynrec.c b/storage/myisam/mi_dynrec.c
--- a/storage/myisam/mi_dynrec.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_dynrec.c	2008-04-08 12:29:45 +02:00
@@ -112,8 +112,8 @@ void mi_remap_file(MI_INFO *info, my_off
 {
   if (info->s->file_map)
   {
-    VOID(my_munmap((char*) info->s->file_map,
-                   (size_t) info->s->mmaped_length + MEMMAP_EXTRA_MARGIN));
+    (void) my_munmap((char*) info->s->file_map,
+                   (size_t) info->s->mmaped_length + MEMMAP_EXTRA_MARGIN);
     mi_dynmap_file(info, size);
   }
 }
@@ -1514,7 +1514,7 @@ int _mi_read_dynamic_record(MI_INFO *inf
 panic:
   my_errno=HA_ERR_WRONG_IN_RECORD;
 err:
-  VOID(_mi_writeinfo(info,0));
+  (void) _mi_writeinfo(info,0);
   DBUG_RETURN(-1);
 }
 
@@ -1831,7 +1831,7 @@ int _mi_read_rnd_dynamic_record(MI_INFO 
             block_info.filepos + block_info.data_len &&
             flush_io_cache(&info->rec_cache))
           goto err;
-	/* VOID(my_seek(info->dfile,filepos,MY_SEEK_SET,MYF(0))); */
+	/* my_seek(info->dfile,filepos,MY_SEEK_SET,MYF(0)); */
 	if (my_read(info->dfile,(uchar*) to,block_info.data_len,MYF(MY_NABP)))
 	{
 	  if (my_errno == -1)
@@ -1865,7 +1865,7 @@ panic:
   my_errno=HA_ERR_WRONG_IN_RECORD;		/* Something is fatal wrong */
 err:
   save_errno=my_errno;
-  VOID(_mi_writeinfo(info,0));
+  (void) _mi_writeinfo(info,0);
   DBUG_RETURN(my_errno=save_errno);
 }
 
@@ -1884,7 +1884,7 @@ uint _mi_get_block_info(MI_BLOCK_INFO *i
       pointer set to the end of the header after this function.
       my_pread() may leave the file pointer untouched.
     */
-    VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
+    my_seek(file,filepos,MY_SEEK_SET,MYF(0));
     if (my_read(file, header, sizeof(info->header),MYF(0)) !=
 	sizeof(info->header))
       goto err;
diff -Nrup a/storage/myisam/mi_info.c b/storage/myisam/mi_info.c
--- a/storage/myisam/mi_info.c	2007-04-13 09:43:59 +02:00
+++ b/storage/myisam/mi_info.c	2008-04-08 12:29:46 +02:00
@@ -43,7 +43,7 @@ int mi_status(MI_INFO *info, register MI
   if (!(flag & HA_STATUS_NO_LOCK))
   {
     pthread_mutex_lock(&share->intern_lock);
-    VOID(_mi_readinfo(info,F_RDLCK,0));
+    (void) _mi_readinfo(info,F_RDLCK,0);
     fast_mi_writeinfo(info);
     pthread_mutex_unlock(&share->intern_lock);
   }
diff -Nrup a/storage/myisam/mi_locking.c b/storage/myisam/mi_locking.c
--- a/storage/myisam/mi_locking.c	2007-08-13 15:11:16 +02:00
+++ b/storage/myisam/mi_locking.c	2008-04-08 12:29:46 +02:00
@@ -173,12 +173,12 @@ int mi_lock_database(MI_INFO *info, int 
 	if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
 	{
 	  error=my_errno;
-	  VOID(my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE)));
+	  (void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
 	  my_errno=error;
 	  break;
 	}
       }
-      VOID(_mi_test_if_changed(info));
+      (void) _mi_test_if_changed(info);
       share->r_locks++;
       share->tot_locks++;
       info->lock_type=lock_type;
@@ -217,15 +217,15 @@ int mi_lock_database(MI_INFO *info, int 
 	    if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
 	    {
 	      error=my_errno;
-	      VOID(my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
-			   info->lock_wait | MY_SEEK_NOT_DONE));
+	      (void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
+			   info->lock_wait | MY_SEEK_NOT_DONE);
 	      my_errno=error;
 	      break;
 	    }
 	  }
 	}
       }
-      VOID(_mi_test_if_changed(info));
+      (void) _mi_test_if_changed(info);
         
       info->lock_type=lock_type;
       info->invalidator=info->s->invalidator;
@@ -410,14 +410,14 @@ int _mi_readinfo(register MI_INFO *info,
       if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
       {
 	int error=my_errno ? my_errno : -1;
-	VOID(my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
-		     MYF(MY_SEEK_NOT_DONE)));
+	(void) my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
+		     MYF(MY_SEEK_NOT_DONE));
 	my_errno=error;
 	DBUG_RETURN(1);
       }
     }
     if (check_keybuffer)
-      VOID(_mi_test_if_changed(info));
+      (void) _mi_test_if_changed(info);
     info->invalidator=info->s->invalidator;
   }
   else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
@@ -485,7 +485,7 @@ int _mi_test_if_changed(register MI_INFO
   {						/* Keyfile has changed */
     DBUG_PRINT("info",("index file changed"));
     if (share->state.process != share->this_process)
-      VOID(flush_key_blocks(share->key_cache, share->kfile, FLUSH_RELEASE));
+      (void) flush_key_blocks(share->key_cache, share->kfile, FLUSH_RELEASE);
     share->last_process=share->state.process;
     info->last_unique=	share->state.unique;
     info->last_loop=	share->state.update_count;
diff -Nrup a/storage/myisam/mi_log.c b/storage/myisam/mi_log.c
--- a/storage/myisam/mi_log.c	2007-08-13 15:11:16 +02:00
+++ b/storage/myisam/mi_log.c	2008-04-08 12:29:46 +02:00
@@ -88,8 +88,8 @@ void _myisam_log(enum myisam_log_command
 
   pthread_mutex_lock(&THR_LOCK_myisam);
   error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
-  VOID(my_write(myisam_log_file,buff,sizeof(buff),MYF(0)));
-  VOID(my_write(myisam_log_file,buffert,length,MYF(0)));
+  (void) my_write(myisam_log_file,buff,sizeof(buff),MYF(0));
+  (void) my_write(myisam_log_file,buffert,length,MYF(0));
   if (!error)
     error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
   pthread_mutex_unlock(&THR_LOCK_myisam);
@@ -111,9 +111,9 @@ void _myisam_log_command(enum myisam_log
   mi_int2store(buff+7,result);
   pthread_mutex_lock(&THR_LOCK_myisam);
   error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
-  VOID(my_write(myisam_log_file,buff,sizeof(buff),MYF(0)));
+  (void) my_write(myisam_log_file,buff,sizeof(buff),MYF(0));
   if (buffert)
-    VOID(my_write(myisam_log_file,buffert,length,MYF(0)));
+    (void) my_write(myisam_log_file,buffert,length,MYF(0));
   if (!error)
     error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
   pthread_mutex_unlock(&THR_LOCK_myisam);
@@ -142,8 +142,8 @@ void _myisam_log_record(enum myisam_log_
   mi_int4store(buff+17,length);
   pthread_mutex_lock(&THR_LOCK_myisam);
   error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
-  VOID(my_write(myisam_log_file, buff,sizeof(buff),MYF(0)));
-  VOID(my_write(myisam_log_file, record,info->s->base.reclength,MYF(0)));
+  (void) my_write(myisam_log_file, buff,sizeof(buff),MYF(0));
+  (void) my_write(myisam_log_file, record,info->s->base.reclength,MYF(0));
   if (info->s->base.blobs)
   {
     MI_BLOB *blob,*end;
@@ -154,7 +154,7 @@ void _myisam_log_record(enum myisam_log_
     {
       memcpy_fixed((uchar*) &pos, record+blob->offset+blob->pack_length,
                    sizeof(char*));
-      VOID(my_write(myisam_log_file,pos,blob->length,MYF(0)));
+      (void) my_write(myisam_log_file,pos,blob->length,MYF(0));
     }
   }
   if (!error)
diff -Nrup a/storage/myisam/mi_open.c b/storage/myisam/mi_open.c
--- a/storage/myisam/mi_open.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_open.c	2008-04-08 12:29:47 +02:00
@@ -174,7 +174,7 @@ MI_INFO *mi_open(const char *name, int m
     end_pos=disk_cache+info_length;
     errpos=2;
 
-    VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
+    my_seek(kfile,0L,MY_SEEK_SET,MYF(0));
     if (!(open_flags & HA_OPEN_TMP_TABLE))
     {
       if ((lock_error=my_lock(kfile,F_RDLCK,0L,F_TO_EOF,
@@ -472,7 +472,7 @@ MI_INFO *mi_open(const char *name, int m
 
     if (! lock_error)
     {
-      VOID(my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE)));
+      (void) my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
       lock_error=1;			/* Database unlocked */
     }
 
@@ -512,10 +512,10 @@ MI_INFO *mi_open(const char *name, int m
     share->is_log_table= FALSE;
 #ifdef THREAD
     thr_lock_init(&share->lock);
-    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
+    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
     for (i=0; i<keys; i++)
-      VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
-    VOID(my_rwlock_init(&share->mmap_lock, NULL));
+      (void) my_rwlock_init(&share->key_root_lock[i], NULL);
+    (void) my_rwlock_init(&share->mmap_lock, NULL);
     if (!thr_lock_inited)
     {
       /* Probably a single threaded program; Don't use concurrent inserts */
@@ -660,7 +660,7 @@ err:
     my_free((uchar*) m_info,MYF(0));
     /* fall through */
   case 5:
-    VOID(my_close(info.dfile,MYF(0)));
+    (void) my_close(info.dfile,MYF(0));
     if (old_info)
       break;					/* Don't remove open table */
     /* fall through */
@@ -669,13 +669,13 @@ err:
     /* fall through */
   case 3:
     if (! lock_error)
-      VOID(my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE)));
+      (void) my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE));
     /* fall through */
   case 2:
     my_afree(disk_cache);
     /* fall through */
   case 1:
-    VOID(my_close(kfile,MYF(0)));
+    (void) my_close(kfile,MYF(0));
     /* fall through */
   case 0:
   default:
diff -Nrup a/storage/myisam/mi_packrec.c b/storage/myisam/mi_packrec.c
--- a/storage/myisam/mi_packrec.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_packrec.c	2008-04-08 12:29:47 +02:00
@@ -1366,7 +1366,7 @@ uint _mi_pack_get_block_info(MI_INFO *my
       We can't use my_pread() here because mi_read_rnd_pack_record assumes
       position is ok
     */
-    VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
+    my_seek(file,filepos,MY_SEEK_SET,MYF(0));
     if (my_read(file, header,ref_length,MYF(MY_NABP)))
       return BLOCK_FATAL_ERROR;
     DBUG_DUMP("header",(uchar*) header,ref_length);
@@ -1506,8 +1506,8 @@ my_bool _mi_memmap_file(MI_INFO *info)
 
 void _mi_unmap_file(MI_INFO *info)
 {
-  VOID(my_munmap((char*) info->s->file_map, 
-                 (size_t) info->s->mmaped_length + MEMMAP_EXTRA_MARGIN));
+  (void) my_munmap((char*) info->s->file_map, 
+                 (size_t) info->s->mmaped_length + MEMMAP_EXTRA_MARGIN);
 }
 
 
diff -Nrup a/storage/myisam/mi_panic.c b/storage/myisam/mi_panic.c
--- a/storage/myisam/mi_panic.c	2006-12-31 01:06:40 +01:00
+++ b/storage/myisam/mi_panic.c	2008-04-08 12:29:48 +02:00
@@ -103,7 +103,7 @@ int mi_panic(enum ha_panic_function flag
   }
   if (flag == HA_PANIC_CLOSE)
   {
-    VOID(mi_log(0));				/* Close log if neaded */
+    (void) mi_log(0);				/* Close log if neaded */
     ft_free_stopwords();
   }
   pthread_mutex_unlock(&THR_LOCK_myisam);
diff -Nrup a/storage/myisam/mi_rsame.c b/storage/myisam/mi_rsame.c
--- a/storage/myisam/mi_rsame.c	2007-05-10 11:59:32 +02:00
+++ b/storage/myisam/mi_rsame.c	2008-04-08 12:29:48 +02:00
@@ -50,9 +50,9 @@ int mi_rsame(MI_INFO *info, uchar *recor
 				      info->lastpos);
     if (info->s->concurrent_insert)
       rw_rdlock(&info->s->key_root_lock[inx]);
-    VOID(_mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,
+    (void) _mi_search(info,info->s->keyinfo+inx,info->lastkey, USE_WHOLE_KEY,
 		    SEARCH_SAME,
-		    info->s->state.key_root[inx]));
+		    info->s->state.key_root[inx]);
     if (info->s->concurrent_insert)
       rw_unlock(&info->s->key_root_lock[inx]);
   }
diff -Nrup a/storage/myisam/mi_statrec.c b/storage/myisam/mi_statrec.c
--- a/storage/myisam/mi_statrec.c	2008-03-29 09:01:36 +01:00
+++ b/storage/myisam/mi_statrec.c	2008-04-08 12:29:49 +02:00
@@ -282,7 +282,7 @@ int _mi_read_rnd_static_record(MI_INFO *
 		    info->s->base.pack_reclength - info->s->base.reclength);
   }
   if (locked)
-    VOID(_mi_writeinfo(info,0));		/* Unlock keyfile */
+    (void) _mi_writeinfo(info,0);		/* Unlock keyfile */
   if (!error)
   {
     if (!buf[0])
diff -Nrup a/storage/myisam/mi_test1.c b/storage/myisam/mi_test1.c
--- a/storage/myisam/mi_test1.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_test1.c	2008-04-08 12:29:49 +02:00
@@ -161,7 +161,7 @@ static int run_test(const char *filename
   row_count=deleted=0;
   for (i=49 ; i>=1 ; i-=2 )
   {
-    if (insert_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
+    if (insert_count-- == 0) { (void) mi_close(file); exit(0) ; }
     j=i%25 +1;
     create_record(record,j);
     error=mi_write(file,record);
@@ -225,7 +225,7 @@ static int run_test(const char *filename
     found=0;
     while ((error=mi_rrnd(file,read_record,pos)) == 0)
     {
-      if (update_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
+      if (update_count-- == 0) { (void) mi_close(file); exit(0) ; }
       memcpy(record,read_record,rec_length);
       update_record(record);
       if (mi_update(file,read_record,record))
@@ -252,7 +252,7 @@ static int run_test(const char *filename
     for (i=0 ; i <= 10 ; i++)
     {
       /* testing */
-      if (remove_count-- == 0) { VOID(mi_close(file)) ; exit(0) ; }
+      if (remove_count-- == 0) { (void) mi_close(file); exit(0) ; }
       j=i*2;
       if (!flags[j])
 	continue;
diff -Nrup a/storage/myisam/mi_test2.c b/storage/myisam/mi_test2.c
--- a/storage/myisam/mi_test2.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_test2.c	2008-04-08 12:29:50 +02:00
@@ -862,7 +862,7 @@ reads:      %10lu\n",
 err:
   printf("got error: %d when using MyISAM-database\n",my_errno);
   if (file)
-    VOID(mi_close(file));
+    (void) mi_close(file);
   return(1);
 } /* main */
 
diff -Nrup a/storage/myisam/mi_test3.c b/storage/myisam/mi_test3.c
--- a/storage/myisam/mi_test3.c	2008-03-29 09:01:58 +01:00
+++ b/storage/myisam/mi_test3.c	2008-04-08 12:29:50 +02:00
@@ -109,7 +109,7 @@ int main(int argc,char **argv)
       sleep(1);
       return 0;
     }
-    VOID(rnd(1));
+    (void) rnd(1);
   }
 
   for (i=0 ; i < forks ; i++)
diff -Nrup a/storage/myisam/mi_update.c b/storage/myisam/mi_update.c
--- a/storage/myisam/mi_update.c	2008-02-18 23:29:35 +01:00
+++ b/storage/myisam/mi_update.c	2008-04-08 12:29:50 +02:00
@@ -181,7 +181,7 @@ int mi_update(register MI_INFO *info, co
     mi_update() must always pass !0 value as operation, since even if
     there is no index change there could be data change.
   */
-  VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE);
   allow_break();				/* Allow SIGHUP & SIGINT */
   if (info->invalidator != 0)
   {
@@ -232,7 +232,7 @@ err:
 
  err_end:
   myisam_log_record(MI_LOG_UPDATE,info,newrec,info->lastpos,my_errno);
-  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
   allow_break();				/* Allow SIGHUP & SIGINT */
   if (save_errno == HA_ERR_KEY_NOT_FOUND)
   {
diff -Nrup a/storage/myisam/mi_write.c b/storage/myisam/mi_write.c
--- a/storage/myisam/mi_write.c	2008-03-31 09:40:37 +02:00
+++ b/storage/myisam/mi_write.c	2008-04-08 12:29:51 +02:00
@@ -155,7 +155,7 @@ int mi_write(MI_INFO *info, uchar *recor
   info->state->records++;
   info->lastpos=filepos;
   myisam_log_record(MI_LOG_WRITE,info,record,filepos,0);
-  VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE);
   if (info->invalidator != 0)
   {
     DBUG_PRINT("info", ("invalidator... '%s' (update)", info->filename));
@@ -232,7 +232,7 @@ err:
 err2:
   save_errno=my_errno;
   myisam_log_record(MI_LOG_WRITE,info,record,filepos,my_errno);
-  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
+  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
   allow_break();			/* Allow SIGHUP & SIGINT */
   DBUG_RETURN(my_errno=save_errno);
 } /* mi_write */
diff -Nrup a/storage/myisam/myisamchk.c b/storage/myisam/myisamchk.c
--- a/storage/myisam/myisamchk.c	2007-12-07 15:02:28 +01:00
+++ b/storage/myisam/myisamchk.c	2008-04-08 12:29:51 +02:00
@@ -99,8 +99,8 @@ int main(int argc, char **argv)
     int new_error=myisamchk(&check_param, *(argv++));
     if ((check_param.testflag & T_REP_ANY) != T_REP)
       check_param.testflag&= ~T_REP;
-    VOID(fflush(stdout));
-    VOID(fflush(stderr));
+    (void) fflush(stdout);
+    (void) fflush(stderr);
     if ((check_param.error_printed | check_param.warning_printed) &&
 	(check_param.testflag & T_FORCE_CREATE) &&
 	(!(check_param.testflag & (T_REP | T_REP_BY_SORT | T_SORT_RECORDS |
@@ -112,15 +112,15 @@ int main(int argc, char **argv)
       check_param.testflag&= ~T_EXTEND;			/* Don't needed  */
       error|=myisamchk(&check_param, argv[-1]);
       check_param.testflag= old_testflag;
-      VOID(fflush(stdout));
-      VOID(fflush(stderr));
+      (void) fflush(stdout);
+      (void) fflush(stderr);
     }
     else
       error|=new_error;
     if (argc && (!(check_param.testflag & T_SILENT) || check_param.testflag & T_INFO))
     {
       puts("\n---------\n");
-      VOID(fflush(stdout));
+      (void) fflush(stdout);
     }
   }
   if (check_param.total_files > 1)
@@ -761,9 +761,9 @@ static void get_options(register int *ar
   if ((check_param.testflag & T_UNPACK) &&
       (check_param.testflag & (T_QUICK | T_SORT_RECORDS)))
   {
-    VOID(fprintf(stderr,
+    (void) fprintf(stderr,
 		 "%s: --unpack can't be used with --quick or --sort-records\n",
-		 my_progname_short));
+		 my_progname_short);
     exit(1);
   }
   if ((check_param.testflag & T_READONLY) &&
@@ -771,9 +771,9 @@ static void get_options(register int *ar
        (T_REP_ANY | T_STATISTICS | T_AUTO_INC |
 	T_SORT_RECORDS | T_SORT_INDEX | T_FORCE_CREATE)))
   {
-    VOID(fprintf(stderr,
+    (void) fprintf(stderr,
 		 "%s: Can't use --readonly when repairing or sorting\n",
-		 my_progname_short));
+		 my_progname_short);
     exit(1);
   }
 
@@ -927,9 +927,9 @@ static int myisamchk(MI_CHECK *param, ch
       param->language= set_collation->number;
     if (recreate_table(param, &info,filename))
     {
-      VOID(fprintf(stderr,
+      (void) fprintf(stderr,
 		   "MyISAM-table '%s' is not fixed because of errors\n",
-	      filename));
+	      filename);
       return(-1);
     }
     recreate=1;
@@ -1029,7 +1029,7 @@ static int myisamchk(MI_CHECK *param, ch
 #ifndef TO_BE_REMOVED
 	if (param->out_flag & O_NEW_DATA)
 	{			/* Change temp file to org file */
-	  VOID(my_close(info->dfile,MYF(MY_WME))); /* Close new file */
+	  (void) my_close(info->dfile,MYF(MY_WME)); /* Close new file */
 	  error|=change_to_newfile(filename,MI_NAME_DEXT,DATA_TMP_EXT,
 				   raid_chunks,
 				   MYF(0));
@@ -1100,23 +1100,23 @@ static int myisamchk(MI_CHECK *param, ch
 	  !(param->testflag & (T_FAST | T_FORCE_CREATE)))
       {
 	if (param->testflag & (T_EXTEND | T_MEDIUM))
-	  VOID(init_key_cache(dflt_key_cache,opt_key_cache_block_size,
-                              param->use_buffers, 0, 0));
-	VOID(init_io_cache(&param->read_cache,datafile,
+	  (void) init_key_cache(dflt_key_cache,opt_key_cache_block_size,
+                              param->use_buffers, 0, 0);
+	(void) init_io_cache(&param->read_cache,datafile,
 			   (uint) param->read_buffer_length,
 			   READ_CACHE,
 			   (param->start_check_pos ?
 			    param->start_check_pos :
 			    share->pack.header_length),
 			   1,
-			   MYF(MY_WME)));
+			   MYF(MY_WME));
 	lock_memory(param);
 	if ((info->s->options & (HA_OPTION_PACK_RECORD |
 				 HA_OPTION_COMPRESS_RECORD)) ||
 	    (param->testflag & (T_EXTEND | T_MEDIUM)))
 	  error|=chk_data_link(param, info, param->testflag & T_EXTEND);
 	error|=flush_blocks(param, share->key_cache, share->kfile);
-	VOID(end_io_cache(&param->read_cache));
+	(void) end_io_cache(&param->read_cache);
       }
       if (!error)
       {
@@ -1149,7 +1149,7 @@ static int myisamchk(MI_CHECK *param, ch
 				(state_updated ? UPDATE_STAT : 0) |
 				((param->testflag & T_SORT_RECORDS) ?
 				 UPDATE_SORT : 0)));
-    VOID(lock_file(param, share->kfile,0L,F_UNLCK,"indexfile",filename));
+    (void) lock_file(param, share->kfile,0L,F_UNLCK,"indexfile",filename);
     info->update&= ~HA_STATE_CHANGED;
   }
   mi_lock_database(info, F_UNLCK);
@@ -1170,30 +1170,30 @@ end2:
       error|=change_to_newfile(filename,MI_NAME_IEXT,INDEX_TMP_EXT,0,
 			       MYF(0));
   }
-  VOID(fflush(stdout)); VOID(fflush(stderr));
+  (void) fflush(stdout); (void) fflush(stderr);
   if (param->error_printed)
   {
     if (param->testflag & (T_REP_ANY | T_SORT_RECORDS | T_SORT_INDEX))
     {
-      VOID(fprintf(stderr,
+      (void) fprintf(stderr,
 		   "MyISAM-table '%s' is not fixed because of errors\n",
-		   filename));
+		   filename);
       if (param->testflag & T_REP_ANY)
-	VOID(fprintf(stderr,
-		     "Try fixing it by using the --safe-recover (-o), the --force (-f) option or by not using the --quick (-q) flag\n"));
+	(void) fprintf(stderr,
+		     "Try fixing it by using the --safe-recover (-o), the --force (-f) option or by not using the --quick (-q) flag\n");
     }
     else if (!(param->error_printed & 2) &&
 	     !(param->testflag & T_FORCE_CREATE))
-      VOID(fprintf(stderr,
+      (void) fprintf(stderr,
       "MyISAM-table '%s' is corrupted\nFix it using switch \"-r\" or \"-o\"\n",
-	      filename));
+	      filename);
   }
   else if (param->warning_printed &&
 	   ! (param->testflag & (T_REP_ANY | T_SORT_RECORDS | T_SORT_INDEX |
 			  T_FORCE_CREATE)))
-    VOID(fprintf(stderr, "MyISAM-table '%s' is usable but should be fixed\n",
-		 filename));
-  VOID(fflush(stderr));
+    (void) fprintf(stderr, "MyISAM-table '%s' is usable but should be fixed\n",
+		 filename);
+  (void) fflush(stderr);
   DBUG_RETURN(error);
 } /* myisamchk */
 
@@ -1320,7 +1320,7 @@ static void descript(MI_CHECK *param, re
   printf("Key Start Len Index   Type");
   if (param->testflag & T_VERBOSE)
     printf("                     Rec/key         Root  Blocksize");
-  VOID(putchar('\n'));
+  (void) putchar('\n');
 
   for (key=keyseg_nr=0, keyinfo= &share->keyinfo[0] ;
        key < share->base.keys;
@@ -1359,7 +1359,7 @@ static void descript(MI_CHECK *param, re
       printf("%11lu %12s %10d",
 	     share->state.rec_per_key_part[keyseg_nr++],
 	     buff,keyinfo->block_length);
-    VOID(putchar('\n'));
+    (void) putchar('\n');
     while ((++keyseg)->type != HA_KEYTYPE_END)
     {
       pos=buff;
@@ -1378,7 +1378,7 @@ static void descript(MI_CHECK *param, re
 	     (long) keyseg->start+1,keyseg->length,buff);
       if (param->testflag & T_VERBOSE)
 	printf("%11lu", share->state.rec_per_key_part[keyseg_nr++]);
-      VOID(putchar('\n'));
+      (void) putchar('\n');
     }
     keyseg++;
   }
@@ -1416,7 +1416,7 @@ static void descript(MI_CHECK *param, re
     printf("\nField Start Length Nullpos Nullbit Type");
     if (share->options & HA_OPTION_COMPRESS_RECORD)
       printf("                         Huff tree  Bits");
-    VOID(putchar('\n'));
+    (void) putchar('\n');
     start=1;
     for (field=0 ; field < share->base.fields ; field++)
     {
@@ -1455,7 +1455,7 @@ static void descript(MI_CHECK *param, re
 		 (uint) (share->rec[field].huff_tree-share->decode_trees)+1,
 		 share->rec[field].huff_tree->quick_table_bits);
       }
-      VOID(putchar('\n'));
+      (void) putchar('\n');
       start+=share->rec[field].length;
     }
   }
@@ -1603,7 +1603,7 @@ static int mi_sort_records(MI_CHECK *par
     goto err;
   }
 
-  VOID(my_close(info->dfile,MYF(MY_WME)));
+  (void) my_close(info->dfile,MYF(MY_WME));
   param->out_flag|=O_NEW_DATA;			/* Data in new file */
   info->dfile=new_file;				/* Use new datafile */
   info->state->del=0;
@@ -1617,14 +1617,14 @@ static int mi_sort_records(MI_CHECK *par
 
   if (param->testflag & T_WRITE_LOOP)
   {
-    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
+    (void) fputs("          \r",stdout); (void) fflush(stdout);
   }
   got_error=0;
 
 err:
   if (got_error && new_file >= 0)
   {
-    VOID(end_io_cache(&info->rec_cache));
+    (void) end_io_cache(&info->rec_cache);
     (void) my_close(new_file,MYF(MY_WME));
     (void) my_raid_delete(param->temp_filename, share->base.raid_chunks,
 			  MYF(MY_WME));
@@ -1636,7 +1636,7 @@ err:
   my_free(mi_get_rec_buff_ptr(info, sort_param.record),
           MYF(MY_ALLOW_ZERO_PTR));
   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
-  VOID(end_io_cache(&info->rec_cache));
+  (void) end_io_cache(&info->rec_cache);
   my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
   sort_info.buff=0;
   share->state.sortkey=sort_key;
@@ -1760,8 +1760,8 @@ void mi_check_print_info(MI_CHECK *param
   va_list args;
 
   va_start(args,fmt);
-  VOID(vfprintf(stdout, fmt, args));
-  VOID(fputc('\n',stdout));
+  (void) vfprintf(stdout, fmt, args);
+  (void) fputc('\n',stdout);
   va_end(args);
 }
 
@@ -1783,8 +1783,8 @@ void mi_check_print_warning(MI_CHECK *pa
   param->warning_printed=1;
   va_start(args,fmt);
   fprintf(stderr,"%s: warning: ",my_progname_short);
-  VOID(vfprintf(stderr, fmt, args));
-  VOID(fputc('\n',stderr));
+  (void) vfprintf(stderr, fmt, args);
+  (void) fputc('\n',stderr);
   fflush(stderr);
   va_end(args);
   DBUG_VOID_RETURN;
@@ -1808,8 +1808,8 @@ void mi_check_print_error(MI_CHECK *para
   param->error_printed|=1;
   va_start(args,fmt);
   fprintf(stderr,"%s: error: ",my_progname_short);
-  VOID(vfprintf(stderr, fmt, args));
-  VOID(fputc('\n',stderr));
+  (void) vfprintf(stderr, fmt, args);
+  (void) fputc('\n',stderr);
   fflush(stderr);
   va_end(args);
   DBUG_VOID_RETURN;
diff -Nrup a/storage/myisam/myisamlog.c b/storage/myisam/myisamlog.c
--- a/storage/myisam/myisamlog.c	2008-02-18 23:29:35 +01:00
+++ b/storage/myisam/myisamlog.c	2008-04-08 12:29:52 +02:00
@@ -121,7 +121,7 @@ int main(int argc, char **argv)
   if (re_open_count)
     printf("Had to do %d re-open because of too few possibly open files\n",
 	   re_open_count);
-  VOID(mi_panic(HA_PANIC_CLOSE));
+  (void) mi_panic(HA_PANIC_CLOSE);
   my_free_open_file_info();
   my_end(test_info ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
   exit(error);
@@ -292,8 +292,8 @@ static void get_options(register int *ar
   }
   return;
  err:
-  VOID(fprintf(stderr,"option \"%c\" used without or with wrong argument\n",
-	       option));
+  (void) fprintf(stderr,"option \"%c\" used without or with wrong argument\n",
+	       option);
   exit(1);
 }
 
@@ -332,8 +332,8 @@ static int examine_log(char * file_name,
   bzero((uchar*) com_count,sizeof(com_count));
   init_tree(&tree,0,0,sizeof(file_info),(qsort_cmp2) file_info_compare,1,
 	    (tree_element_free) file_info_free, NULL);
-  VOID(init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE,
-                      0, 0));
+  (void) init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE,
+                      0, 0);
 
   files_open=0; access_time=0;
   while (access_time++ != number_of_commands &&
@@ -412,8 +412,8 @@ static int examine_log(char * file_name,
       }
       open_param.name=file_info.name;
       open_param.max_id=0;
-      VOID(tree_walk(&tree,(tree_walk_action) test_if_open,(void*) &open_param,
-		     left_root_right));
+      (void) tree_walk(&tree,(tree_walk_action) test_if_open,(void*) &open_param,
+		     left_root_right);
       file_info.id=open_param.max_id+1;
       /*
        * In the line below +10 is added to accomodate '<' and '>' chars
@@ -458,7 +458,7 @@ static int examine_log(char * file_name,
 	files_open++;
 	file_info.closed=0;
       }
-      VOID(tree_insert(&tree, (uchar*) &file_info, 0, tree.custom_arg));
+      (void) tree_insert(&tree, (uchar*) &file_info, 0, tree.custom_arg);
       if (file_info.used)
       {
 	if (verbose && !record_pos_file)
@@ -477,7 +477,7 @@ static int examine_log(char * file_name,
       {
 	if (!curr_file_info->closed)
 	  files_open--;
-        VOID(tree_delete(&tree, (uchar*) curr_file_info, 0, tree.custom_arg));
+        (void) tree_delete(&tree, (uchar*) curr_file_info, 0, tree.custom_arg);
       }
       break;
     case MI_LOG_EXTRA:
@@ -493,10 +493,10 @@ static int examine_log(char * file_name,
 	if (mi_extra(curr_file_info->isam, extra_command, 0) != (int) result)
 	{
 	  fflush(stdout);
-	  VOID(fprintf(stderr,
+	  (void) fprintf(stderr,
 		       "Warning: error %d, expected %d on command %s at %s\n",
 		       my_errno,result,command_name[command],
-		       llstr(isamlog_filepos,llbuff)));
+		       llstr(isamlog_filepos,llbuff));
 	  fflush(stderr);
 	}
       }
@@ -641,39 +641,39 @@ static int examine_log(char * file_name,
       break;
     default:
       fflush(stdout);
-      VOID(fprintf(stderr,
+      (void) fprintf(stderr,
 		   "Error: found unknown command %d in logfile, aborted\n",
-		   command));
+		   command);
       fflush(stderr);
       goto end;
     }
   }
   end_key_cache(dflt_key_cache,1);
   delete_tree(&tree);
-  VOID(end_io_cache(&cache));
-  VOID(my_close(file,MYF(0)));
+  (void) end_io_cache(&cache);
+  (void) my_close(file,MYF(0));
   if (write_file && my_fclose(write_file,MYF(MY_WME)))
     DBUG_RETURN(1);
   DBUG_RETURN(0);
 
  err:
   fflush(stdout);
-  VOID(fprintf(stderr,"Got error %d when reading from logfile\n",my_errno));
+  (void) fprintf(stderr,"Got error %d when reading from logfile\n",my_errno);
   fflush(stderr);
   goto end;
  com_err:
   fflush(stdout);
-  VOID(fprintf(stderr,"Got error %d, expected %d on command %s at %s\n",
+  (void) fprintf(stderr,"Got error %d, expected %d on command %s at %s\n",
 	       my_errno,result,command_name[command],
-	       llstr(isamlog_filepos,llbuff)));
+	       llstr(isamlog_filepos,llbuff));
   fflush(stderr);
  end:
   end_key_cache(dflt_key_cache, 1);
   delete_tree(&tree);
-  VOID(end_io_cache(&cache));
-  VOID(my_close(file,MYF(0)));
+  (void) end_io_cache(&cache);
+  (void) my_close(file,MYF(0));
   if (write_file)
-    VOID(my_fclose(write_file,MYF(MY_WME)));
+    (void) my_fclose(write_file,MYF(MY_WME));
   DBUG_RETURN(1);
 }
 
@@ -757,7 +757,7 @@ static void file_info_free(struct file_i
   if (update)
   {
     if (!fileinfo->closed)
-      VOID(mi_close(fileinfo->isam));
+      (void) mi_close(fileinfo->isam);
     if (fileinfo->record)
       my_free(fileinfo->record,MYF(0));
   }
@@ -775,8 +775,8 @@ static int close_some_file(TREE *tree)
   access_param.min_accessed=LONG_MAX;
   access_param.found=0;
 
-  VOID(tree_walk(tree,(tree_walk_action) test_when_accessed,
-		 (void*) &access_param,left_root_right));
+  (void) tree_walk(tree,(tree_walk_action) test_when_accessed,
+		 (void*) &access_param,left_root_right);
   if (!access_param.found)
     return 1;			/* No open file that is possibly to close */
   if (mi_close(access_param.found->isam))
@@ -815,7 +815,7 @@ static int find_record_with_key(struct f
     if (mi_is_key_active(info->s->state.key_map, key) &&
 	info->s->keyinfo[key].flag & HA_NOSAME)
     {
-      VOID(_mi_make_key(info,key,tmp_key,record,0L));
+      (void) _mi_make_key(info,key,tmp_key,record,0L);
       return mi_rkey(info,file_info->record,(int) key,tmp_key,0,
 		     HA_READ_KEY_EXACT);
     }
diff -Nrup a/storage/myisam/myisampack.c b/storage/myisam/myisampack.c
--- a/storage/myisam/myisampack.c	2008-02-27 12:29:58 +01:00
+++ b/storage/myisam/myisampack.c	2008-04-08 12:29:52 +02:00
@@ -238,8 +238,8 @@ int main(int argc, char **argv)
   }
   if (ok && isamchk_neaded && !silent)
     puts("Remember to run myisamchk -rq on compressed tables");
-  VOID(fflush(stdout));
-  VOID(fflush(stderr));
+  (void) fflush(stdout);
+  (void) fflush(stderr);
   free_defaults(default_argv);
   my_end(verbose ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
   exit(error ? 2 : 0);
@@ -291,8 +291,8 @@ static struct my_option my_long_options[
 
 static void print_version(void)
 {
-  VOID(printf("%s Ver 1.23 for %s on %s\n",
-              my_progname, SYSTEM_TYPE, MACHINE_TYPE));
+  printf("%s Ver 1.23 for %s on %s\n",
+              my_progname, SYSTEM_TYPE, MACHINE_TYPE);
   NETWARE_SET_SCREEN_MODE(1);
 }
 
@@ -309,7 +309,7 @@ static void usage(void)
   puts("afterwards to update the keys.");
   puts("You should give the .MYI file as the filename argument.");
 
-  VOID(printf("\nUsage: %s [OPTIONS] filename...\n", my_progname));
+  printf("\nUsage: %s [OPTIONS] filename...\n", my_progname);
   my_print_help(my_long_options);
   print_defaults("my", load_default_groups);
   my_print_variables(my_long_options);
@@ -407,7 +407,7 @@ static MI_INFO *open_isam_file(char *nam
 			  (opt_wait ? HA_OPEN_WAIT_IF_LOCKED :
 			   HA_OPEN_ABORT_IF_LOCKED))))
   {
-    VOID(fprintf(stderr, "%s gave error %d on open\n", name, my_errno));
+    (void) fprintf(stderr, "%s gave error %d on open\n", name, my_errno);
     DBUG_RETURN(0);
   }
   share=isam_file->s;
@@ -415,8 +415,8 @@ static MI_INFO *open_isam_file(char *nam
   {
     if (!force_pack)
     {
-      VOID(fprintf(stderr, "%s is already compressed\n", name));
-      VOID(mi_close(isam_file));
+      (void) fprintf(stderr, "%s is already compressed\n", name);
+      (void) mi_close(isam_file);
       DBUG_RETURN(0);
     }
     if (verbose)
@@ -427,11 +427,11 @@ static MI_INFO *open_isam_file(char *nam
       (share->state.state.records <= 1 ||
        share->state.state.data_file_length < 1024))
   {
-    VOID(fprintf(stderr, "%s is too small to compress\n", name));
-    VOID(mi_close(isam_file));
+    (void) fprintf(stderr, "%s is too small to compress\n", name);
+    (void) mi_close(isam_file);
     DBUG_RETURN(0);
   }
-  VOID(mi_lock_database(isam_file,F_WRLCK));
+  (void) mi_lock_database(isam_file,F_WRLCK);
   DBUG_RETURN(isam_file);
 }
 
@@ -473,8 +473,8 @@ static my_bool open_isam_files(PACK_MRG_
   return 0;
 
  diff_file:
-  VOID(fprintf(stderr, "%s: Tables '%s' and '%s' are not identical\n",
-               my_progname, names[j], names[j+1]));
+  (void) fprintf(stderr, "%s: Tables '%s' and '%s' are not identical\n",
+               my_progname, names[j], names[j+1]);
  error:
   while (i--)
     mi_close(mrg->file[i]);
@@ -506,16 +506,16 @@ static int compress(PACK_MRG_INFO *mrg,c
   /* Create temporary or join file */
 
   if (backup)
-    VOID(fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2));
+    (void) fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2);
   else
-    VOID(fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2+4+16));
+    (void) fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2+4+16);
   if (!test_only && result_table)
   {
     /* Make a new indexfile based on first file in list */
     uint length;
     uchar *buff;
     strmov(org_name,result_table);		/* Fix error messages */
-    VOID(fn_format(new_name,result_table,"",MI_NAME_IEXT,2));
+    (void) fn_format(new_name,result_table,"",MI_NAME_IEXT,2);
     if ((join_isam_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME)))
 	< 0)
       goto err;
@@ -530,12 +530,12 @@ static int compress(PACK_MRG_INFO *mrg,c
       goto err;
     }
     my_free(buff,MYF(0));
-    VOID(fn_format(new_name,result_table,"",MI_NAME_DEXT,2));
+    (void) fn_format(new_name,result_table,"",MI_NAME_DEXT,2);
   }
   else if (!tmp_dir[0])
-    VOID(make_new_name(new_name,org_name));
+    (void) make_new_name(new_name,org_name);
   else
-    VOID(fn_format(new_name,org_name,tmp_dir,DATA_TMP_EXT,1+2+4));
+    (void) fn_format(new_name,org_name,tmp_dir,DATA_TMP_EXT,1+2+4);
   if (!test_only &&
       (new_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME))) < 0)
     goto err;
@@ -551,8 +551,8 @@ static int compress(PACK_MRG_INFO *mrg,c
                       (ulong) mrg->records));
   if (write_loop || verbose)
   {
-    VOID(printf("Compressing %s: (%lu records)\n",
-                result_table ? new_name : org_name, (ulong) mrg->records));
+    printf("Compressing %s: (%lu records)\n",
+                result_table ? new_name : org_name, (ulong) mrg->records);
   }
   trees=fields=share->base.fields;
   huff_counts=init_huff_count(isam_file,mrg->records);
@@ -563,7 +563,7 @@ static int compress(PACK_MRG_INFO *mrg,c
   */
   DBUG_PRINT("info", ("- Calculating statistics"));
   if (write_loop || verbose)
-    VOID(printf("- Calculating statistics\n"));
+    printf("- Calculating statistics\n");
   if (get_statistic(mrg,huff_counts))
     goto err;
   NORMAL_SAFEMALLOC;
@@ -613,7 +613,7 @@ static int compress(PACK_MRG_INFO *mrg,c
   */
   file_buffer.pos_in_file=HEAD_LENGTH;
   if (! test_only)
-    VOID(my_seek(new_file,file_buffer.pos_in_file,MY_SEEK_SET,MYF(0)));
+    my_seek(new_file,file_buffer.pos_in_file,MY_SEEK_SET,MYF(0));
 
   /*
     Write field infos: field type, pack type, length bits, tree number.
@@ -639,7 +639,7 @@ static int compress(PACK_MRG_INFO *mrg,c
   */
   DBUG_PRINT("info", ("- Compressing file"));
   if (write_loop || verbose)
-    VOID(printf("- Compressing file\n"));
+    printf("- Compressing file\n");
   error=compress_isam_file(mrg,huff_counts);
   new_length=file_buffer.pos_in_file;
   if (!error && !test_only)
@@ -666,9 +666,9 @@ static int compress(PACK_MRG_INFO *mrg,c
                       mrg->min_pack_length, mrg->max_pack_length,
                       (ulong) (mrg->records ? (new_length/mrg->records) : 0)));
   if (verbose && mrg->records)
-    VOID(printf("Min record length: %6d   Max length: %6d   "
+    printf("Min record length: %6d   Max length: %6d   "
                 "Mean total length: %6ld\n", mrg->min_pack_length,
-                mrg->max_pack_length, (ulong) (new_length/mrg->records)));
+                mrg->max_pack_length, (ulong) (new_length/mrg->records));
 
   /* Close source and target file. */
   if (!test_only)
@@ -704,9 +704,9 @@ static int compress(PACK_MRG_INFO *mrg,c
 	    error=my_rename(new_name,org_name,MYF(MY_WME));
 	  if (!error)
           {
-	    VOID(my_copystat(temp_name,org_name,MYF(MY_COPYTIME)));
+	    (void) my_copystat(temp_name,org_name,MYF(MY_COPYTIME));
             if (tmp_dir[0])
-              VOID(my_delete(new_name,MYF(MY_WME)));
+              (void) my_delete(new_name,MYF(MY_WME));
           }
 	}
       }
@@ -717,7 +717,7 @@ static int compress(PACK_MRG_INFO *mrg,c
 	  error=my_copy(new_name,org_name,
 			MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_COPYTIME));
           if (!error)
-            VOID(my_delete(new_name,MYF(MY_WME)));
+            (void) my_delete(new_name,MYF(MY_WME));
         }
 	else
 	  error=my_redel(org_name,new_name,MYF(MY_WME | MY_COPYTIME));
@@ -731,16 +731,16 @@ static int compress(PACK_MRG_INFO *mrg,c
     error|=my_close(join_isam_file,MYF(MY_WME));
   if (error)
   {
-    VOID(fprintf(stderr, "Aborting: %s is not compressed\n", org_name));
-    VOID(my_delete(new_name,MYF(MY_WME)));
+    (void) fprintf(stderr, "Aborting: %s is not compressed\n", org_name);
+    (void) my_delete(new_name,MYF(MY_WME));
     DBUG_RETURN(-1);
   }
   if (write_loop || verbose)
   {
     if (old_length)
-      VOID(printf("%.4g%%     \n",
+      printf("%.4g%%     \n",
                   (((longlong) (old_length - new_length)) * 100.0 /
-                   (longlong) old_length)));
+                   (longlong) old_length));
     else
       puts("Empty file saved in compressed format");
   }
@@ -749,11 +749,11 @@ static int compress(PACK_MRG_INFO *mrg,c
  err:
   free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields);
   if (new_file >= 0)
-    VOID(my_close(new_file,MYF(0)));
+    (void) my_close(new_file,MYF(0));
   if (join_isam_file >= 0)
-    VOID(my_close(join_isam_file,MYF(0)));
+    (void) my_close(join_isam_file,MYF(0));
   mrg_close(mrg);
-  VOID(fprintf(stderr, "Aborted: %s is not compressed\n", org_name));
+  (void) fprintf(stderr, "Aborted: %s is not compressed\n", org_name);
   DBUG_RETURN(-1);
 }
 
@@ -1069,13 +1069,13 @@ static int get_statistic(PACK_MRG_INFO *
       record_count++;
       if (write_loop && record_count % WRITE_COUNT == 0)
       {
-	VOID(printf("%lu\r", (ulong) record_count));
-        VOID(fflush(stdout));
+	printf("%lu\r", (ulong) record_count);
+        (void) fflush(stdout);
       }
     }
     else if (error != HA_ERR_RECORD_DELETED)
     {
-      VOID(fprintf(stderr, "Got error %d while reading rows", error));
+      (void) fprintf(stderr, "Got error %d while reading rows", error);
       break;
     }
 
@@ -1083,8 +1083,8 @@ static int get_statistic(PACK_MRG_INFO *
   }
   if (write_loop)
   {
-    VOID(printf("            \r"));
-    VOID(fflush(stdout));
+    printf("            \r");
+    (void) fflush(stdout);
   }
 
   /*
@@ -1096,8 +1096,8 @@ static int get_statistic(PACK_MRG_INFO *
   DBUG_PRINT("info", ("Found the following number of incidents "
                       "of the byte codes:"));
   if (verbose >= 2)
-    VOID(printf("Found the following number of incidents "
-                "of the byte codes:\n"));
+    printf("Found the following number of incidents "
+                "of the byte codes:\n");
   for (count= huff_counts ; count < end_count; count++)
   {
     uint      idx;
@@ -1106,16 +1106,16 @@ static int get_statistic(PACK_MRG_INFO *
 
     DBUG_PRINT("info", ("column: %3u", (uint) (count - huff_counts + 1)));
     if (verbose >= 2)
-      VOID(printf("column: %3u\n", (uint) (count - huff_counts + 1)));
+      printf("column: %3u\n", (uint) (count - huff_counts + 1));
     if (count->tree_buff)
     {
       DBUG_PRINT("info", ("number of distinct values: %u",
                           (uint) ((count->tree_pos - count->tree_buff) /
                                   count->field_length)));
       if (verbose >= 2)
-        VOID(printf("number of distinct values: %u\n",
+        printf("number of distinct values: %u\n",
                     (uint) ((count->tree_pos - count->tree_buff) /
-                            count->field_length)));
+                            count->field_length));
     }
     total_count= 0;
     for (idx= 0; idx < 256; idx++)
@@ -1126,16 +1126,16 @@ static int get_statistic(PACK_MRG_INFO *
         DBUG_PRINT("info", ("counts[0x%02x]: %12s", idx,
                             llstr((longlong) count->counts[idx], llbuf)));
         if (verbose >= 2)
-          VOID(printf("counts[0x%02x]: %12s\n", idx,
-                      llstr((longlong) count->counts[idx], llbuf)));
+          printf("counts[0x%02x]: %12s\n", idx,
+                      llstr((longlong) count->counts[idx], llbuf));
       }
     }
     DBUG_PRINT("info", ("total:        %12s", llstr((longlong) total_count,
                                                     llbuf)));
     if ((verbose >= 2) && total_count)
     {
-      VOID(printf("total:        %12s\n",
-                  llstr((longlong) total_count, llbuf)));
+      printf("total:        %12s\n",
+                  llstr((longlong) total_count, llbuf));
     }
   }
 
@@ -1352,7 +1352,7 @@ static void check_counts(HUFF_COUNTS *hu
                       field_count[FIELD_INTERVALL],
                       field_count[FIELD_ZERO]));
   if (verbose)
-    VOID(printf("\nnormal:    %3d  empty-space:     %3d  "
+    printf("\nnormal:    %3d  empty-space:     %3d  "
                 "empty-zero:       %3d  empty-fill: %3d\n"
                 "pre-space: %3d  end-space:       %3d  "
                 "intervall-fields: %3d  zero:       %3d\n",
@@ -1361,7 +1361,7 @@ static void check_counts(HUFF_COUNTS *hu
                 field_count[FIELD_SKIP_PRESPACE],
                 field_count[FIELD_SKIP_ENDSPACE],
                 field_count[FIELD_INTERVALL],
-                field_count[FIELD_ZERO]));
+                field_count[FIELD_ZERO]);
   DBUG_VOID_RETURN;
 }
 
@@ -1876,7 +1876,7 @@ static uint join_same_trees(HUFF_COUNTS 
   DBUG_PRINT("info", ("Original trees:  %d  After join: %d",
                       trees, tree_number));
   if (verbose)
-    VOID(printf("Original trees:  %d  After join: %d\n", trees, tree_number));
+    printf("Original trees:  %d  After join: %d\n", trees, tree_number);
   return tree_number;			/* Return trees left */
 }
 
@@ -2022,7 +2022,7 @@ static int write_header(PACK_MRG_INFO *m
   buff[27]= (uchar) mi_get_pointer_length((ulonglong) filelength,2);
   if (test_only)
     return 0;
-  VOID(my_seek(file_buffer.file,0L,MY_SEEK_SET,MYF(0)));
+  my_seek(file_buffer.file,0L,MY_SEEK_SET,MYF(0));
   return my_write(file_buffer.file,(const uchar *) file_buffer.pos,HEAD_LENGTH,
 		  MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)) != 0;
 }
@@ -2055,24 +2055,24 @@ static void write_field_info(HUFF_COUNTS
   DBUG_PRINT("info", (" "));
   if (verbose >= 2)
   {
-    VOID(printf("\n"));
-    VOID(printf("column types:\n"));
-    VOID(printf("FIELD_NORMAL          0\n"));
-    VOID(printf("FIELD_SKIP_ENDSPACE   1\n"));
-    VOID(printf("FIELD_SKIP_PRESPACE   2\n"));
-    VOID(printf("FIELD_SKIP_ZERO       3\n"));
-    VOID(printf("FIELD_BLOB            4\n"));
-    VOID(printf("FIELD_CONSTANT        5\n"));
-    VOID(printf("FIELD_INTERVALL       6\n"));
-    VOID(printf("FIELD_ZERO            7\n"));
-    VOID(printf("FIELD_VARCHAR         8\n"));
-    VOID(printf("FIELD_CHECK           9\n"));
-    VOID(printf("\n"));
-    VOID(printf("pack type as a set of flags:\n"));
-    VOID(printf("PACK_TYPE_SELECTED      1\n"));
-    VOID(printf("PACK_TYPE_SPACE_FIELDS  2\n"));
-    VOID(printf("PACK_TYPE_ZERO_FILL     4\n"));
-    VOID(printf("\n"));
+    printf("\n");
+    printf("column types:\n");
+    printf("FIELD_NORMAL          0\n");
+    printf("FIELD_SKIP_ENDSPACE   1\n");
+    printf("FIELD_SKIP_PRESPACE   2\n");
+    printf("FIELD_SKIP_ZERO       3\n");
+    printf("FIELD_BLOB            4\n");
+    printf("FIELD_CONSTANT        5\n");
+    printf("FIELD_INTERVALL       6\n");
+    printf("FIELD_ZERO            7\n");
+    printf("FIELD_VARCHAR         8\n");
+    printf("FIELD_CHECK           9\n");
+    printf("\n");
+    printf("pack type as a set of flags:\n");
+    printf("PACK_TYPE_SELECTED      1\n");
+    printf("PACK_TYPE_SPACE_FIELDS  2\n");
+    printf("PACK_TYPE_ZERO_FILL     4\n");
+    printf("\n");
   }
   for (i=0 ; i++ < fields ; counts++)
   {
@@ -2089,10 +2089,10 @@ static void write_field_info(HUFF_COUNTS
                         counts->max_zero_fill, counts->length_bits,
                         counts->tree->tree_number, counts->field_length));
     if (verbose >= 2)
-      VOID(printf("column: %3u  type: %2u  pack: %2u  zero: %4u  lbits: %2u  "
+      printf("column: %3u  type: %2u  pack: %2u  zero: %4u  lbits: %2u  "
                   "tree: %2u  length: %4u\n", i , counts->field_type,
                   counts->pack_type, counts->max_zero_fill, counts->length_bits,
-                  counts->tree->tree_number, counts->field_length));
+                  counts->tree->tree_number, counts->field_length);
   }
   flush_bits();
   return;
@@ -2127,7 +2127,7 @@ static my_off_t write_huff_tree(HUFF_TRE
 
   DBUG_PRINT("info", (" "));
   if (verbose >= 2)
-    VOID(printf("\n"));
+    printf("\n");
   tree_no= 0;
   intervall_length=0;
   for (elements=0; trees-- ; huff_tree++)
@@ -2138,7 +2138,7 @@ static my_off_t write_huff_tree(HUFF_TRE
     tree_no++;
     DBUG_PRINT("info", (" "));
     if (verbose >= 3)
-      VOID(printf("\n"));
+      printf("\n");
     /* Count the total number of elements (byte codes or column values). */
     elements+=huff_tree->elements;
     huff_tree->max_offset=2;
@@ -2157,8 +2157,8 @@ static my_off_t write_huff_tree(HUFF_TRE
     */
     if (huff_tree->max_offset >= IS_OFFSET)
     {				/* This should be impossible */
-      VOID(fprintf(stderr, "Tree offset got too big: %d, aborted\n",
-                   huff_tree->max_offset));
+      (void) fprintf(stderr, "Tree offset got too big: %d, aborted\n",
+                   huff_tree->max_offset);
       my_afree((uchar*) packed_tree);
       return 0;
     }
@@ -2197,19 +2197,19 @@ static my_off_t write_huff_tree(HUFF_TRE
                         "bufflen" : "min_chr", huff_tree->counts->tree_buff ?
                         int_length : huff_tree->min_chr, huff_tree->height));
     if (verbose >= 2)
-      VOID(printf("tree: %2u  elements: %4u  char_bits: %2u  offset_bits: %2u  "
+      printf("tree: %2u  elements: %4u  char_bits: %2u  offset_bits: %2u  "
                   "%s: %5u  codelen: %2u\n", tree_no, huff_tree->elements,
                   huff_tree->char_bits, huff_tree->offset_bits,
                   huff_tree->counts->tree_buff ? "bufflen" : "min_chr",
                   huff_tree->counts->tree_buff ? int_length :
-                  huff_tree->min_chr, huff_tree->height));
+                  huff_tree->min_chr, huff_tree->height);
 
     /* Check that the code tree length matches the element count. */
     length=(uint) (offset-packed_tree);
     if (length != huff_tree->elements*2-2)
     {
-      VOID(fprintf(stderr, "error: Huff-tree-length: %d != calc_length: %d\n",
-                   length, huff_tree->elements * 2 - 2));
+      (void) fprintf(stderr, "error: Huff-tree-length: %d != calc_length: %d\n",
+                   length, huff_tree->elements * 2 - 2);
       errors++;
       break;
     }
@@ -2226,10 +2226,10 @@ static my_off_t write_huff_tree(HUFF_TRE
                           " -> " : "", (packed_tree[i] & IS_OFFSET) ?
                           packed_tree[i] - IS_OFFSET + i : packed_tree[i]));
       if (verbose >= 3)
-        VOID(printf("tree[0x%04x]: %s0x%04x\n",
+        printf("tree[0x%04x]: %s0x%04x\n",
                     i, (packed_tree[i] & IS_OFFSET) ? " -> " : "",
                     (packed_tree[i] & IS_OFFSET) ?
-                    packed_tree[i] - IS_OFFSET + i : packed_tree[i]));
+                    packed_tree[i] - IS_OFFSET + i : packed_tree[i]);
     }
     flush_bits();
 
@@ -2251,9 +2251,9 @@ static my_off_t write_huff_tree(HUFF_TRE
                           bindigits(huff_tree->code[i],
                                     huff_tree->code_len[i])));
       if (verbose >= 3)
-        VOID(printf("code[0x%04x]:      0x%s  bits: %2u  bin: %s\n", i,
+        printf("code[0x%04x]:      0x%s  bits: %2u  bin: %s\n", i,
                     hexdigits(huff_tree->code[i]), huff_tree->code_len[i],
-                    bindigits(huff_tree->code[i], huff_tree->code_len[i])));
+                    bindigits(huff_tree->code[i], huff_tree->code_len[i]));
 
       /* Check that the encode table decodes correctly. */
       code= 0;
@@ -2266,9 +2266,9 @@ static my_off_t write_huff_tree(HUFF_TRE
       {
         if (! len)
         {
-          VOID(fflush(stdout));
-          VOID(fprintf(stderr, "error: code 0x%s with %u bits not found\n",
-                       hexdigits(huff_tree->code[i]), huff_tree->code_len[i]));
+          (void) fflush(stdout);
+          (void) fprintf(stderr, "error: code 0x%s with %u bits not found\n",
+                       hexdigits(huff_tree->code[i]), huff_tree->code_len[i]);
           errors++;
           break;
         }
@@ -2277,18 +2277,18 @@ static my_off_t write_huff_tree(HUFF_TRE
         bits++;
         if (bits > 8 * sizeof(code))
         {
-          VOID(fflush(stdout));
-          VOID(fprintf(stderr, "error: Huffman code too long: %u/%u\n",
-                       bits, (uint) (8 * sizeof(code))));
+          (void) fflush(stdout);
+          (void) fprintf(stderr, "error: Huffman code too long: %u/%u\n",
+                       bits, (uint) (8 * sizeof(code)));
           errors++;
           break;
         }
         idx+= (uint) code & 1;
         if (idx >= length)
         {
-          VOID(fflush(stdout));
-          VOID(fprintf(stderr, "error: illegal tree offset: %u/%u\n",
-                       idx, length));
+          (void) fflush(stdout);
+          (void) fprintf(stderr, "error: illegal tree offset: %u/%u\n",
+                       idx, length);
           errors++;
           break;
         }
@@ -2303,9 +2303,9 @@ static my_off_t write_huff_tree(HUFF_TRE
       DBUG_EXECUTE_IF("forcechkerr4", packed_tree[idx]++;);
       if (packed_tree[idx] != i)
       {
-        VOID(fflush(stdout));
-        VOID(fprintf(stderr, "error: decoded value 0x%04x  should be: 0x%04x\n",
-                     packed_tree[idx], i));
+        (void) fflush(stdout);
+        (void) fprintf(stderr, "error: decoded value 0x%04x  should be: 0x%04x\n",
+                     packed_tree[idx], i);
         errors++;
         break;
       }
@@ -2322,19 +2322,19 @@ static my_off_t write_huff_tree(HUFF_TRE
         DBUG_PRINT("info", ("column_values[0x%04x]: 0x%02x",
                             i, (uchar) huff_tree->counts->tree_buff[i]));
         if (verbose >= 3)
-          VOID(printf("column_values[0x%04x]: 0x%02x\n",
-                      i, (uchar) huff_tree->counts->tree_buff[i]));
+          printf("column_values[0x%04x]: 0x%02x\n",
+                      i, (uchar) huff_tree->counts->tree_buff[i]);
       }
     }
     flush_bits();
   }
   DBUG_PRINT("info", (" "));
   if (verbose >= 2)
-    VOID(printf("\n"));
+    printf("\n");
   my_afree((uchar*) packed_tree);
   if (errors)
   {
-    VOID(fprintf(stderr, "Error: Generated decode trees are corrupt. Stop.\n"));
+    (void) fprintf(stderr, "Error: Generated decode trees are corrupt. Stop.\n");
     return 0;
   }
   return elements;
@@ -2756,8 +2756,8 @@ static int compress_isam_file(PACK_MRG_I
       record_count++;
       if (write_loop && record_count % WRITE_COUNT == 0)
       {
-	VOID(printf("%lu\r", (ulong) record_count));
-        VOID(fflush(stdout));
+	printf("%lu\r", (ulong) record_count);
+        (void) fflush(stdout);
       }
     }
     else if (error != HA_ERR_RECORD_DELETED)
@@ -2767,11 +2767,11 @@ static int compress_isam_file(PACK_MRG_I
     error=0;
   else
   {
-    VOID(fprintf(stderr, "%s: Got error %d reading records\n",
-                 my_progname, error));
+    (void) fprintf(stderr, "%s: Got error %d reading records\n",
+                 my_progname, error);
   }
   if (verbose >= 2)
-    VOID(printf("wrote %s records.\n", llstr((longlong) record_count, llbuf)));
+    printf("wrote %s records.\n", llstr((longlong) record_count, llbuf));
 
   my_afree((uchar*) record);
   mrg->ref_length=max_pack_length;
@@ -2901,7 +2901,7 @@ static void write_bits(register ulonglon
     if (bits != 8 * sizeof(value))
       value&= (((ulonglong) 1) << bits) - 1;
     if (file_buffer.pos >= file_buffer.end)
-      VOID(flush_buffer(~ (ulong) 0));
+      (void) flush_buffer(~ (ulong) 0);
     file_buffer.bits=(int) (BITS_SAVED - bits);
     file_buffer.bitbucket= value << (BITS_SAVED - bits);
   }
@@ -2924,7 +2924,7 @@ static void flush_bits(void)
     *file_buffer.pos++= (uchar) (bit_buffer >> bits);
   }
   if (file_buffer.pos >= file_buffer.end)
-    VOID(flush_buffer(~ (ulong) 0));
+    (void) flush_buffer(~ (ulong) 0);
   file_buffer.bits= BITS_SAVED;
   file_buffer.bitbucket= 0;
 }
@@ -2974,7 +2974,7 @@ static int save_state(MI_INFO *isam_file
   share->changed=1;			/* Force write of header */
   share->state.open_count=0;
   share->global_changed=0;
-  VOID(my_chsize(share->kfile, share->base.keystart, 0, MYF(0)));
+  (void) my_chsize(share->kfile, share->base.keystart, 0, MYF(0));
   if (share->base.keys)
     isamchk_neaded=1;
   DBUG_RETURN(mi_state_info_write(share->kfile,&share->state,1+2));
diff -Nrup a/storage/myisam/sort.c b/storage/myisam/sort.c
--- a/storage/myisam/sort.c	2008-02-01 11:50:19 +01:00
+++ b/storage/myisam/sort.c	2008-04-08 12:29:53 +02:00
@@ -961,7 +961,7 @@ merge_buffers(MI_SORT_PARAM *info, uint 
           uchar *base=buffpek->base;
           uint max_keys=buffpek->max_keys;
 
-          VOID(queue_remove(&queue,0));
+          (void) queue_remove(&queue,0);
 
           /* Put room used by buffer to use in other buffer */
           for (refpek= (BUFFPEK**) &queue_top(&queue);
diff -Nrup a/storage/myisammrg/myrg_close.c b/storage/myisammrg/myrg_close.c
--- a/storage/myisammrg/myrg_close.c	2007-12-11 15:32:09 +01:00
+++ b/storage/myisammrg/myrg_close.c	2008-04-08 12:29:53 +02:00
@@ -58,7 +58,7 @@ int myrg_close(MYRG_INFO *info)
   pthread_mutex_lock(&THR_LOCK_open);
   myrg_open_list=list_delete(myrg_open_list,&info->open_list);
   pthread_mutex_unlock(&THR_LOCK_open);
-  VOID(pthread_mutex_destroy(&info->mutex));
+  pthread_mutex_destroy(&info->mutex);
   my_free((uchar*) info,MYF(0));
   if (error)
   {
diff -Nrup a/storage/myisammrg/myrg_create.c b/storage/myisammrg/myrg_create.c
--- a/storage/myisammrg/myrg_create.c	2007-08-13 15:11:17 +02:00
+++ b/storage/myisammrg/myrg_create.c	2008-04-08 12:29:54 +02:00
@@ -66,7 +66,7 @@ err:
   save_errno=my_errno ? my_errno : -1;
   switch (errpos) {
   case 1:
-    VOID(my_close(file,MYF(0)));
+    (void) my_close(file,MYF(0));
   }
   DBUG_RETURN(my_errno=save_errno);
 } /* myrg_create */
diff -Nrup a/storage/myisammrg/myrg_open.c b/storage/myisammrg/myrg_open.c
--- a/storage/myisammrg/myrg_open.c	2007-12-11 15:32:09 +01:00
+++ b/storage/myisammrg/myrg_open.c	2008-04-08 12:29:54 +02:00
@@ -89,9 +89,9 @@ MYRG_INFO *myrg_open(const char *name, i
 
     if (!has_path(buff))
     {
-      VOID(strmake(name_buff+dir_length,buff,
-                   sizeof(name_buff)-1-dir_length));
-      VOID(cleanup_dirname(buff,name_buff));
+      (void) strmake(name_buff+dir_length,buff,
+                   sizeof(name_buff)-1-dir_length);
+      (void) cleanup_dirname(buff,name_buff);
     }
     else
       fn_format(buff, buff, "", "", 0);
@@ -169,9 +169,9 @@ MYRG_INFO *myrg_open(const char *name, i
   m_info->last_used_table=m_info->open_tables;
   m_info->children_attached= TRUE;
 
-  VOID(my_close(fd,MYF(0)));
+  (void) my_close(fd,MYF(0));
   end_io_cache(&file);
-  VOID(pthread_mutex_init(&m_info->mutex, MY_MUTEX_INIT_FAST));
+  pthread_mutex_init(&m_info->mutex, MY_MUTEX_INIT_FAST);
   m_info->open_list.data=(void*) m_info;
   pthread_mutex_lock(&THR_LOCK_open);
   myrg_open_list=list_add(myrg_open_list,&m_info->open_list);
@@ -190,7 +190,7 @@ err:
     end_io_cache(&file);
     /* Fall through */
   case 1:
-    VOID(my_close(fd,MYF(0)));
+    (void) my_close(fd,MYF(0));
   }
   my_errno=save_errno;
   DBUG_RETURN (NULL);
@@ -314,9 +314,9 @@ MYRG_INFO *myrg_parent_open(const char *
 
     if (!has_path(child_name_buff))
     {
-      VOID(strmake(parent_name_buff + dir_length, child_name_buff,
-                   sizeof(parent_name_buff) - 1 - dir_length));
-      VOID(cleanup_dirname(child_name_buff, parent_name_buff));
+      (void) strmake(parent_name_buff + dir_length, child_name_buff,
+                   sizeof(parent_name_buff) - 1 - dir_length);
+      (void) cleanup_dirname(child_name_buff, parent_name_buff);
     }
     else
       fn_format(child_name_buff, child_name_buff, "", "", 0);
@@ -328,8 +328,8 @@ MYRG_INFO *myrg_parent_open(const char *
   }
 
   end_io_cache(&file_cache);
-  VOID(my_close(fd, MYF(0)));
-  VOID(pthread_mutex_init(&m_info->mutex, MY_MUTEX_INIT_FAST));
+  (void) my_close(fd, MYF(0));
+  pthread_mutex_init(&m_info->mutex, MY_MUTEX_INIT_FAST);
 
   m_info->open_list.data= (void*) m_info;
   pthread_mutex_lock(&THR_LOCK_open);
@@ -349,7 +349,7 @@ MYRG_INFO *myrg_parent_open(const char *
     end_io_cache(&file_cache);
     /* Fall through */
   case 1:
-    VOID(my_close(fd, MYF(0)));
+    (void) my_close(fd, MYF(0));
   }
   my_errno= save_errno;
   DBUG_RETURN (NULL);
diff -Nrup a/strings/str_test.c b/strings/str_test.c
--- a/strings/str_test.c	2007-05-10 11:59:35 +02:00
+++ b/strings/str_test.c	2008-04-08 12:29:55 +02:00
@@ -265,13 +265,13 @@ extern void dummy_functions(void);
 
 void dummy_functions(void)
 {
-  VOID(memchr(from,'a',5));
-  VOID(memcmp(from,to,5));
-  VOID(memcpy(from,to,5));
-  VOID(memset(from,' ',5));
-  VOID(strcmp(from,to));
-  VOID(strcpy(from,to));
-  VOID(strstr(from,to));
-  VOID(strrchr(from,'a'));
+  (void) memchr(from,'a',5);
+  (void) memcmp(from,to,5);
+  (void) memcpy(from,to,5);
+  (void) memset(from,' ',5);
+  (void) strcmp(from,to);
+  (void) strcpy(from,to);
+  (void) strstr(from,to);
+  (void) strrchr(from,'a');
   return;
 }
diff -Nrup a/tests/thread_test.c b/tests/thread_test.c
--- a/tests/thread_test.c	2007-09-15 04:09:33 +02:00
+++ b/tests/thread_test.c	2008-04-08 12:29:55 +02:00
@@ -77,7 +77,7 @@ end:
   mysql_close(mysql);
   pthread_mutex_lock(&LOCK_thread_count);
   thread_count--;
-  VOID(pthread_cond_signal(&COND_thread_count)); /* Tell main we are ready */
+  pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
   pthread_mutex_unlock(&LOCK_thread_count);
   pthread_exit(0);
   return 0;
Thread
bk commit into 5.1 tree (vvaintroub:1.2571) BUG#32082vvaintroub8 Apr