List:Commits« Previous MessageNext Message »
From:Konstantin Osipov Date:November 24 2009 1:55pm
Subject:bzr commit into mysql-5.6-next-mr branch (kostja:2938) Bug#32082
View as plain text  
#At file:///opt/local/work/next-mr-kostja/ based on revid:kostja@strippedxw9w7oce

 2938 Konstantin Osipov	2009-11-24
      Backport of:
      ----------------------------------------------------------------------
      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
        Bug#32082 : remove VOID macro
     @ client/mysqldump.c
        Bug#32082 : remove VOID macro
     @ client/mysqlimport.c
        Bug#32082 : remove VOID macro
     @ client/mysqlslap.c
        Bug#32082 : remove VOID macro
     @ client/mysqltest.cc
        Bug#32082 : remove VOID macro
     @ client/sql_string.cc
        Bug#32082 : remove VOID macro
     @ extra/comp_err.c
        Bug#32082 : remove VOID macro
     @ extra/replace.c
        Bug#32082 : remove VOID macro
     @ include/my_alarm.h
        Bug#32082 : remove VOID macro
     @ include/my_global.h
        Bug#32082 : remove VOID macro
     @ libmysql/libmysql.c
        Bug#32082 : remove VOID macro
     @ mysys/errors.c
        Bug#32082 : remove VOID macro
     @ mysys/hash.c
        Bug#32082 : remove VOID macro
     @ mysys/mf_iocache2.c
        Bug#32082 : remove VOID macro
     @ mysys/mf_loadpath.c
        Bug#32082 : remove VOID macro
     @ mysys/mf_path.c
        Bug#32082 : remove VOID macro
     @ mysys/my_append.c
        Bug#32082 : remove VOID macro
     @ mysys/my_clock.c
        Bug#32082 : remove VOID macro
     @ mysys/my_copy.c
        Bug#32082 : remove VOID macro
     @ mysys/my_fstream.c
        Bug#32082 : remove VOID macro
     @ mysys/my_getwd.c
        Bug#32082 : remove VOID macro
     @ mysys/my_lib.c
        Bug#32082 : remove VOID macro
     @ mysys/my_lockmem.c
        Bug#32082 : remove VOID macro
     @ mysys/my_pthread.c
        Bug#32082 : remove VOID macro
     @ mysys/my_redel.c
        Bug#32082 : remove VOID macro
     @ mysys/stacktrace.c
        Bug#32082 : remove VOID macro
     @ mysys/thr_alarm.c
        Bug#32082 : remove VOID macro
     @ mysys/thr_lock.c
        Bug#32082 : remove VOID macro
     @ sql/derror.cc
        Bug#32082 : remove VOID macro
     @ sql/des_key_file.cc
        Bug#32082 : remove VOID macro
     @ sql/discover.cc
        Bug#32082 : remove VOID macro
     @ sql/field.cc
        Bug#32082 : remove VOID macro
     @ sql/filesort.cc
        Bug#32082 : remove VOID macro
     @ sql/ha_ndbcluster.cc
        Bug#32082 : remove VOID macro
     @ sql/ha_partition.cc
        Bug#32082 : remove VOID macro
     @ sql/handler.cc
        Bug#32082 : remove VOID macro
     @ sql/hostname.cc
        Bug#32082 : remove VOID macro
     @ sql/init.cc
        Bug#32082 : remove VOID macro
     @ sql/item.cc
        Bug#32082 : remove VOID macro
     @ sql/item_cmpfunc.cc
        Bug#32082 : remove VOID macro
     @ sql/item_strfunc.cc
        Bug#32082 : remove VOID macro
     @ sql/lock.cc
        Bug#32082 : remove VOID macro
     @ sql/log.cc
        Bug#32082 : remove VOID macro
     @ sql/log_event.cc
        Bug#32082 : remove VOID macro
     @ sql/mysqld.cc
        Bug#32082 : remove VOID macro
     @ sql/opt_range.h
        Bug#32082 : remove VOID macro
     @ sql/protocol.cc
        Bug#32082 : remove VOID macro
     @ sql/records.cc
        Bug#32082 : remove VOID macro
     @ sql/sp_head.cc
        Bug#32082 : remove VOID macro
     @ sql/sp_pcontext.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_acl.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_base.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_cache.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_connect.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_db.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_delete.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_handler.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_insert.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_map.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_parse.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_select.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_servers.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_show.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_string.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_table.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_test.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_trigger.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_update.cc
        Bug#32082 : remove VOID macro
     @ sql/sql_view.cc
        Bug#32082 : remove VOID macro
     @ sql/table.cc
        Bug#32082 : remove VOID macro
     @ sql/tztime.cc
        Bug#32082 : remove VOID macro
     @ sql/udf_example.c
        Bug#32082 : remove VOID macro
     @ sql/uniques.cc
        Bug#32082 : remove VOID macro
     @ sql/unireg.cc
        Bug#32082 : remove VOID macro
     @ storage/archive/ha_archive.cc
        Bug#32082 : remove VOID macro
     @ storage/blackhole/ha_blackhole.cc
        Bug#32082 : remove VOID macro
     @ storage/csv/ha_tina.cc
        Bug#32082 : remove VOID macro
     @ storage/csv/transparent_file.cc
        Bug#32082 : remove VOID macro
     @ storage/example/ha_example.cc
        Bug#32082 : remove VOID macro
     @ storage/federated/ha_federated.cc
        Bug#32082 : remove VOID macro
     @ storage/heap/hp_clear.c
        Bug#32082 : remove VOID macro
     @ storage/heap/hp_create.c
        Bug#32082 : remove VOID macro
     @ storage/heap/hp_test1.c
        Bug#32082 : remove VOID macro
     @ storage/heap/hp_test2.c
        Bug#32082 : remove VOID macro
     @ storage/innobase/handler/ha_innodb.cc
        Bug#32082 : remove VOID macro
     @ storage/myisam/ft_eval.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/ha_myisam.cc
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_changed.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_check.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_close.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_create.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_dbug.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_delete.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_delete_all.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_dynrec.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_info.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_locking.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_log.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_open.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_packrec.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_panic.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_rsame.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_statrec.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_test1.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_test2.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_test3.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_update.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/mi_write.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/myisamchk.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/myisamlog.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/myisampack.c
        Bug#32082 : remove VOID macro
     @ storage/myisam/sort.c
        Bug#32082 : remove VOID macro
     @ storage/myisammrg/myrg_close.c
        Bug#32082 : remove VOID macro
     @ storage/myisammrg/myrg_create.c
        Bug#32082 : remove VOID macro
     @ storage/myisammrg/myrg_open.c
        Bug#32082 : remove VOID macro
     @ strings/str_test.c
        Bug#32082 : remove VOID macro
     @ tests/thread_test.c
        Bug#32082 : remove VOID macro

    modified:
      client/mysqladmin.cc
      client/mysqldump.c
      client/mysqlimport.c
      client/mysqlslap.c
      client/mysqltest.cc
      client/sql_string.cc
      extra/comp_err.c
      extra/replace.c
      include/my_alarm.h
      include/my_global.h
      libmysql/libmysql.c
      mysys/errors.c
      mysys/hash.c
      mysys/mf_iocache2.c
      mysys/mf_loadpath.c
      mysys/mf_path.c
      mysys/my_append.c
      mysys/my_clock.c
      mysys/my_copy.c
      mysys/my_fstream.c
      mysys/my_getwd.c
      mysys/my_lib.c
      mysys/my_lockmem.c
      mysys/my_pthread.c
      mysys/my_redel.c
      mysys/stacktrace.c
      mysys/thr_alarm.c
      mysys/thr_lock.c
      sql/derror.cc
      sql/des_key_file.cc
      sql/discover.cc
      sql/field.cc
      sql/filesort.cc
      sql/ha_ndbcluster.cc
      sql/ha_partition.cc
      sql/handler.cc
      sql/hostname.cc
      sql/init.cc
      sql/item.cc
      sql/item_cmpfunc.cc
      sql/item_strfunc.cc
      sql/lock.cc
      sql/log.cc
      sql/log_event.cc
      sql/mysqld.cc
      sql/opt_range.h
      sql/protocol.cc
      sql/records.cc
      sql/sp_head.cc
      sql/sp_pcontext.cc
      sql/sql_acl.cc
      sql/sql_base.cc
      sql/sql_cache.cc
      sql/sql_connect.cc
      sql/sql_db.cc
      sql/sql_delete.cc
      sql/sql_handler.cc
      sql/sql_insert.cc
      sql/sql_map.cc
      sql/sql_parse.cc
      sql/sql_select.cc
      sql/sql_servers.cc
      sql/sql_show.cc
      sql/sql_string.cc
      sql/sql_table.cc
      sql/sql_test.cc
      sql/sql_trigger.cc
      sql/sql_update.cc
      sql/sql_view.cc
      sql/table.cc
      sql/tztime.cc
      sql/udf_example.c
      sql/uniques.cc
      sql/unireg.cc
      storage/archive/ha_archive.cc
      storage/blackhole/ha_blackhole.cc
      storage/csv/ha_tina.cc
      storage/csv/transparent_file.cc
      storage/example/ha_example.cc
      storage/federated/ha_federated.cc
      storage/heap/hp_clear.c
      storage/heap/hp_create.c
      storage/heap/hp_test1.c
      storage/heap/hp_test2.c
      storage/innobase/handler/ha_innodb.cc
      storage/myisam/ft_eval.c
      storage/myisam/ha_myisam.cc
      storage/myisam/mi_changed.c
      storage/myisam/mi_check.c
      storage/myisam/mi_close.c
      storage/myisam/mi_create.c
      storage/myisam/mi_dbug.c
      storage/myisam/mi_delete.c
      storage/myisam/mi_delete_all.c
      storage/myisam/mi_dynrec.c
      storage/myisam/mi_info.c
      storage/myisam/mi_locking.c
      storage/myisam/mi_log.c
      storage/myisam/mi_open.c
      storage/myisam/mi_packrec.c
      storage/myisam/mi_panic.c
      storage/myisam/mi_rsame.c
      storage/myisam/mi_statrec.c
      storage/myisam/mi_test1.c
      storage/myisam/mi_test2.c
      storage/myisam/mi_test3.c
      storage/myisam/mi_update.c
      storage/myisam/mi_write.c
      storage/myisam/myisamchk.c
      storage/myisam/myisamlog.c
      storage/myisam/myisampack.c
      storage/myisam/sort.c
      storage/myisammrg/myrg_close.c
      storage/myisammrg/myrg_create.c
      storage/myisammrg/myrg_open.c
      strings/str_test.c
      tests/thread_test.c
=== modified file 'client/mysqladmin.cc'
--- a/client/mysqladmin.cc	2009-11-11 16:22:27 +0000
+++ b/client/mysqladmin.cc	2009-11-24 13:54:59 +0000
@@ -325,8 +325,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);

=== modified file 'client/mysqldump.c'
--- a/client/mysqldump.c	2009-11-04 13:31:03 +0000
+++ b/client/mysqldump.c	2009-11-24 13:54:59 +0000
@@ -2001,7 +2001,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);
 }
 
@@ -2204,7 +2204,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);
 }
 
@@ -4086,7 +4086,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");
@@ -4160,7 +4160,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 */
 
@@ -4332,7 +4332,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 */
 

=== modified file 'client/mysqlimport.c'
--- a/client/mysqlimport.c	2009-10-21 12:59:47 +0000
+++ b/client/mysqlimport.c	2009-11-24 13:54:59 +0000
@@ -610,8 +610,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 */
     {
@@ -650,8 +650,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

=== modified file 'client/mysqlslap.c'
--- a/client/mysqlslap.c	2009-10-14 08:25:39 +0000
+++ b/client/mysqlslap.c	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'client/mysqltest.cc'
--- a/client/mysqltest.cc	2009-11-19 23:48:08 +0000
+++ b/client/mysqltest.cc	2009-11-24 13:54:59 +0000
@@ -696,12 +696,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;
@@ -9063,7 +9063,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 */
@@ -9534,7 +9534,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 */

=== modified file 'client/sql_string.cc'
--- a/client/sql_string.cc	2009-11-11 20:19:41 +0000
+++ b/client/sql_string.cc	2009-11-24 13:54:59 +0000
@@ -130,7 +130,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;

=== modified file 'extra/comp_err.c'
--- a/extra/comp_err.c	2009-10-15 12:23:43 +0000
+++ b/extra/comp_err.c	2009-11-24 13:54:59 +0000
@@ -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

=== modified file 'extra/replace.c'
--- a/extra/replace.c	2008-02-18 22:29:39 +0000
+++ b/extra/replace.c	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'include/my_alarm.h'
--- a/include/my_alarm.h	2006-12-23 19:17:15 +0000
+++ b/include/my_alarm.h	2009-11-24 13:54:59 +0000
@@ -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

=== modified file 'include/my_global.h'
--- a/include/my_global.h	2009-10-30 18:13:58 +0000
+++ b/include/my_global.h	2009-11-24 13:54:59 +0000
@@ -542,17 +542,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

=== modified file 'libmysql/libmysql.c'
--- a/libmysql/libmysql.c	2009-11-19 23:48:08 +0000
+++ b/libmysql/libmysql.c	2009-11-24 13:54:59 +0000
@@ -556,7 +556,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=

=== modified file 'mysys/errors.c'
--- a/mysys/errors.c	2009-10-15 12:23:43 +0000
+++ b/mysys/errors.c	2009-11-24 13:54:59 +0000
@@ -104,7 +104,7 @@ void wait_for_free_space(const char *fil
                     MYF(ME_BELL | ME_NOREFRESH),
                     MY_WAIT_FOR_USER_TO_FIX_PANIC,
                     MY_WAIT_GIVE_USER_A_MESSAGE * 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);
 }
 
 const char **get_global_errmsgs()

=== modified file 'mysys/hash.c'
--- a/mysys/hash.c	2009-09-17 15:25:52 +0000
+++ b/mysys/hash.c	2009-11-24 13:54:59 +0000
@@ -541,7 +541,7 @@ my_bool my_hash_delete(HASH *hash, uchar
   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);

=== modified file 'mysys/mf_iocache2.c'
--- a/mysys/mf_iocache2.c	2009-02-13 16:41:47 +0000
+++ b/mysys/mf_iocache2.c	2009-11-24 13:54:59 +0000
@@ -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)));

=== modified file 'mysys/mf_loadpath.c'
--- a/mysys/mf_loadpath.c	2007-05-10 09:59:39 +0000
+++ b/mysys/mf_loadpath.c	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'mysys/mf_path.c'
--- a/mysys/mf_path.c	2007-07-30 08:33:50 +0000
+++ b/mysys/mf_path.c	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'mysys/my_append.c'
--- a/mysys/my_append.c	2009-02-13 16:41:47 +0000
+++ b/mysys/my_append.c	2009-11-24 13:54:59 +0000

@@ -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);
 }

=== modified file 'mysys/my_clock.c'
--- a/mysys/my_clock.c	2006-12-23 19:20:40 +0000
+++ b/mysys/my_clock.c	2009-11-24 13:54:59 +0000

@@ -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();

=== modified file 'mysys/my_copy.c'
--- a/mysys/my_copy.c	2009-09-03 12:29:25 +0000
+++ b/mysys/my_copy.c	2009-11-24 13:54:59 +0000
@@ -112,19 +112,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 */

=== modified file 'mysys/my_fstream.c'
--- a/mysys/my_fstream.c	2009-09-11 20:26:35 +0000
+++ b/mysys/my_fstream.c	2009-11-24 13:54:59 +0000
@@ -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
@@ -133,7 +133,7 @@ size_t my_fwrite(FILE *stream, const uch
       {
         wait_for_free_space("[stream]", errors);
         errors++;
-        VOID(my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0)));
+        (void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
         continue;
       }
 #endif

=== modified file 'mysys/my_getwd.c'
--- a/mysys/my_getwd.c	2009-02-13 16:41:47 +0000
+++ b/mysys/my_getwd.c	2009-11-24 13:54:59 +0000
@@ -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)

=== modified file 'mysys/my_lib.c'
--- a/mysys/my_lib.c	2009-09-11 20:26:35 +0000
+++ b/mysys/my_lib.c	2009-11-24 13:54:59 +0000
@@ -159,8 +159,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;
     }
@@ -266,7 +266,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 */
@@ -282,13 +282,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);
       }
     }
@@ -296,13 +296,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 */
@@ -323,7 +323,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));
@@ -331,13 +331,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;

=== modified file 'mysys/my_lockmem.c'
--- a/mysys/my_lockmem.c	2007-05-10 09:59:39 +0000
+++ b/mysys/my_lockmem.c	2009-11-24 13:54:59 +0000
@@ -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;
     }

=== modified file 'mysys/my_pthread.c'
--- a/mysys/my_pthread.c	2009-11-23 16:57:31 +0000
+++ b/mysys/my_pthread.c	2009-11-24 13:54:59 +0000
@@ -30,6 +30,7 @@
 #endif
 
 uint thd_lib_detected= 0;
+
 /* To allow use of pthread_getspecific with two arguments */
 
 #ifdef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC
@@ -267,7 +268,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);
 }
 
@@ -350,7 +351,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;
 }

=== modified file 'mysys/my_redel.c'
--- a/mysys/my_redel.c	2009-09-02 15:45:33 +0000
+++ b/mysys/my_redel.c	2009-11-24 13:54:59 +0000
@@ -89,7 +89,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)
@@ -107,7 +107,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)
@@ -115,7 +115,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

=== modified file 'mysys/stacktrace.c'
--- a/mysys/stacktrace.c	2008-09-16 13:23:07 +0000
+++ b/mysys/stacktrace.c	2009-11-24 13:54:59 +0000
@@ -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 <my_stacktrace.h>
 

=== modified file 'mysys/thr_alarm.c'
--- a/mysys/thr_alarm.c	2009-11-23 16:57:31 +0000
+++ b/mysys/thr_alarm.c	2009-11-24 13:54:59 +0000
@@ -772,7 +772,7 @@ static void *test_thread(void *arg)
 		break;
 	      continue;
 	    }
-	    VOID(getchar());			/* Somebody was playing */
+	    (void) getchar();			/* Somebody was playing */
 	  }
 	}
       }
@@ -784,7 +784,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;
@@ -813,7 +813,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 */
@@ -904,7 +904,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);
@@ -913,10 +913,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);
@@ -944,7 +944,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");

=== modified file 'mysys/thr_lock.c'
--- a/mysys/thr_lock.c	2009-10-26 19:38:03 +0000
+++ b/mysys/thr_lock.c	2009-11-24 13:54:59 +0000
@@ -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;
@@ -522,7 +522,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));
@@ -794,7 +794,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)
@@ -904,7 +904,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 ||
@@ -955,7 +955,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);
@@ -1526,7 +1526,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))
@@ -1544,7 +1544,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);
@@ -1684,7 +1684,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;
@@ -1745,7 +1745,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++)
   {

=== modified file 'sql/derror.cc'
--- a/sql/derror.cc	2009-10-15 12:23:43 +0000
+++ b/sql/derror.cc	2009-11-24 13:54:59 +0000
@@ -143,7 +143,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);
   }
 
@@ -170,7 +170,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:
@@ -187,7 +187,7 @@ err:
   }
   sql_print_error(errmsg, name);
   if (file != FERR)
-    VOID(my_close(file,MYF(MY_WME)));
+    (void) my_close(file,MYF(MY_WME));
   DBUG_RETURN(1);
 } /* read_texts */
 

=== modified file 'sql/des_key_file.cc'
--- a/sql/des_key_file.cc	2007-10-09 21:56:32 +0000
+++ b/sql/des_key_file.cc	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'sql/discover.cc'
--- a/sql/discover.cc	2007-10-09 21:56:32 +0000
+++ b/sql/discover.cc	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'sql/field.cc'
--- a/sql/field.cc	2009-11-19 23:48:08 +0000
+++ b/sql/field.cc	2009-11-24 13:54:59 +0000
@@ -4200,7 +4200,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++='-';
@@ -4559,7 +4559,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++='-';

=== modified file 'sql/filesort.cc'
--- a/sql/filesort.cc	2009-02-17 12:24:09 +0000
+++ b/sql/filesort.cc	2009-11-24 13:54:59 +0000
@@ -1318,7 +1318,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 */
         }

=== modified file 'sql/ha_ndbcluster.cc'
--- a/sql/ha_ndbcluster.cc	2009-11-10 07:31:33 +0000
+++ b/sql/ha_ndbcluster.cc	2009-11-24 13:54:59 +0000
@@ -6904,7 +6904,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();
@@ -6914,7 +6914,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);      
 }

=== modified file 'sql/ha_partition.cc'
--- a/sql/ha_partition.cc	2009-11-19 23:48:08 +0000
+++ b/sql/ha_partition.cc	2009-11-24 13:54:59 +0000
@@ -641,7 +641,7 @@ int ha_partition::drop_partitions(const 
         part_elem->part_state= PART_IS_DROPPED;
     }
   } while (++i < num_parts);
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   DBUG_RETURN(error);
 }
 
@@ -739,7 +739,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
@@ -791,7 +791,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,
@@ -822,7 +822,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,
@@ -840,7 +840,7 @@ int ha_partition::rename_partitions(cons
       }
     }
   } while (++i < num_parts);
-  VOID(sync_ddl_log());
+  (void) sync_ddl_log();
   DBUG_RETURN(error);
 }
 
@@ -1295,7 +1295,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);
 }
 
@@ -2210,7 +2210,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;
@@ -2396,7 +2396,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;
 
@@ -2418,7 +2418,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;
   
@@ -2443,7 +2443,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);
 }
 
@@ -5844,9 +5844,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;
 }
 
@@ -5870,7 +5870,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;
 }
 
@@ -6675,7 +6675,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);
     }

=== modified file 'sql/handler.cc'
--- a/sql/handler.cc	2009-11-23 13:09:39 +0000
+++ b/sql/handler.cc	2009-11-24 13:54:59 +0000
@@ -3014,7 +3014,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);
 }
 
@@ -3647,7 +3647,7 @@ int ha_create_table(THD *thd, const char
   name= get_canonical_filename(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);
@@ -3718,7 +3718,7 @@ int ha_create_table_from_engine(THD* thd
 
   get_canonical_filename(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);
 }

=== modified file 'sql/hostname.cc'
--- a/sql/hostname.cc	2009-10-14 16:37:38 +0000
+++ b/sql/hostname.cc	2009-11-24 13:54:59 +0000
@@ -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));

=== modified file 'sql/init.cc'
--- a/sql/init.cc	2008-04-03 17:14:57 +0000
+++ b/sql/init.cc	2009-11-24 13:54:59 +0000
@@ -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;

=== modified file 'sql/item.cc'
--- a/sql/item.cc	2009-11-06 14:20:27 +0000
+++ b/sql/item.cc	2009-11-24 13:54:59 +0000
@@ -1196,7 +1196,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);
 }
 

=== modified file 'sql/item_cmpfunc.cc'
--- a/sql/item_cmpfunc.cc	2009-11-19 23:48:08 +0000
+++ b/sql/item_cmpfunc.cc	2009-11-24 13:54:59 +0000
@@ -4187,7 +4187,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);
   }
 }
 

=== modified file 'sql/item_strfunc.cc'
--- a/sql/item_strfunc.cc	2009-10-05 15:06:04 +0000
+++ b/sql/item_strfunc.cc	2009-11-24 13:54:59 +0000
@@ -465,18 +465,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
   {
@@ -566,9 +566,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
   {

=== modified file 'sql/lock.cc'
--- a/sql/lock.cc	2009-11-20 19:51:12 +0000
+++ b/sql/lock.cc	2009-11-24 13:54:59 +0000
@@ -325,7 +325,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);
       reset_lock_data_and_free(&sql_lock);
       my_error(rc, MYF(0));
       break;
@@ -357,7 +357,7 @@ MYSQL_LOCK *mysql_lock_tables(THD *thd, 
         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);
 
     /*
       If thr_multi_lock fails it resets lock type for tables, which
@@ -433,7 +433,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;
 }
@@ -497,7 +497,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 */
@@ -978,7 +978,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))
@@ -1622,8 +1622,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);
 }
 
 /**

=== modified file 'sql/log.cc'
--- a/sql/log.cc	2009-11-23 13:09:39 +0000
+++ b/sql/log.cc	2009-11-24 13:54:59 +0000
@@ -2909,7 +2909,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;
@@ -2989,7 +2989,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);
@@ -4084,7 +4084,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 */
@@ -4546,7 +4546,7 @@ bool MYSQL_BIN_LOG::write(THD *thd, IO_C
                           bool incident)
 {
   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);
@@ -4635,7 +4635,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);
 
@@ -4645,7 +4645,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);
 }
 
@@ -4865,7 +4865,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];
     /*
@@ -4912,7 +4912,7 @@ bool flush_error_log()
    else
      result= 1;
 #endif
-    VOID(pthread_mutex_unlock(&LOCK_error_log));
+    pthread_mutex_unlock(&LOCK_error_log);
   }
    return result;
 }
@@ -4987,7 +4987,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);
@@ -5006,7 +5006,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;
 }
 

=== modified file 'sql/log_event.cc'
--- a/sql/log_event.cc	2009-11-23 13:09:39 +0000
+++ b/sql/log_event.cc	2009-11-24 13:54:59 +0000
@@ -3056,9 +3056,9 @@ int Query_log_event::do_apply_event(Rela
   {
     thd->set_time((time_t)when);
     thd->set_query((char*)query_arg, q_len_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()));
 
@@ -4580,9 +4580,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);
     thd->warning_info->opt_clear_warning_info(thd->query_id);
 
     TABLE_LIST tables;

=== modified file 'sql/mysqld.cc'
--- a/sql/mysqld.cc	2009-11-23 16:57:31 +0000
+++ b/sql/mysqld.cc	2009-11-24 13:54:59 +0000
@@ -1039,14 +1039,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;
@@ -1054,16 +1054,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
@@ -5175,7 +5175,7 @@ void handle_connections_sockets()
     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,

=== modified file 'sql/opt_range.h'
--- a/sql/opt_range.h	2009-09-28 07:21:25 +0000
+++ b/sql/opt_range.h	2009-11-24 13:54:59 +0000
@@ -730,7 +730,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; }

=== modified file 'sql/protocol.cc'
--- a/sql/protocol.cc	2009-10-23 11:22:21 +0000

+++ b/sql/protocol.cc	2009-11-24 13:54:59 +0000
@@ -247,6 +247,7 @@ net_send_ok(THD *thd,
   if (!error)
     error= net_flush(net);
 
+
   thd->stmt_da->can_overwrite_status= FALSE;
   DBUG_PRINT("info", ("OK sent, so no more error sending allowed"));
 
@@ -406,6 +407,7 @@ bool net_send_error_packet(THD *thd, uin
     buff[2]= '#';
     pos= (uchar*) strmov((char*) buff+3, sqlstate);
   }
+
   converted_err_len= convert_error_message((char*)converted_err,
                                            sizeof(converted_err),
                                            thd->variables.character_set_results,
@@ -414,6 +416,7 @@ bool net_send_error_packet(THD *thd, uin
   length= (uint) (strmake((char*) pos, (char*)converted_err, MYSQL_ERRMSG_SIZE) -
                   (char*) buff);
   err= (char*) buff;
+
   DBUG_RETURN(net_write_command(net,(uchar) 255, (uchar*) "", 0, (uchar*) err,
                                 length));
 }

=== modified file 'sql/records.cc'
--- a/sql/records.cc	2009-11-06 16:13:33 +0000
+++ b/sql/records.cc	2009-11-24 13:54:59 +0000
@@ -178,7 +178,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)
   {
@@ -266,8 +266,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 && 

=== modified file 'sql/sp_head.cc'
--- a/sql/sp_head.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sp_head.cc	2009-11-24 13:54:59 +0000
@@ -1769,9 +1769,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;
@@ -2736,9 +2736,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)
   {

=== modified file 'sql/sp_pcontext.cc'
--- a/sql/sp_pcontext.cc	2009-09-10 09:18:29 +0000
+++ b/sql/sp_pcontext.cc	2009-11-24 13:54:59 +0000
@@ -63,21 +63,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();
 
@@ -91,21 +91,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();
 

=== modified file 'sql/sql_acl.cc'
--- a/sql/sql_acl.cc	2009-11-06 14:20:27 +0000
+++ b/sql/sql_acl.cc	2009-11-24 13:54:59 +0000
@@ -326,7 +326,7 @@ static my_bool acl_load(THD *thd, TABLE_
   init_read_record(&read_record_info,thd,table= tables[0].table,NULL,1,0, 
                    FALSE);
   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,FALSE);
   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,FALSE);
   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);
@@ -706,7 +706,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;
@@ -733,7 +733,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);
@@ -885,7 +885,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,
@@ -1064,7 +1064,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);
 }
 
@@ -1111,7 +1111,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;
@@ -1165,7 +1165,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);
 }
 
@@ -1254,7 +1254,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 */
@@ -1320,7 +1320,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);
 }
@@ -1344,7 +1344,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)
   {
@@ -1356,7 +1356,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);
   }
@@ -1410,7 +1410,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);
 }
@@ -1426,10 +1426,11 @@ 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(my_hash_init(&acl_check_hosts,system_charset_info,acl_users.elements,0,0,
-                    (my_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) my_hash_init(&acl_check_hosts,system_charset_info,
+                      acl_users.elements, 0, 0,
+                      (my_hash_get_key) check_get_key, 0, 0);
   if (!allow_all_hosts)
   {
     for (uint i=0 ; i < acl_users.elements ; i++)
@@ -1491,12 +1492,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 && my_hash_search(&acl_check_hosts,(uchar*) host,strlen(host))) ||
       (ip && my_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++)
@@ -1504,11 +1505,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
 }
 
@@ -1622,11 +1623,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;
   }
@@ -1638,12 +1639,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())
   {
@@ -1684,9 +1685,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;
 }
 
@@ -3443,7 +3444,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;
@@ -3475,7 +3476,7 @@ bool mysql_grant(THD *thd, const char *d
       }
     }
   }
-  VOID(pthread_mutex_unlock(&acl_cache->lock));
+  pthread_mutex_unlock(&acl_cache->lock);
 
   if (!result)
   {
@@ -4635,12 +4636,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),
@@ -4658,7 +4659,7 @@ bool mysql_show_grants(THD *thd,LEX_USER
   if (protocol->send_result_set_metadata(&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);
@@ -4969,7 +4970,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);
@@ -5767,7 +5768,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++))
   {
@@ -5797,7 +5798,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());
@@ -5849,7 +5850,7 @@ bool mysql_drop_user(THD *thd, List <LEX
   thd->variables.sql_mode&= ~MODE_PAD_CHAR_TO_FULL_LENGTH;
 
   rw_wrlock(&LOCK_grant);
-  VOID(pthread_mutex_lock(&acl_cache->lock));
+  pthread_mutex_lock(&acl_cache->lock);
 
   while ((tmp_user_name= user_list++))
   {
@@ -5870,7 +5871,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());
@@ -5921,7 +5922,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++))
   {
@@ -5955,7 +5956,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());
@@ -6002,7 +6003,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);
@@ -6141,7 +6142,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());
 
@@ -6250,7 +6251,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
@@ -6288,7 +6289,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);
 
@@ -6329,7 +6330,7 @@ bool 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;
@@ -6340,11 +6341,11 @@ bool 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();

=== modified file 'sql/sql_base.cc'
--- a/sql/sql_base.cc	2009-11-06 14:20:27 +0000
+++ b/sql/sql_base.cc	2009-11-24 13:54:59 +0000
@@ -438,7 +438,7 @@ found:
          oldest_unused_share->next)
   {
     pthread_mutex_lock(&oldest_unused_share->mutex);
-    VOID(my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
+    my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
   }
 
   DBUG_PRINT("exit", ("share: 0x%lx  ref_count: %u",
@@ -714,7 +714,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;
@@ -767,7 +767,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);
 }
 
@@ -787,7 +787,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;
 }
 
@@ -864,7 +864,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
@@ -874,14 +874,14 @@ bool close_cached_tables(THD *thd, TABLE
       if (my_hash_delete(&open_cache,(uchar*) unused_tables))
 	printf("Warning: Couldn't delete open table from hash\n");
 #else
-      VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
+      (void) my_hash_delete(&open_cache,(uchar*) unused_tables);
 #endif
     }
     /* Free table shares */
     while (oldest_unused_share->next)
     {
       pthread_mutex_lock(&oldest_unused_share->mutex);
-      VOID(my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
+      (void) my_hash_delete(&table_def_cache, (uchar*) oldest_unused_share);
     }
     DBUG_PRINT("tcache", ("incremented global refresh_version to: %lu",
                           refresh_version));
@@ -1019,7 +1019,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);
@@ -1049,7 +1049,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++)
   {
@@ -1082,7 +1082,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)
   {
@@ -1199,7 +1199,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));
 
@@ -1209,7 +1209,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(my_hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
+    my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
   check_unused();
   if (found_old_table)
   {
@@ -1217,7 +1217,7 @@ static void close_open_tables(THD *thd)
     broadcast_refresh();
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 }
 
 
@@ -1395,7 +1395,7 @@ bool close_thread_table(THD *thd, TABLE 
   if (table->needs_reopen_or_name_lock() ||
       thd->version != refresh_version || !table->db_stat)
   {
-    VOID(my_hash_delete(&open_cache,(uchar*) table));
+    my_hash_delete(&open_cache,(uchar*) table);
     found_old_table=1;
   }
   else
@@ -2099,7 +2099,7 @@ void unlink_open_table(THD *thd, TABLE *
       /* Remove table from open_tables list. */
       *prev= list->next;
       /* Close table. */
-      VOID(my_hash_delete(&open_cache,(uchar*) list)); // Close table
+      my_hash_delete(&open_cache,(uchar*) list); // Close table
     }
     else
     {
@@ -2141,14 +2141,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);
   }
 }
 
@@ -2403,24 +2403,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 (my_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);
 }
 
@@ -2677,15 +2677,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);
       }
     }
     /*
@@ -2718,7 +2718,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,
@@ -2736,7 +2736,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);
   }
 
@@ -2802,7 +2802,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);
       }
@@ -2843,7 +2843,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.
@@ -2876,7 +2876,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(my_hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
+      my_hash_delete(&open_cache,(uchar*) unused_tables); /* purecov: tested */
 
     if (table_list->create)
     {
@@ -2884,7 +2884,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);
       }
 
@@ -2895,7 +2895,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);
         }
         /*
@@ -2906,7 +2906,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. */
@@ -2915,7 +2915,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);
     }
 
@@ -2924,7 +2924,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)
@@ -2937,18 +2937,18 @@ TABLE *open_table(THD *thd, TABLE_LIST *
         table_list->view= (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 */
@@ -3087,13 +3087,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();
@@ -3334,7 +3334,7 @@ bool reopen_tables(THD *thd, bool get_lo
       */
       if (table->child_l || table->parent)
         detach_merge_children(table, TRUE);
-      VOID(my_hash_delete(&open_cache,(uchar*) table));
+      my_hash_delete(&open_cache,(uchar*) table);
       error=1;
     }
     else
@@ -3363,7 +3363,7 @@ bool reopen_tables(THD *thd, bool get_lo
   {
     while (err_tables)
     {
-      VOID(my_hash_delete(&open_cache, (uchar*) err_tables));
+      my_hash_delete(&open_cache, (uchar*) err_tables);
       err_tables= err_tables->next;
     }
   }
@@ -3645,7 +3645,7 @@ TABLE *drop_locked_tables(THD *thd,const
       else
       {
         /* We already have a name lock, remove copy */
-        VOID(my_hash_delete(&open_cache,(uchar*) table));
+        my_hash_delete(&open_cache,(uchar*) table);
       }
     }
     else
@@ -4252,7 +4252,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));
@@ -8354,7 +8354,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);
@@ -8396,7 +8396,7 @@ void remove_db_from_cache(const char *db
     }
   }
   while (unused_tables && !unused_tables->s->version)
-    VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
+    my_hash_delete(&open_cache,(uchar*) unused_tables);
 }
 
 
@@ -8520,7 +8520,7 @@ bool remove_table_from_cache(THD *thd, c
       }
     }
     while (unused_tables && !unused_tables->s->version)
-      VOID(my_hash_delete(&open_cache,(uchar*) unused_tables));
+      my_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 */
@@ -8533,7 +8533,7 @@ bool remove_table_from_cache(THD *thd, c
       if (share->ref_count == 0)
       {
         pthread_mutex_lock(&share->mutex);
-        VOID(my_hash_delete(&table_def_cache, (uchar*) share));
+        my_hash_delete(&table_def_cache, (uchar*) share);
       }
     }
 
@@ -8710,12 +8710,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);
 }
 
@@ -8737,10 +8737,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);
@@ -8779,7 +8779,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*) my_hash_first(&open_cache,(uchar*) key,key_length,
                                      &state) ;
@@ -8837,7 +8837,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;
 }
 

=== modified file 'sql/sql_cache.cc'
--- a/sql/sql_cache.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sql_cache.cc	2009-11-24 13:54:59 +0000
@@ -2126,8 +2126,8 @@ ulong Query_cache::init_cache()
 
   DUMP(this);
 
-  VOID(my_hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
-                    query_cache_query_get_key, 0, 0));
+  (void) my_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 
@@ -2137,8 +2137,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(my_hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
-                    query_cache_table_get_key, 0, 0));
+  (void) my_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
@@ -2148,10 +2148,11 @@ ulong Query_cache::init_cache()
     file system) and so should use case insensitive collation for
     comparison.
   */
-  VOID(my_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));
+  (void) my_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);
 #endif
 
   queries_in_cache = 0;

=== modified file 'sql/sql_connect.cc'
--- a/sql/sql_connect.cc	2009-11-02 11:10:04 +0000
+++ b/sql/sql_connect.cc	2009-11-24 13:54:59 +0000
@@ -410,7 +410,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

=== modified file 'sql/sql_db.cc'
--- a/sql/sql_db.cc	2009-11-05 20:28:35 +0000
+++ b/sql/sql_db.cc	2009-11-24 13:54:59 +0000
@@ -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) - 1, db, "", "", 0);
@@ -753,7 +753,7 @@ not_silent:
   }
 
 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
@@ -830,7 +830,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);
@@ -882,7 +882,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);
 
   length= build_table_filename(path, sizeof(path) - 1, db, "", "", 0);
   strmov(path+length, MY_DB_OPT_FILE);		// Append db option file name
@@ -1030,7 +1030,7 @@ exit:
   */
   if (thd->db && !strcmp(thd->db, db) && error == 0)
     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);
@@ -1143,9 +1143,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 */

=== modified file 'sql/sql_delete.cc'
--- a/sql/sql_delete.cc	2009-11-05 20:28:35 +0000
+++ b/sql/sql_delete.cc	2009-11-24 13:54:59 +0000
@@ -1166,10 +1166,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:
@@ -1184,15 +1184,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);
 

=== modified file 'sql/sql_handler.cc'
--- a/sql/sql_handler.cc	2009-11-02 11:10:04 +0000
+++ b/sql/sql_handler.cc	2009-11-24 13:54:59 +0000
@@ -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)
   {

=== modified file 'sql/sql_insert.cc'
--- a/sql/sql_insert.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sql_insert.cc	2009-11-24 13:54:59 +0000
@@ -1033,7 +1033,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;
@@ -1766,11 +1766,11 @@ 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++;
     delayed_lock= global_system_variables.low_priority_updates ?
                                           TL_WRITE_LOW_PRIORITY : TL_WRITE;
-    VOID(pthread_mutex_unlock(&LOCK_thread_count));
+    pthread_mutex_unlock(&LOCK_thread_count);
   }
   ~Delayed_insert()
   {
@@ -1780,7 +1780,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);
@@ -1789,8 +1789,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 */
@@ -2262,7 +2262,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;
@@ -2287,7 +2287,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
 }
 
 
@@ -3499,7 +3499,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,
@@ -3508,7 +3508,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
       {

=== modified file 'sql/sql_map.cc'
--- a/sql/sql_map.cc	2007-10-23 09:29:20 +0000
+++ b/sql/sql_map.cc	2009-11-24 13:54:59 +0000
@@ -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
 }
 

=== modified file 'sql/sql_parse.cc'
--- a/sql/sql_parse.cc	2009-11-23 16:57:31 +0000
+++ b/sql/sql_parse.cc	2009-11-24 13:54:59 +0000
@@ -983,7 +983,7 @@ 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;
 
   switch( command ) {
@@ -1005,7 +1005,7 @@ bool dispatch_command(enum enum_server_c
 
   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);
 
   /**
     Clear the set of flags that are expected to be cleared at the
@@ -1268,7 +1268,7 @@ bool dispatch_command(enum enum_server_c
                         (char *) thd->security_ctx->host_or_ip);
 
       thd->set_query(beginning_of_next_stmt, length);
-      VOID(pthread_mutex_lock(&LOCK_thread_count));
+      pthread_mutex_lock(&LOCK_thread_count);
       /*
         Count each statement from the client.
       */
@@ -1276,7 +1276,7 @@ bool dispatch_command(enum enum_server_c
       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);
     }
 
@@ -1494,8 +1494,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->stmt_da->disable_status();
 #endif
     break;
@@ -1590,9 +1590,9 @@ bool dispatch_command(enum enum_server_c
   thd_proc_info(thd, "cleaning up");
   thd->set_query(NULL, 0);
   thd->command=COM_SLEEP;
-  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
+  pthread_mutex_lock(&LOCK_thread_count); // For process list
   thread_running--;
-  VOID(pthread_mutex_unlock(&LOCK_thread_count));
+  pthread_mutex_unlock(&LOCK_thread_count);
   thd_proc_info(thd, 0);
   thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
   free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
@@ -7181,7 +7181,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++))
   {
@@ -7193,7 +7193,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)
   {
 

=== modified file 'sql/sql_select.cc'
--- a/sql/sql_select.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sql_select.cc	2009-11-24 13:54:59 +0000
@@ -3954,7 +3954,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;
@@ -9189,7 +9189,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)
@@ -11055,7 +11055,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)
@@ -12401,7 +12401,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)
     {
@@ -12664,7 +12664,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)
     {

=== modified file 'sql/sql_servers.cc'
--- a/sql/sql_servers.cc	2009-11-10 20:31:28 +0000
+++ b/sql/sql_servers.cc	2009-11-24 13:54:59 +0000
@@ -664,8 +664,8 @@ delete_server_record_in_cache(LEX_SERVER
                      server->server_name,
                      server->server_name_length));
 
-  VOID(my_hash_delete(&servers_cache, (uchar*) server));
-  
+  my_hash_delete(&servers_cache, (uchar*) server);
+
   error= 0;
 
 end:
@@ -771,7 +771,7 @@ int update_server_record_in_cache(FOREIG
   /*
     delete the existing server struct from the server cache
   */
-  VOID(my_hash_delete(&servers_cache, (uchar*)existing));
+  my_hash_delete(&servers_cache, (uchar*)existing);
 
   /*
     Insert the altered server struct into the server cache

=== modified file 'sql/sql_show.cc'
--- a/sql/sql_show.cc	2009-11-20 19:15:50 +0000
+++ b/sql/sql_show.cc	2009-11-24 13:54:59 +0000
@@ -495,7 +495,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);
 }
@@ -936,7 +936,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);
 
@@ -1755,7 +1755,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);
@@ -1808,7 +1808,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);
@@ -1847,7 +1847,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)
   {
@@ -1922,13 +1922,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);
 }
 
@@ -2285,7 +2285,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;
@@ -2297,7 +2297,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;
 }
 
@@ -2852,9 +2852,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;
   }

=== modified file 'sql/sql_string.cc'
--- a/sql/sql_string.cc	2009-11-11 20:19:41 +0000
+++ b/sql/sql_string.cc	2009-11-24 13:54:59 +0000
@@ -120,7 +120,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;

=== modified file 'sql/sql_table.cc'
--- a/sql/sql_table.cc	2009-11-20 20:12:57 +0000
+++ b/sql/sql_table.cc	2009-11-24 13:54:59 +0000
@@ -493,9 +493,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 */
@@ -695,7 +695,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);
 }
 
@@ -763,7 +763,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);
 }
@@ -845,7 +845,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);
   }
@@ -922,7 +922,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
@@ -935,7 +935,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;
@@ -959,7 +959,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
@@ -970,7 +970,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;
     }
@@ -1099,7 +1099,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;
   }
@@ -1156,7 +1156,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
@@ -1180,7 +1180,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())
@@ -1372,7 +1372,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;
@@ -1432,7 +1432,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 */
@@ -1474,7 +1474,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;
 }
@@ -1653,7 +1653,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,
@@ -1706,11 +1706,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
   }
 
@@ -3870,7 +3870,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))
@@ -3987,7 +3987,7 @@ bool mysql_create_table_no_lock(THD *thd
   write_create_table_bin_log(thd, create_info, internal_tmp_table);
   error= FALSE;
 unlock_and_end:
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
 
 err:
   thd_proc_info(thd, "After create");
@@ -4241,7 +4241,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 */
 
@@ -4323,7 +4323,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) - 1));
+    tablename_to_filename(table->table_name, uname, sizeof(uname) - 1);
 
     if (fn_format_relative_to_data_home(src_path, uname, backup_dir, reg_ext))
       DBUG_RETURN(-1); // protect buffer overflow
@@ -5336,12 +5336,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;
     }
   }
@@ -5351,7 +5351,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;
   }
 
@@ -5380,7 +5380,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)
   {
@@ -5454,13 +5454,13 @@ binlog:
           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);
 
         int result __attribute__((unused))=
           store_create_info(thd, table, &query,
@@ -6563,7 +6563,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;
@@ -6746,17 +6746,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;
@@ -6773,7 +6773,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
@@ -6812,8 +6812,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;
         }
       }
@@ -6839,7 +6839,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);
@@ -7200,9 +7200,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);
     thd_proc_info(thd, "manage keys");
     alter_table_manage_keys(table, table->file->indexes_are_disabled(),
                             alter_info->keys_onoff);
@@ -7332,11 +7332,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;
   }
 
@@ -7391,7 +7391,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) ||
@@ -7404,10 +7404,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)
@@ -7459,7 +7459,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)
   {
@@ -7469,7 +7469,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");
 
@@ -7537,10 +7537,8 @@ err1:
     close_temporary_table(thd, new_table, 1, 1);
   }
   else
-    VOID(quick_rm_table(new_db_type, new_db, tmp_name, 
-                        create_info->frm_only
-                        ? FN_IS_TMP | FRM_ONLY
-                        : FN_IS_TMP));
+    (void) quick_rm_table(new_db_type, new_db, tmp_name,
+                          create_info->frm_only ? FN_IS_TMP | FRM_ONLY : FN_IS_TMP);
 
 err:
   /*
@@ -7593,7 +7591,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 */

=== modified file 'sql/sql_test.cc'
--- a/sql/sql_test.cc	2009-10-14 16:37:38 +0000
+++ b/sql/sql_test.cc	2009-11-24 13:54:59 +0000
@@ -80,7 +80,7 @@ void print_cached_tables(void)
   compile_time_assert(TL_WRITE_ONLY+1 == array_elements(lock_descriptions));
 
   /* 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++)
@@ -116,7 +116,7 @@ void print_cached_tables(void)
   if (my_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;
 }
@@ -155,7 +155,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;
@@ -169,7 +169,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;
@@ -195,17 +195,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;
@@ -355,7 +355,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);
     }
   }
 }
@@ -380,13 +380,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,
@@ -395,9 +395,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);
@@ -462,7 +462,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);

=== modified file 'sql/sql_trigger.cc'
--- a/sql/sql_trigger.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sql_trigger.cc	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'sql/sql_update.cc'
--- a/sql/sql_update.cc	2009-11-19 23:48:08 +0000
+++ b/sql/sql_update.cc	2009-11-24 13:54:59 +0000
@@ -782,7 +782,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.
@@ -1857,7 +1857,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)

=== modified file 'sql/sql_view.cc'
--- a/sql/sql_view.cc	2009-11-05 20:28:35 +0000
+++ b/sql/sql_view.cc	2009-11-24 13:54:59 +0000
@@ -620,7 +620,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())
@@ -666,7 +666,7 @@ bool mysql_create_view(THD *thd, TABLE_L
                       buff.ptr(), buff.length(), FALSE, FALSE, errcode);
   }
 
-  VOID(pthread_mutex_unlock(&LOCK_open));
+  pthread_mutex_unlock(&LOCK_open);
   if (mode != VIEW_CREATE_NEW)
     query_cache_invalidate3(thd, view, 0);
   start_waiting_global_read_lock(thd);
@@ -1579,7 +1579,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;
@@ -1656,7 +1656,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)
   {

=== modified file 'sql/table.cc'
--- a/sql/table.cc	2009-11-02 11:10:04 +0000
+++ b/sql/table.cc	2009-11-24 13:54:59 +0000
@@ -753,7 +753,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)
@@ -1030,7 +1030,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
@@ -2059,7 +2059,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),
@@ -2138,17 +2138,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 */
@@ -2164,11 +2164,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))) ||
@@ -2177,7 +2177,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 */
 
@@ -2531,8 +2531,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);
       }
     }
@@ -2569,8 +2569,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)));
 }
 

=== modified file 'sql/tztime.cc'
--- a/sql/tztime.cc	2009-11-10 20:31:28 +0000
+++ b/sql/tztime.cc	2009-11-24 13:54:59 +0000
@@ -1595,7 +1595,7 @@ my_tz_init(THD *org_thd, const char *def
     goto end;
   }
   init_sql_alloc(&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 */
@@ -1773,7 +1773,7 @@ void my_tz_free()
   if (tz_inited)
   {
     tz_inited= 0;
-    VOID(pthread_mutex_destroy(&tz_LOCK));
+    pthread_mutex_destroy(&tz_LOCK);
     my_hash_free(&offset_tzs);
     my_hash_free(&tz_names);
     free_root(&tz_storage, MYF(0));
@@ -2262,7 +2262,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))
   {
@@ -2305,7 +2305,7 @@ my_tz_find(THD *thd, const String *name)
     }
   }
 
-  VOID(pthread_mutex_unlock(&tz_LOCK));
+  pthread_mutex_unlock(&tz_LOCK);
 
   DBUG_RETURN(result_tz);
 }

=== modified file 'sql/udf_example.c'
--- a/sql/udf_example.c	2009-10-14 08:25:39 +0000
+++ b/sql/udf_example.c	2009-11-24 13:54:59 +0000
@@ -767,14 +767,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);
@@ -871,14 +871,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;

=== modified file 'sql/uniques.cc'
--- a/sql/uniques.cc	2009-06-17 14:56:44 +0000
+++ b/sql/uniques.cc	2009-11-24 13:54:59 +0000
@@ -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));
 }
 
 

=== modified file 'sql/unireg.cc'
--- a/sql/unireg.cc	2009-10-15 10:17:32 +0000
+++ b/sql/unireg.cc	2009-11-24 13:54:59 +0000
@@ -199,7 +199,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));
@@ -262,9 +262,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))
@@ -310,7 +310,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))
@@ -324,7 +324,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);
@@ -371,7 +371,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);
@@ -425,7 +425,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 */

=== modified file 'storage/archive/ha_archive.cc'
--- a/storage/archive/ha_archive.cc	2009-10-23 11:22:21 +0000
+++ b/storage/archive/ha_archive.cc	2009-11-24 13:54:59 +0000
@@ -175,7 +175,7 @@ int archive_db_init(void *p)
   if (my_hash_init(&archive_open_tables, table_alias_charset, 32, 0, 0,
                 (my_hash_get_key) archive_get_key, 0, 0))
   {
-    VOID(pthread_mutex_destroy(&archive_mutex));
+    pthread_mutex_destroy(&archive_mutex);
   }
   else
   {
@@ -199,7 +199,7 @@ error:
 int archive_db_done(void *p)
 {
   my_hash_free(&archive_open_tables);
-  VOID(pthread_mutex_destroy(&archive_mutex));
+  pthread_mutex_destroy(&archive_mutex);
 
   return 0;
 }
@@ -346,7 +346,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
@@ -363,7 +363,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++;
@@ -396,7 +396,7 @@ int ha_archive::free_share()
   {
     my_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
@@ -1493,7 +1493,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.data_file_length= file_stat.st_size;
     stats.create_time= (ulong) file_stat.st_ctime;

=== modified file 'storage/blackhole/ha_blackhole.cc'
--- a/storage/blackhole/ha_blackhole.cc	2009-11-05 20:28:35 +0000
+++ b/storage/blackhole/ha_blackhole.cc	2009-11-24 13:54:59 +0000
@@ -377,7 +377,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) my_hash_init(&blackhole_open_tables, system_charset_info,32,0,0,
                       (my_hash_get_key) blackhole_get_key,
                       (my_hash_free_key) blackhole_free_key, 0);

=== modified file 'storage/csv/ha_tina.cc'
--- a/storage/csv/ha_tina.cc	2009-10-23 11:22:21 +0000
+++ b/storage/csv/ha_tina.cc	2009-11-24 13:54:59 +0000
@@ -110,7 +110,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) my_hash_init(&tina_open_tables,system_charset_info,32,0,0,
                       (my_hash_get_key) tina_get_key,0,0);
   tina_hton->state= SHOW_OPTION_YES;
@@ -236,7 +236,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);
@@ -305,7 +305,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);

=== modified file 'storage/csv/transparent_file.cc'
--- a/storage/csv/transparent_file.cc	2009-03-24 09:02:01 +0000
+++ b/storage/csv/transparent_file.cc	2009-11-24 13:54:59 +0000
@@ -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(my_off_
   if ((lower_bound <= offset) && (((my_off_t) 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)

=== modified file 'storage/example/ha_example.cc'
--- a/storage/example/ha_example.cc	2009-11-05 12:08:37 +0000
+++ b/storage/example/ha_example.cc	2009-11-24 13:54:59 +0000
@@ -132,7 +132,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) my_hash_init(&example_open_tables,system_charset_info,32,0,0,
                       (my_hash_get_key) example_get_key,0,0);
 

=== modified file 'storage/federated/ha_federated.cc'
--- a/storage/federated/ha_federated.cc	2009-10-15 20:56:17 +0000
+++ b/storage/federated/ha_federated.cc	2009-11-24 13:54:59 +0000
@@ -465,7 +465,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);
 }
@@ -484,7 +484,7 @@ error:
 int federated_done(void *p)
 {
   my_hash_free(&federated_open_tables);
-  VOID(pthread_mutex_destroy(&federated_mutex));
+  pthread_mutex_destroy(&federated_mutex);
 
   return 0;
 }
@@ -1562,7 +1562,7 @@ static int free_share(FEDERATED_SHARE *s
   {
     my_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);

=== modified file 'storage/heap/hp_clear.c'
--- a/storage/heap/hp_clear.c	2007-05-10 09:59:39 +0000
+++ b/storage/heap/hp_clear.c	2009-11-24 13:54:59 +0000
@@ -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;

=== modified file 'storage/heap/hp_create.c'
--- a/storage/heap/hp_create.c	2007-07-24 22:58:12 +0000
+++ b/storage/heap/hp_create.c	2009-11-24 13:54:59 +0000
@@ -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));

=== modified file 'storage/heap/hp_test1.c'
--- a/storage/heap/hp_test1.c	2007-08-13 13:11:25 +0000
+++ b/storage/heap/hp_test1.c	2009-11-24 13:54:59 +0000
@@ -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)))
     {

=== modified file 'storage/heap/hp_test2.c'
--- a/storage/heap/hp_test2.c	2009-08-28 16:21:54 +0000
+++ b/storage/heap/hp_test2.c	2009-11-24 13:54:59 +0000
@@ -609,7 +609,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 */
 

=== modified file 'storage/innobase/handler/ha_innodb.cc'
--- a/storage/innobase/handler/ha_innodb.cc	2009-11-23 16:57:31 +0000
+++ b/storage/innobase/handler/ha_innodb.cc	2009-11-24 13:54:59 +0000
@@ -902,7 +902,7 @@ innobase_mysql_prepare_print_arbitrary_t
 /*============================================*/
 {
 	ut_ad(!mutex_own(&kernel_mutex));
-	VOID(pthread_mutex_lock(&LOCK_thread_count));
+	pthread_mutex_lock(&LOCK_thread_count);
 }
 
 /*************************************************************//**
@@ -916,7 +916,7 @@ innobase_mysql_end_print_arbitrary_thd(v
 /*========================================*/
 {
 	ut_ad(!mutex_own(&kernel_mutex));
-	VOID(pthread_mutex_unlock(&LOCK_thread_count));
+	pthread_mutex_unlock(&LOCK_thread_count);
 }
 
 /*************************************************************//**

=== modified file 'storage/myisam/ft_eval.c'
--- a/storage/myisam/ft_eval.c	2007-10-11 15:07:40 +0000
+++ b/storage/myisam/ft_eval.c	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'storage/myisam/ha_myisam.cc'
--- a/storage/myisam/ha_myisam.cc	2009-11-05 09:23:55 +0000
+++ b/storage/myisam/ha_myisam.cc	2009-11-24 13:54:59 +0000
@@ -721,11 +721,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))
@@ -916,8 +916,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))
@@ -959,8 +959,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))

=== modified file 'storage/myisam/mi_changed.c'
--- a/storage/myisam/mi_changed.c	2006-12-31 00:32:21 +0000
+++ b/storage/myisam/mi_changed.c	2009-11-24 13:54:59 +0000
@@ -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));

=== modified file 'storage/myisam/mi_check.c'
--- a/storage/myisam/mi_check.c	2009-10-27 14:30:02 +0000
+++ b/storage/myisam/mi_check.c	2009-11-24 13:54:59 +0000
@@ -1184,8 +1184,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)
@@ -1222,7 +1222,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 */
@@ -1275,7 +1275,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)
   {
@@ -1551,8 +1551,8 @@ int mi_repair(MI_CHECK *param, register 
   DBUG_ASSERT(param->use_buffers < SIZE_T_MAX);
 
   if (!param->using_global_keycache)
-    VOID(init_key_cache(dflt_key_cache, param->key_cache_block_size,
-                        (size_t) 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,
@@ -1645,8 +1645,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);
       }
@@ -1668,7 +1668,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)))
   {
@@ -1750,9 +1750,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);
@@ -1762,9 +1762,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)
   {
@@ -1991,9 +1991,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))
@@ -2017,9 +2017,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 */
 
@@ -2176,7 +2176,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)) ||
@@ -2486,7 +2486,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)
@@ -2539,7 +2539,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 */
@@ -2561,9 +2561,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) /* Retry with key cache */
         if (unlikely(mi_open_datafile(info, share, name, -1)))
           param->retry_repair= 0; /* Safety */
@@ -2581,7 +2581,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))
   {
@@ -3068,7 +3068,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()
@@ -3076,7 +3076,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 */
@@ -3098,9 +3098,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) /* Retry with key cache */
         if (unlikely(mi_open_datafile(info, share, name, -1)))
           param->retry_repair= 0; /* Safety */
@@ -3120,7 +3120,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))
   {
@@ -3774,7 +3774,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);
@@ -4048,7 +4048,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);
   }
@@ -4327,7 +4327,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;
@@ -4368,7 +4368,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;

=== modified file 'storage/myisam/mi_close.c'
--- a/storage/myisam/mi_close.c	2009-04-06 07:01:17 +0000
+++ b/storage/myisam/mi_close.c	2009-11-24 13:54:59 +0000
@@ -93,13 +93,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

=== modified file 'storage/myisam/mi_create.c'
--- a/storage/myisam/mi_create.c	2009-08-28 16:21:54 +0000
+++ b/storage/myisam/mi_create.c	2009-11-24 13:54:59 +0000
@@ -838,7 +838,7 @@ 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: T´┐Żshould add a call to my_raid_delete() here */
@@ -848,7 +848,7 @@ err:
 			   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),

=== modified file 'storage/myisam/mi_dbug.c'
--- a/storage/myisam/mi_dbug.c	2009-09-30 19:37:52 +0000
+++ b/storage/myisam/mi_dbug.c	2009-11-24 13:54:59 +0000
@@ -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 */
 

=== modified file 'storage/myisam/mi_delete.c'
--- a/storage/myisam/mi_delete.c	2009-08-28 16:21:54 +0000
+++ b/storage/myisam/mi_delete.c	2009-11-24 13:54:59 +0000
@@ -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;

=== modified file 'storage/myisam/mi_delete_all.c'
--- a/storage/myisam/mi_delete_all.c	2008-03-28 15:16:52 +0000
+++ b/storage/myisam/mi_delete_all.c	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'storage/myisam/mi_dynrec.c'
--- a/storage/myisam/mi_dynrec.c	2009-11-10 21:10:30 +0000
+++ b/storage/myisam/mi_dynrec.c	2009-11-24 13:54:59 +0000
@@ -115,7 +115,7 @@ void mi_remap_file(MI_INFO *info, my_off
 {
   if (info->s->file_map)
   {
-    VOID(my_munmap((char*) info->s->file_map,
+    (void) (my_munmap((char*) info->s->file_map,
                    (size_t) info->s->mmaped_length));
     mi_dynmap_file(info, size);
   }
@@ -1515,7 +1515,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;

=== modified file 'storage/myisam/mi_info.c'
--- a/storage/myisam/mi_info.c	2007-04-13 07:44:02 +0000
+++ b/storage/myisam/mi_info.c	2009-11-24 13:54:59 +0000
@@ -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);
   }

=== modified file 'storage/myisam/mi_locking.c'
--- a/storage/myisam/mi_locking.c	2009-09-11 20:26:35 +0000
+++ b/storage/myisam/mi_locking.c	2009-11-24 13:54:59 +0000
@@ -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;
@@ -412,14 +412,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)
@@ -487,7 +487,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;

=== modified file 'storage/myisam/mi_log.c'
--- a/storage/myisam/mi_log.c	2007-08-13 13:11:25 +0000
+++ b/storage/myisam/mi_log.c	2009-11-24 13:54:59 +0000
@@ -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)

=== modified file 'storage/myisam/mi_open.c'
--- a/storage/myisam/mi_open.c	2009-11-06 14:20:27 +0000
+++ b/storage/myisam/mi_open.c	2009-11-24 13:54:59 +0000
@@ -181,7 +181,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,
@@ -482,7 +482,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 */
     }
 
@@ -522,10 +522,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 */
@@ -670,7 +670,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 */
@@ -679,13 +679,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:

=== modified file 'storage/myisam/mi_packrec.c'
--- a/storage/myisam/mi_packrec.c	2009-08-28 16:21:54 +0000
+++ b/storage/myisam/mi_packrec.c	2009-11-24 13:54:59 +0000
@@ -1373,7 +1373,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);
@@ -1516,8 +1516,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);
 }
 
 

=== modified file 'storage/myisam/mi_panic.c'
--- a/storage/myisam/mi_panic.c	2006-12-31 00:32:21 +0000
+++ b/storage/myisam/mi_panic.c	2009-11-24 13:54:59 +0000
@@ -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);

=== modified file 'storage/myisam/mi_rsame.c'
--- a/storage/myisam/mi_rsame.c	2007-05-10 09:59:39 +0000
+++ b/storage/myisam/mi_rsame.c	2009-11-24 13:54:59 +0000
@@ -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]);
   }

=== modified file 'storage/myisam/mi_statrec.c'
--- a/storage/myisam/mi_statrec.c	2008-03-29 08:02:54 +0000
+++ b/storage/myisam/mi_statrec.c	2009-11-24 13:54:59 +0000
@@ -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])

=== modified file 'storage/myisam/mi_test1.c'
--- a/storage/myisam/mi_test1.c	2008-03-31 07:40:39 +0000
+++ b/storage/myisam/mi_test1.c	2009-11-24 13:54:59 +0000
@@ -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;

=== modified file 'storage/myisam/mi_test2.c'
--- a/storage/myisam/mi_test2.c	2008-03-31 07:40:39 +0000
+++ b/storage/myisam/mi_test2.c	2009-11-24 13:54:59 +0000
@@ -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 */
 

=== modified file 'storage/myisam/mi_test3.c'
--- a/storage/myisam/mi_test3.c	2008-03-29 08:02:54 +0000
+++ b/storage/myisam/mi_test3.c	2009-11-24 13:54:59 +0000
@@ -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++)

=== modified file 'storage/myisam/mi_update.c'
--- a/storage/myisam/mi_update.c	2009-08-28 16:21:54 +0000
+++ b/storage/myisam/mi_update.c	2009-11-24 13:54:59 +0000
@@ -178,7 +178,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)
   {
@@ -229,7 +229,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)
   {

=== modified file 'storage/myisam/mi_write.c'
--- a/storage/myisam/mi_write.c	2009-09-17 15:25:52 +0000
+++ b/storage/myisam/mi_write.c	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'storage/myisam/myisamchk.c'
--- a/storage/myisam/myisamchk.c	2009-10-27 13:20:34 +0000
+++ b/storage/myisam/myisamchk.c	2009-11-24 13:54:59 +0000
@@ -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)
@@ -762,9 +762,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) &&
@@ -772,9 +772,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);
   }
 
@@ -928,9 +928,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;
@@ -1030,7 +1030,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));
@@ -1101,23 +1101,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,
-                              (size_t) 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)
       {
@@ -1150,7 +1150,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);
@@ -1171,30 +1171,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 */
 
@@ -1321,7 +1321,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;
@@ -1360,7 +1360,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;
@@ -1379,7 +1379,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++;
   }
@@ -1417,7 +1417,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++)
     {
@@ -1456,7 +1456,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;
     }
   }
@@ -1604,7 +1604,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;
@@ -1618,14 +1618,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));
@@ -1637,7 +1637,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;
@@ -1761,8 +1761,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);
 }
 
@@ -1784,8 +1784,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;
@@ -1809,8 +1809,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;

=== modified file 'storage/myisam/myisamlog.c'
--- a/storage/myisam/myisamlog.c	2008-02-18 22:29:39 +0000
+++ b/storage/myisam/myisamlog.c	2009-11-24 13:54:59 +0000
@@ -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);
     }

=== modified file 'storage/myisam/myisampack.c'
--- a/storage/myisam/myisampack.c	2008-11-14 16:29:38 +0000
+++ b/storage/myisam/myisampack.c	2009-11-24 13:54:59 +0000
@@ -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));

=== modified file 'storage/myisam/sort.c'
--- a/storage/myisam/sort.c	2009-10-27 14:27:27 +0000
+++ b/storage/myisam/sort.c	2009-11-24 13:54:59 +0000
@@ -970,7 +970,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);

=== modified file 'storage/myisammrg/myrg_close.c'
--- a/storage/myisammrg/myrg_close.c	2007-12-11 14:32:10 +0000
+++ b/storage/myisammrg/myrg_close.c	2009-11-24 13:54:59 +0000
@@ -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)
   {

=== modified file 'storage/myisammrg/myrg_create.c'
--- a/storage/myisammrg/myrg_create.c	2009-06-05 13:44:38 +0000
+++ b/storage/myisammrg/myrg_create.c	2009-11-24 13:54:59 +0000
@@ -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 */

=== modified file 'storage/myisammrg/myrg_open.c'
--- a/storage/myisammrg/myrg_open.c	2009-09-23 13:21:29 +0000
+++ b/storage/myisammrg/myrg_open.c	2009-11-24 13:54:59 +0000
@@ -87,9 +87,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);
@@ -167,9 +167,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);
@@ -313,9 +313,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);
@@ -327,8 +327,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);
@@ -348,7 +348,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);

=== modified file 'strings/str_test.c'
--- a/strings/str_test.c	2007-05-10 09:59:39 +0000
+++ b/strings/str_test.c	2009-11-24 13:54:59 +0000
@@ -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;
 }

=== modified file 'tests/thread_test.c'
--- a/tests/thread_test.c	2007-09-15 02:09:38 +0000
+++ b/tests/thread_test.c	2009-11-24 13:54:59 +0000
@@ -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;

Attachment: [text/bzr-bundle] bzr/kostja@sun.com-20091124135459-klvuwbvth0iahfbu.bundle
Thread
bzr commit into mysql-5.6-next-mr branch (kostja:2938) Bug#32082Konstantin Osipov24 Nov