Convert 703 function definitions to prototype style.

This automatically-generated patch converts 703 function definitions
in glibc from old-style K&R to prototype-style.

This conversion is deliberately simplistic, excluding any tricky cases
as even a patch covering only simple cases is still very large.
Currently excluded are: sysdeps files (to improve test coverage for
the initial patch); files containing assertions (to avoid line number
changes so that generated libraries can be compared); any cases where
the generated function declaration would involve lines over 79
characters and so need to be wrapped; any cases with array parameters
or other cases where parameter declarators don't end with the
parameter name; any other cases that my script didn't parse.

I didn't try to make the ChangeLog generation indicate when function
definitions are conditional; it just lists the functions changed
without regard to that.

Tested for x86_64 and x86 (testsuite, and that installed stripped
shared libraries are unchanged by the patch).

	* crypt/cert.c (good_bye): Convert to prototype-style function
	definition.
	(get8): Likewise.
	(put8): Likewise.
	* crypt/crypt-entry.c (crypt): Likewise.
	(__fcrypt): Likewise.
	* crypt/crypt_util.c (_ufc_prbits): Likewise.
	(_ufc_set_bits): Likewise.
	(_ufc_clearmem): Likewise.
	(__init_des_r): Likewise.
	(shuffle_sb): Likewise.
	(shuffle_sb): Likewise.
	(_ufc_setup_salt_r): Likewise.
	(_ufc_mk_keytab_r): Likewise.
	(_ufc_dofinalperm_r): Likewise.
	(encrypt): Likewise.
	(__setkey_r): Likewise.
	(setkey): Likewise.
	* crypt/md5.c (md5_init_ctx): Likewise.
	(md5_read_ctx): Likewise.
	(md5_finish_ctx): Likewise.
	(md5_stream): Likewise.
	(md5_buffer): Likewise.
	(md5_process_bytes): Likewise.
	* crypt/sha256.c (__sha256_init_ctx): Likewise.
	(__sha256_finish_ctx): Likewise.
	(__sha256_process_bytes): Likewise.
	* crypt/sha512.c (__sha512_init_ctx): Likewise.
	(__sha512_finish_ctx): Likewise.
	(__sha512_process_bytes): Likewise.
	* ctype/isctype.c (__isctype): Likewise.
	* debug/backtrace.c (__backtrace): Likewise.
	* debug/backtracesymsfd.c (__backtrace_symbols_fd): Likewise.
	* debug/fgets_chk.c (__fgets_chk): Likewise.
	* debug/fgets_u_chk.c (__fgets_unlocked_chk): Likewise.
	* debug/memcpy_chk.c (__memcpy_chk): Likewise.
	* debug/memmove_chk.c (MEMMOVE_CHK): Likewise.
	* debug/mempcpy_chk.c (__mempcpy_chk): Likewise.
	* debug/memset_chk.c (__memset_chk): Likewise.
	* debug/strcat_chk.c (__strcat_chk): Likewise.
	* debug/strncat_chk.c (__strncat_chk): Likewise.
	* debug/strncpy_chk.c (__strncpy_chk): Likewise.
	* debug/vsprintf_chk.c (_IO_str_chk_overflow): Likewise.
	* dirent/dirfd.c (dirfd): Likewise.
	* dirent/getdents.c (__getdirentries): Likewise.
	* dirent/getdents64.c (getdirentries64): Likewise.
	* dirent/rewinddir.c (__rewinddir): Likewise.
	* dirent/seekdir.c (seekdir): Likewise.
	* dirent/telldir.c (telldir): Likewise.
	* elf/sln.c (makesymlinks): Likewise.
	(makesymlink): Likewise.
	* gmon/gmon.c (__moncontrol): Likewise.
	(__monstartup): Likewise.
	(write_hist): Likewise.
	(write_call_graph): Likewise.
	(write_bb_counts): Likewise.
	* grp/setgroups.c (setgroups): Likewise.
	* inet/inet_lnaof.c (inet_lnaof): Likewise.
	* inet/inet_net.c (inet_network): Likewise.
	* inet/inet_netof.c (inet_netof): Likewise.
	* inet/rcmd.c (rresvport_af): Likewise.
	(rresvport): Likewise.
	* io/access.c (__access): Likewise.
	* io/chdir.c (__chdir): Likewise.
	* io/chmod.c (__chmod): Likewise.
	* io/chown.c (__chown): Likewise.
	* io/close.c (__close): Likewise.
	* io/creat.c (creat): Likewise.
	* io/creat64.c (creat64): Likewise.
	* io/dup.c (__dup): Likewise.
	* io/dup2.c (__dup2): Likewise.
	* io/dup3.c (__dup3): Likewise.
	* io/euidaccess.c (__euidaccess): Likewise.
	* io/faccessat.c (faccessat): Likewise.
	* io/fchmod.c (__fchmod): Likewise.
	* io/fchmodat.c (fchmodat): Likewise.
	* io/fchown.c (__fchown): Likewise.
	* io/fchownat.c (fchownat): Likewise.
	* io/fcntl.c (__fcntl): Likewise.
	* io/flock.c (__flock): Likewise.
	* io/fts.c (fts_load): Likewise.
	(fts_close): Likewise.
	(fts_read): Likewise.
	(fts_set): Likewise.
	(fts_children): Likewise.
	(fts_build): Likewise.
	(fts_stat): Likewise.
	(fts_sort): Likewise.
	(fts_alloc): Likewise.
	(fts_lfree): Likewise.
	(fts_palloc): Likewise.
	(fts_padjust): Likewise.
	(fts_maxarglen): Likewise.
	(fts_safe_changedir): Likewise.
	* io/getwd.c (getwd): Likewise.
	* io/isatty.c (__isatty): Likewise.
	* io/lchown.c (__lchown): Likewise.
	* io/link.c (__link): Likewise.
	* io/linkat.c (linkat): Likewise.
	* io/lseek.c (__libc_lseek): Likewise.
	* io/mkdir.c (__mkdir): Likewise.
	* io/mkdirat.c (mkdirat): Likewise.
	* io/mkfifo.c (mkfifo): Likewise.
	* io/mkfifoat.c (mkfifoat): Likewise.
	* io/open.c (__libc_open): Likewise.
	* io/open64.c (__libc_open64): Likewise.
	* io/readlink.c (__readlink): Likewise.
	* io/readlinkat.c (readlinkat): Likewise.
	* io/rmdir.c (__rmdir): Likewise.
	* io/symlink.c (__symlink): Likewise.
	* io/symlinkat.c (symlinkat): Likewise.
	* io/ttyname.c (ttyname): Likewise.
	* io/ttyname_r.c (__ttyname_r): Likewise.
	* io/umask.c (__umask): Likewise.
	* io/unlink.c (__unlink): Likewise.
	* io/unlinkat.c (unlinkat): Likewise.
	* io/utime.c (utime): Likewise.
	* libio/clearerr.c (clearerr): Likewise.
	* libio/clearerr_u.c (clearerr_unlocked): Likewise.
	* libio/feof.c (_IO_feof): Likewise.
	* libio/feof_u.c (feof_unlocked): Likewise.
	* libio/ferror.c (_IO_ferror): Likewise.
	* libio/ferror_u.c (ferror_unlocked): Likewise.
	* libio/filedoalloc.c (_IO_file_doallocate): Likewise.
	* libio/fileno.c (__fileno): Likewise.
	* libio/fputc.c (fputc): Likewise.
	* libio/fputc_u.c (fputc_unlocked): Likewise.
	* libio/fputwc.c (fputwc): Likewise.
	* libio/fputwc_u.c (fputwc_unlocked): Likewise.
	* libio/freopen.c (freopen): Likewise.
	* libio/freopen64.c (freopen64): Likewise.
	* libio/fseek.c (fseek): Likewise.
	* libio/fseeko.c (fseeko): Likewise.
	* libio/fseeko64.c (fseeko64): Likewise.
	* libio/ftello.c (__ftello): Likewise.
	* libio/ftello64.c (ftello64): Likewise.
	* libio/fwide.c (fwide): Likewise.
	* libio/genops.c (_IO_un_link): Likewise.
	(_IO_link_in): Likewise.
	(_IO_least_marker): Likewise.
	(_IO_switch_to_main_get_area): Likewise.
	(_IO_switch_to_backup_area): Likewise.
	(_IO_switch_to_get_mode): Likewise.
	(_IO_free_backup_area): Likewise.
	(_IO_switch_to_put_mode): Likewise.
	(__overflow): Likewise.
	(__underflow): Likewise.
	(__uflow): Likewise.
	(_IO_setb): Likewise.
	(_IO_doallocbuf): Likewise.
	(_IO_default_underflow): Likewise.
	(_IO_default_uflow): Likewise.
	(_IO_default_xsputn): Likewise.
	(_IO_sgetn): Likewise.
	(_IO_default_xsgetn): Likewise.
	(_IO_sync): Likewise.
	(_IO_default_setbuf): Likewise.
	(_IO_default_seekpos): Likewise.
	(_IO_default_doallocate): Likewise.
	(_IO_init): Likewise.
	(_IO_old_init): Likewise.
	(_IO_default_sync): Likewise.
	(_IO_default_finish): Likewise.
	(_IO_default_seekoff): Likewise.
	(_IO_sputbackc): Likewise.
	(_IO_sungetc): Likewise.
	(_IO_set_column): Likewise.
	(_IO_set_column): Likewise.
	(_IO_adjust_column): Likewise.
	(_IO_get_column): Likewise.
	(_IO_init_marker): Likewise.
	(_IO_remove_marker): Likewise.
	(_IO_marker_difference): Likewise.
	(_IO_marker_delta): Likewise.
	(_IO_seekmark): Likewise.
	(_IO_unsave_markers): Likewise.
	(_IO_nobackup_pbackfail): Likewise.
	(_IO_default_pbackfail): Likewise.
	(_IO_default_seek): Likewise.
	(_IO_default_stat): Likewise.
	(_IO_default_read): Likewise.
	(_IO_default_write): Likewise.
	(_IO_default_showmanyc): Likewise.
	(_IO_default_imbue): Likewise.
	(_IO_iter_next): Likewise.
	(_IO_iter_file): Likewise.
	* libio/getc.c (_IO_getc): Likewise.
	* libio/getwc.c (_IO_getwc): Likewise.
	* libio/iofclose.c (_IO_new_fclose): Likewise.
	* libio/iofdopen.c (_IO_new_fdopen): Likewise.
	* libio/iofflush.c (_IO_fflush): Likewise.
	* libio/iofflush_u.c (__fflush_unlocked): Likewise.
	* libio/iofgetpos.c (_IO_new_fgetpos): Likewise.
	* libio/iofgetpos64.c (_IO_new_fgetpos64): Likewise.
	* libio/iofgets.c (_IO_fgets): Likewise.
	* libio/iofgets_u.c (__fgets_unlocked): Likewise.
	* libio/iofgetws.c (fgetws): Likewise.
	* libio/iofgetws_u.c (fgetws_unlocked): Likewise.
	* libio/iofopen64.c (_IO_fopen64): Likewise.
	* libio/iofopncook.c (_IO_cookie_read): Likewise.
	(_IO_cookie_write): Likewise.
	(_IO_cookie_seek): Likewise.
	(_IO_cookie_close): Likewise.
	(_IO_cookie_seekoff): Likewise.
	(_IO_old_cookie_seek): Likewise.
	* libio/iofputs.c (_IO_fputs): Likewise.
	* libio/iofputs_u.c (__fputs_unlocked): Likewise.
	* libio/iofputws.c (fputws): Likewise.
	* libio/iofputws_u.c (fputws_unlocked): Likewise.
	* libio/iofread.c (_IO_fread): Likewise.
	* libio/iofread_u.c (__fread_unlocked): Likewise.
	* libio/iofsetpos.c (_IO_new_fsetpos): Likewise.
	* libio/iofsetpos64.c (_IO_new_fsetpos64): Likewise.
	* libio/ioftell.c (_IO_ftell): Likewise.
	* libio/iofwrite.c (_IO_fwrite): Likewise.
	* libio/iogetdelim.c (_IO_getdelim): Likewise.
	* libio/iogets.c (_IO_gets): Likewise.
	* libio/iopadn.c (_IO_padn): Likewise.
	* libio/iopopen.c (_IO_new_proc_open): Likewise.
	(_IO_new_popen): Likewise.
	(_IO_new_proc_close): Likewise.
	* libio/ioputs.c (_IO_puts): Likewise.
	* libio/ioseekoff.c (_IO_seekoff_unlocked): Likewise.
	(_IO_seekoff): Likewise.
	* libio/ioseekpos.c (_IO_seekpos_unlocked): Likewise.
	(_IO_seekpos): Likewise.
	* libio/iosetbuffer.c (_IO_setbuffer): Likewise.
	* libio/iosetvbuf.c (_IO_setvbuf): Likewise.
	* libio/ioungetc.c (_IO_ungetc): Likewise.
	* libio/ioungetwc.c (ungetwc): Likewise.
	* libio/iovdprintf.c (_IO_vdprintf): Likewise.
	* libio/iovsscanf.c (_IO_vsscanf): Likewise.
	* libio/iowpadn.c (_IO_wpadn): Likewise.
	* libio/libc_fatal.c (__libc_fatal): Likewise.
	* libio/memstream.c (__open_memstream): Likewise.
	(_IO_mem_sync): Likewise.
	(_IO_mem_finish): Likewise.
	* libio/oldfileops.c (_IO_old_file_init): Likewise.
	(_IO_old_file_close_it): Likewise.
	(_IO_old_file_finish): Likewise.
	(_IO_old_file_fopen): Likewise.
	(_IO_old_file_attach): Likewise.
	(_IO_old_file_setbuf): Likewise.
	(_IO_old_do_write): Likewise.
	(old_do_write): Likewise.
	(_IO_old_file_underflow): Likewise.
	(_IO_old_file_overflow): Likewise.
	(_IO_old_file_sync): Likewise.
	(_IO_old_file_seekoff): Likewise.
	(_IO_old_file_write): Likewise.
	(_IO_old_file_xsputn): Likewise.
	* libio/oldiofclose.c (_IO_old_fclose): Likewise.
	* libio/oldiofdopen.c (_IO_old_fdopen): Likewise.
	* libio/oldiofgetpos.c (_IO_old_fgetpos): Likewise.
	* libio/oldiofgetpos64.c (_IO_old_fgetpos64): Likewise.
	* libio/oldiofopen.c (_IO_old_fopen): Likewise.
	* libio/oldiofsetpos.c (_IO_old_fsetpos): Likewise.
	* libio/oldiofsetpos64.c (_IO_old_fsetpos64): Likewise.
	* libio/oldiopopen.c (_IO_old_proc_open): Likewise.
	(_IO_old_popen): Likewise.
	(_IO_old_proc_close): Likewise.
	* libio/oldpclose.c (__old_pclose): Likewise.
	* libio/pclose.c (__new_pclose): Likewise.
	* libio/peekc.c (_IO_peekc_locked): Likewise.
	* libio/putc.c (_IO_putc): Likewise.
	* libio/putc_u.c (putc_unlocked): Likewise.
	* libio/putchar.c (putchar): Likewise.
	* libio/putchar_u.c (putchar_unlocked): Likewise.
	* libio/putwc.c (putwc): Likewise.
	* libio/putwc_u.c (putwc_unlocked): Likewise.
	* libio/putwchar.c (putwchar): Likewise.
	* libio/putwchar_u.c (putwchar_unlocked): Likewise.
	* libio/rewind.c (rewind): Likewise.
	* libio/setbuf.c (setbuf): Likewise.
	* libio/setlinebuf.c (setlinebuf): Likewise.
	* libio/vasprintf.c (_IO_vasprintf): Likewise.
	* libio/vscanf.c (_IO_vscanf): Likewise.
	* libio/vsnprintf.c (_IO_strn_overflow): Likewise.
	* libio/vswprintf.c (_IO_wstrn_overflow): Likewise.
	* libio/wfiledoalloc.c (_IO_wfile_doallocate): Likewise.
	* libio/wgenops.c (_IO_least_wmarker): Likewise.
	(_IO_switch_to_main_wget_area): Likewise.
	(_IO_switch_to_wbackup_area): Likewise.
	(_IO_wsetb): Likewise.
	(_IO_wdefault_pbackfail): Likewise.
	(_IO_wdefault_finish): Likewise.
	(_IO_wdefault_uflow): Likewise.
	(__woverflow): Likewise.
	(__wuflow): Likewise.
	(__wunderflow): Likewise.
	(_IO_wdefault_xsputn): Likewise.
	(_IO_wdefault_xsgetn): Likewise.
	(_IO_wdoallocbuf): Likewise.
	(_IO_wdefault_doallocate): Likewise.
	(_IO_switch_to_wget_mode): Likewise.
	(_IO_free_wbackup_area): Likewise.
	(_IO_switch_to_wput_mode): Likewise.
	(_IO_sputbackwc): Likewise.
	(_IO_sungetwc): Likewise.
	(_IO_adjust_wcolumn): Likewise.
	(_IO_init_wmarker): Likewise.
	(_IO_wmarker_delta): Likewise.
	(_IO_seekwmark): Likewise.
	(_IO_unsave_wmarkers): Likewise.
	* libio/wmemstream.c (open_wmemstream): Likewise.
	(_IO_wmem_sync): Likewise.
	(_IO_wmem_finish): Likewise.
	* locale/nl_langinfo.c (nl_langinfo): Likewise.
	* locale/nl_langinfo_l.c (__nl_langinfo_l): Likewise.
	* locale/programs/simple-hash.c (init_hash): Likewise.
	(delete_hash): Likewise.
	(insert_entry): Likewise.
	(set_entry): Likewise.
	(next_prime): Likewise.
	(is_prime): Likewise.
	* locale/programs/xmalloc.c (fixup_null_alloc): Likewise.
	(xmalloc): Likewise.
	(xrealloc): Likewise.
	* locale/programs/xstrdup.c (xstrdup): Likewise.
	* localedata/collate-test.c (xstrcoll): Likewise.
	* localedata/xfrm-test.c (xstrcmp): Likewise.
	* login/getlogin_r.c (__getlogin_r): Likewise.
	* login/getpt.c (__posix_openpt): Likewise.
	* login/login_tty.c (login_tty): Likewise.
	* login/setlogin.c (setlogin): Likewise.
	* mach/msg-destroy.c (__mach_msg_destroy): Likewise.
	(mach_msg_destroy_port): Likewise.
	(mach_msg_destroy_memory): Likewise.
	* malloc/mcheck.c (flood): Likewise.
	* misc/acct.c (acct): Likewise.
	* misc/brk.c (__brk): Likewise.
	* misc/chflags.c (chflags): Likewise.
	* misc/chroot.c (chroot): Likewise.
	* misc/fchflags.c (fchflags): Likewise.
	* misc/fstab.c (getfsspec): Likewise.
	(getfsfile): Likewise.
	* misc/fsync.c (fsync): Likewise.
	* misc/ftruncate.c (__ftruncate): Likewise.
	* misc/ftruncate64.c (__ftruncate64): Likewise.
	* misc/getdomain.c (getdomainname): Likewise.
	(getdomainname): Likewise.
	* misc/gethostname.c (__gethostname): Likewise.
	* misc/getpass.c (getpass): Likewise.
	* misc/getttyent.c (skip): Likewise.
	(value): Likewise.
	* misc/gtty.c (gtty): Likewise.
	* misc/hsearch.c (hsearch): Likewise.
	(hcreate): Likewise.
	* misc/hsearch_r.c (__hcreate_r): Likewise.
	(__hdestroy_r): Likewise.
	* misc/ioctl.c (__ioctl): Likewise.
	* misc/mkdtemp.c (mkdtemp): Likewise.
	* misc/mkostemp.c (mkostemp): Likewise.
	* misc/mkostemp64.c (mkostemp64): Likewise.
	* misc/mkostemps.c (mkostemps): Likewise.
	* misc/mkostemps64.c (mkostemps64): Likewise.
	* misc/mkstemp.c (mkstemp): Likewise.
	* misc/mkstemp64.c (mkstemp64): Likewise.
	* misc/mkstemps.c (mkstemps): Likewise.
	* misc/mkstemps64.c (mkstemps64): Likewise.
	* misc/mktemp.c (__mktemp): Likewise.
	* misc/preadv.c (preadv): Likewise.
	* misc/preadv64.c (preadv64): Likewise.
	* misc/pwritev.c (pwritev): Likewise.
	* misc/pwritev64.c (pwritev64): Likewise.
	* misc/readv.c (__readv): Likewise.
	* misc/revoke.c (revoke): Likewise.
	* misc/setdomain.c (setdomainname): Likewise.
	* misc/setegid.c (setegid): Likewise.
	* misc/seteuid.c (seteuid): Likewise.
	* misc/sethostid.c (sethostid): Likewise.
	* misc/sethostname.c (sethostname): Likewise.
	* misc/setregid.c (__setregid): Likewise.
	* misc/setreuid.c (__setreuid): Likewise.
	* misc/sstk.c (sstk): Likewise.
	* misc/stty.c (stty): Likewise.
	* misc/syscall.c (syscall): Likewise.
	* misc/syslog.c (setlogmask): Likewise.
	* misc/truncate.c (__truncate): Likewise.
	* misc/truncate64.c (truncate64): Likewise.
	* misc/ualarm.c (ualarm): Likewise.
	* misc/usleep.c (usleep): Likewise.
	* misc/ustat.c (ustat): Likewise.
	* misc/writev.c (__writev): Likewise.
	* nptl/cleanup_compat.c (_pthread_cleanup_pop): Likewise.
	* nptl/old_pthread_cond_broadcast.c
	(__pthread_cond_broadcast_2_0): Likewise.
	* nptl/old_pthread_cond_destroy.c (__pthread_cond_destroy_2_0):
	Likewise.
	* nptl/old_pthread_cond_signal.c (__pthread_cond_signal_2_0):
	Likewise.
	* nptl/old_pthread_cond_wait.c (__pthread_cond_wait_2_0):
	Likewise.
	* nptl/pt-raise.c (raise): Likewise.
	* nptl/pthread_barrier_destroy.c (pthread_barrier_destroy):
	Likewise.
	* nptl/pthread_barrier_wait.c (__pthread_barrier_wait): Likewise.
	* nptl/pthread_barrierattr_destroy.c
	(pthread_barrierattr_destroy): Likewise.
	* nptl/pthread_barrierattr_init.c (pthread_barrierattr_init):
	Likewise.
	* nptl/pthread_barrierattr_setpshared.c
	(pthread_barrierattr_setpshared): Likewise.
	* nptl/pthread_cond_broadcast.c (__pthread_cond_broadcast):
	Likewise.
	* nptl/pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
	* nptl/pthread_cond_init.c (__pthread_cond_init): Likewise.
	* nptl/pthread_cond_signal.c (__pthread_cond_signal): Likewise.
	* nptl/pthread_condattr_destroy.c (__pthread_condattr_destroy):
	Likewise.
	* nptl/pthread_condattr_getclock.c (pthread_condattr_getclock):
	Likewise.
	* nptl/pthread_condattr_getpshared.c
	(pthread_condattr_getpshared): Likewise.
	* nptl/pthread_condattr_init.c (__pthread_condattr_init):
	Likewise.
	* nptl/pthread_condattr_setpshared.c
	(pthread_condattr_setpshared): Likewise.
	* nptl/pthread_detach.c (pthread_detach): Likewise.
	* nptl/pthread_equal.c (__pthread_equal): Likewise.
	* nptl/pthread_getcpuclockid.c (pthread_getcpuclockid): Likewise.
	* nptl/pthread_getspecific.c (__pthread_getspecific): Likewise.
	* nptl/pthread_key_delete.c (pthread_key_delete): Likewise.
	* nptl/pthread_mutex_consistent.c (pthread_mutex_consistent):
	Likewise.
	* nptl/pthread_mutex_destroy.c (__pthread_mutex_destroy):
	Likewise.
	* nptl/pthread_mutex_getprioceiling.c
	(pthread_mutex_getprioceiling): Likewise.
	* nptl/pthread_mutexattr_destroy.c (__pthread_mutexattr_destroy):
	Likewise.
	* nptl/pthread_mutexattr_getprotocol.c
	(pthread_mutexattr_getprotocol): Likewise.
	* nptl/pthread_mutexattr_getpshared.c
	(pthread_mutexattr_getpshared): Likewise.
	* nptl/pthread_mutexattr_getrobust.c
	(pthread_mutexattr_getrobust): Likewise.
	* nptl/pthread_mutexattr_gettype.c (pthread_mutexattr_gettype):
	Likewise.
	* nptl/pthread_mutexattr_init.c (__pthread_mutexattr_init):
	Likewise.
	* nptl/pthread_mutexattr_setprioceiling.c
	(pthread_mutexattr_setprioceiling): Likewise.
	* nptl/pthread_mutexattr_setprotocol.c
	(pthread_mutexattr_setprotocol): Likewise.
	* nptl/pthread_mutexattr_setpshared.c
	(pthread_mutexattr_setpshared): Likewise.
	* nptl/pthread_mutexattr_setrobust.c
	(pthread_mutexattr_setrobust): Likewise.
	* nptl/pthread_mutexattr_settype.c (__pthread_mutexattr_settype):
	Likewise.
	* nptl/pthread_rwlock_destroy.c (__pthread_rwlock_destroy):
	Likewise.
	* nptl/pthread_rwlockattr_destroy.c (pthread_rwlockattr_destroy):
	Likewise.
	* nptl/pthread_rwlockattr_getkind_np.c
	(pthread_rwlockattr_getkind_np): Likewise.
	* nptl/pthread_rwlockattr_getpshared.c
	(pthread_rwlockattr_getpshared): Likewise.
	* nptl/pthread_rwlockattr_init.c (pthread_rwlockattr_init):
	Likewise.
	* nptl/pthread_rwlockattr_setkind_np.c
	(pthread_rwlockattr_setkind_np): Likewise.
	* nptl/pthread_rwlockattr_setpshared.c
	(pthread_rwlockattr_setpshared): Likewise.
	* nptl/pthread_setcancelstate.c (__pthread_setcancelstate):
	Likewise.
	* nptl/pthread_setcanceltype.c (__pthread_setcanceltype):
	Likewise.
	* nptl/pthread_setconcurrency.c (pthread_setconcurrency):
	Likewise.
	* nptl/pthread_setschedprio.c (pthread_setschedprio): Likewise.
	* nptl/pthread_setspecific.c (__pthread_setspecific): Likewise.
	* nptl/pthread_spin_destroy.c (pthread_spin_destroy): Likewise.
	* nptl/pthread_tryjoin.c (pthread_tryjoin_np): Likewise.
	* nptl/sem_close.c (sem_close): Likewise.
	* nptl/sem_destroy.c (__new_sem_destroy): Likewise.
	* nptl/sem_init.c (__old_sem_init): Likewise.
	* nptl/sigaction.c (__sigaction): Likewise.
	* nptl/unregister-atfork.c (__unregister_atfork): Likewise.
	* posix/_exit.c (_exit): Likewise.
	* posix/alarm.c (alarm): Likewise.
	* posix/confstr.c (confstr): Likewise.
	* posix/fpathconf.c (__fpathconf): Likewise.
	* posix/getgroups.c (__getgroups): Likewise.
	* posix/getpgid.c (__getpgid): Likewise.
	* posix/group_member.c (__group_member): Likewise.
	* posix/pathconf.c (__pathconf): Likewise.
	* posix/sched_getaffinity.c (sched_getaffinity): Likewise.
	* posix/sched_setaffinity.c (sched_setaffinity): Likewise.
	* posix/setgid.c (__setgid): Likewise.
	* posix/setpgid.c (__setpgid): Likewise.
	* posix/setuid.c (__setuid): Likewise.
	* posix/sleep.c (__sleep): Likewise.
	* posix/sysconf.c (__sysconf): Likewise.
	* posix/times.c (__times): Likewise.
	* posix/uname.c (__uname): Likewise.
	* posix/waitid.c (__waitid): Likewise.
	* pwd/getpw.c (__getpw): Likewise.
	* resolv/base64.c (b64_pton): Likewise.
	* resolv/gai_sigqueue.c (__gai_sigqueue): Likewise.
	* resolv/gethnamaddr.c (Dprintf): Likewise.
	(gethostbyname): Likewise.
	(gethostbyname2): Likewise.
	(gethostbyaddr): Likewise.
	(_sethtent): Likewise.
	(_gethtbyname): Likewise.
	(_gethtbyname2): Likewise.
	(_gethtbyaddr): Likewise.
	(map_v4v6_address): Likewise.
	(map_v4v6_hostent): Likewise.
	(addrsort): Likewise.
	(ht_sethostent): Likewise.
	(ht_gethostbyname): Likewise.
	(ht_gethostbyaddr): Likewise.
	* resolv/inet_net_ntop.c (inet_net_ntop): Likewise.
	(inet_net_ntop_ipv4): Likewise.
	* resolv/inet_neta.c (inet_neta): Likewise.
	* resolv/inet_ntop.c (inet_ntop): Likewise.
	(inet_ntop4): Likewise.
	(inet_ntop6): Likewise.
	* resolv/inet_pton.c (__inet_pton): Likewise.
	(inet_pton4): Likewise.
	(inet_pton6): Likewise.
	* resolv/res_debug.c (loc_aton): Likewise.
	(loc_ntoa): Likewise.
	* resource/getpriority.c (__getpriority): Likewise.
	* resource/getrusage.c (__getrusage): Likewise.
	* resource/nice.c (nice): Likewise.
	* resource/setpriority.c (__setpriority): Likewise.
	* resource/setrlimit64.c (setrlimit64): Likewise.
	* resource/vlimit.c (vlimit): Likewise.
	* resource/vtimes.c (vtimes): Likewise.
	* rt/aio_error.c (aio_error): Likewise.
	* rt/aio_return.c (aio_return): Likewise.
	* rt/aio_sigqueue.c (__aio_sigqueue): Likewise.
	* signal/kill.c (__kill): Likewise.
	* signal/killpg.c (killpg): Likewise.
	* signal/raise.c (raise): Likewise.
	* signal/sigaction.c (__sigaction): Likewise.
	* signal/sigaddset.c (sigaddset): Likewise.
	* signal/sigaltstack.c (sigaltstack): Likewise.
	* signal/sigandset.c (sigandset): Likewise.
	* signal/sigblock.c (__sigblock): Likewise.
	* signal/sigdelset.c (sigdelset): Likewise.
	* signal/sigempty.c (sigemptyset): Likewise.
	* signal/sigfillset.c (sigfillset): Likewise.
	* signal/sighold.c (sighold): Likewise.
	* signal/sigignore.c (sigignore): Likewise.
	* signal/sigintr.c (siginterrupt): Likewise.
	* signal/sigisempty.c (sigisemptyset): Likewise.
	* signal/sigismem.c (sigismember): Likewise.
	* signal/signal.c (signal): Likewise.
	* signal/sigorset.c (sigorset): Likewise.
	* signal/sigpause.c (__sigpause): Likewise.
	* signal/sigpending.c (sigpending): Likewise.
	* signal/sigprocmask.c (__sigprocmask): Likewise.
	* signal/sigrelse.c (sigrelse): Likewise.
	* signal/sigreturn.c (__sigreturn): Likewise.
	* signal/sigset.c (sigset): Likewise.
	* signal/sigsetmask.c (__sigsetmask): Likewise.
	* signal/sigstack.c (sigstack): Likewise.
	* signal/sigsuspend.c (__sigsuspend): Likewise.
	* signal/sigvec.c (sigvec_wrapper_handler): Likewise.
	* signal/sysv_signal.c (__sysv_signal): Likewise.
	* socket/accept.c (accept): Likewise.
	* socket/accept4.c (__libc_accept4): Likewise.
	* socket/bind.c (__bind): Likewise.
	* socket/connect.c (__connect): Likewise.
	* socket/getpeername.c (getpeername): Likewise.
	* socket/getsockname.c (__getsockname): Likewise.
	* socket/getsockopt.c (getsockopt): Likewise.
	* socket/listen.c (__listen): Likewise.
	* socket/recv.c (__recv): Likewise.
	* socket/recvmsg.c (__recvmsg): Likewise.
	* socket/send.c (__send): Likewise.
	* socket/sendmsg.c (__sendmsg): Likewise.
	* socket/shutdown.c (shutdown): Likewise.
	* socket/sockatmark.c (sockatmark): Likewise.
	* socket/socket.c (__socket): Likewise.
	* stdio-common/ctermid.c (ctermid): Likewise.
	* stdio-common/cuserid.c (cuserid): Likewise.
	* stdio-common/printf-prs.c (parse_printf_format): Likewise.
	* stdio-common/remove.c (remove): Likewise.
	* stdio-common/rename.c (rename): Likewise.
	* stdio-common/renameat.c (renameat): Likewise.
	* stdio-common/tempname.c (__gen_tempname): Likewise.
	* stdio-common/xbug.c (InitBuffer): Likewise.
	(AppendToBuffer): Likewise.
	(ReadFile): Likewise.
	* stdlib/a64l.c (a64l): Likewise.
	* stdlib/drand48_r.c (drand48_r): Likewise.
	* stdlib/getcontext.c (getcontext): Likewise.
	* stdlib/getenv.c (getenv): Likewise.
	* stdlib/l64a.c (l64a): Likewise.
	* stdlib/llabs.c (llabs): Likewise.
	* stdlib/lldiv.c (lldiv): Likewise.
	* stdlib/lrand48_r.c (lrand48_r): Likewise.
	* stdlib/mrand48_r.c (mrand48_r): Likewise.
	* stdlib/putenv.c (putenv): Likewise.
	* stdlib/random.c (__srandom): Likewise.
	(__initstate): Likewise.
	(__setstate): Likewise.
	* stdlib/random_r.c (__srandom_r): Likewise.
	(__setstate_r): Likewise.
	(__random_r): Likewise.
	* stdlib/secure-getenv.c (__libc_secure_getenv): Likewise.
	* stdlib/setcontext.c (setcontext): Likewise.
	* stdlib/setenv.c (setenv): Likewise.
	(unsetenv): Likewise.
	* stdlib/srand48.c (srand48): Likewise.
	* stdlib/srand48_r.c (__srand48_r): Likewise.
	* stdlib/swapcontext.c (swapcontext): Likewise.
	* stdlib/system.c (__libc_system): Likewise.
	* stdlib/tst-strtod.c (expand): Likewise.
	* stdlib/tst-strtol.c (expand): Likewise.
	* stdlib/tst-strtoll.c (expand): Likewise.
	* streams/fattach.c (fattach): Likewise.
	* streams/fdetach.c (fdetach): Likewise.
	* streams/getmsg.c (getmsg): Likewise.
	* streams/isastream.c (isastream): Likewise.
	* string/ffs.c (__ffs): Likewise.
	* string/ffsll.c (ffsll): Likewise.
	* string/memcmp.c (memcmp_common_alignment): Likewise.
	(memcmp_not_common_alignment): Likewise.
	(MEMCMP): Likewise.
	* string/memcpy.c (memcpy): Likewise.
	* string/memmove.c (MEMMOVE): Likewise.
	* string/memset.c (memset): Likewise.
	* string/rawmemchr.c (RAWMEMCHR): Likewise.
	* string/strchrnul.c (STRCHRNUL): Likewise.
	* string/strerror.c (strerror): Likewise.
	* string/strndup.c (__strndup): Likewise.
	* string/strverscmp.c (__strverscmp): Likewise.
	* sunrpc/clnt_raw.c (clntraw_freeres): Likewise.
	* sunrpc/clnt_tcp.c (clnttcp_geterr): Likewise.
	(clnttcp_freeres): Likewise.
	* sunrpc/clnt_unix.c (clntunix_freeres): Likewise.
	* sunrpc/pmap_prot.c (xdr_pmap): Likewise.
	* sunrpc/pmap_prot2.c (xdr_pmaplist): Likewise.
	* sunrpc/pmap_rmt.c (xdr_rmtcallres): Likewise.
	* sunrpc/rpc_prot.c (xdr_replymsg): Likewise.
	(xdr_callhdr): Likewise.
	* sunrpc/rpcinfo.c (udpping): Likewise.
	(tcpping): Likewise.
	(pstatus): Likewise.
	(pmapdump): Likewise.
	(brdcst): Likewise.
	(deletereg): Likewise.
	(getprognum): Likewise.
	(getvers): Likewise.
	(get_inet_address): Likewise.
	* sunrpc/svc_raw.c (svcraw_recv): Likewise.
	* sunrpc/svc_udp.c (svcudp_create): Likewise.
	(svcudp_stat): Likewise.
	(svcudp_recv): Likewise.
	(svcudp_reply): Likewise.
	(svcudp_getargs): Likewise.
	(svcudp_freeargs): Likewise.
	(svcudp_destroy): Likewise.
	* sunrpc/xdr.c (xdr_bytes): Likewise.
	(xdr_netobj): Likewise.
	(xdr_string): Likewise.
	(xdr_wrapstring): Likewise.
	* sunrpc/xdr_float.c (xdr_float): Likewise.
	(xdr_double): Likewise.
	* sunrpc/xdr_mem.c (xdrmem_setpos): Likewise.
	* sunrpc/xdr_ref.c (xdr_pointer): Likewise.
	* sysvipc/ftok.c (ftok): Likewise.
	* sysvipc/msgctl.c (msgctl): Likewise.
	* sysvipc/msgget.c (msgget): Likewise.
	* sysvipc/msgrcv.c (msgrcv): Likewise.
	* sysvipc/msgsnd.c (msgsnd): Likewise.
	* sysvipc/semget.c (semget): Likewise.
	* sysvipc/semop.c (semop): Likewise.
	* sysvipc/shmat.c (shmat): Likewise.
	* sysvipc/shmctl.c (shmctl): Likewise.
	* sysvipc/shmdt.c (shmdt): Likewise.
	* sysvipc/shmget.c (shmget): Likewise.
	* termios/cfmakeraw.c (cfmakeraw): Likewise.
	* termios/speed.c (cfgetospeed): Likewise.
	(cfgetispeed): Likewise.
	(cfsetospeed): Likewise.
	(cfsetispeed): Likewise.
	* termios/tcflow.c (tcflow): Likewise.
	* termios/tcflush.c (tcflush): Likewise.
	* termios/tcgetattr.c (__tcgetattr): Likewise.
	* termios/tcgetpgrp.c (tcgetpgrp): Likewise.
	* termios/tcgetsid.c (tcgetsid): Likewise.
	* termios/tcsendbrk.c (tcsendbreak): Likewise.
	* termios/tcsetpgrp.c (tcsetpgrp): Likewise.
	* time/adjtime.c (__adjtime): Likewise.
	* time/dysize.c (dysize): Likewise.
	* time/ftime.c (ftime): Likewise.
	* time/getitimer.c (__getitimer): Likewise.
	* time/gettimeofday.c (__gettimeofday): Likewise.
	* time/gmtime.c (__gmtime_r): Likewise.
	(gmtime): Likewise.
	* time/localtime.c (__localtime_r): Likewise.
	(localtime): Likewise.
	* time/offtime.c (__offtime): Likewise.
	* time/settimeofday.c (__settimeofday): Likewise.
	* time/stime.c (stime): Likewise.
	* time/strftime_l.c (tm_diff): Likewise.
	(iso_week_days): Likewise.
	* time/strptime.c (strptime): Likewise.
	* time/time.c (time): Likewise.
	* time/timespec_get.c (timespec_get): Likewise.
	* time/tzset.c (tzset_internal): Likewise.
	(compute_change): Likewise.
	(__tz_compute): Likewise.
	* wcsmbs/btowc.c (__btowc): Likewise.
	* wcsmbs/mbrlen.c (__mbrlen): Likewise.
	* wcsmbs/mbsinit.c (__mbsinit): Likewise.
	* wcsmbs/mbsrtowcs.c (__mbsrtowcs): Likewise.
	* wcsmbs/wcpcpy.c (__wcpcpy): Likewise.
	* wcsmbs/wcpncpy.c (__wcpncpy): Likewise.
	* wcsmbs/wcscat.c (__wcscat): Likewise.
	* wcsmbs/wcschrnul.c (__wcschrnul): Likewise.
	* wcsmbs/wcscmp.c (WCSCMP): Likewise.
	* wcsmbs/wcscpy.c (WCSCPY): Likewise.
	* wcsmbs/wcscspn.c (wcscspn): Likewise.
	* wcsmbs/wcsdup.c (wcsdup): Likewise.
	* wcsmbs/wcslen.c (__wcslen): Likewise.
	* wcsmbs/wcsncat.c (WCSNCAT): Likewise.
	* wcsmbs/wcsncmp.c (WCSNCMP): Likewise.
	* wcsmbs/wcsncpy.c (__wcsncpy): Likewise.
	* wcsmbs/wcsnlen.c (__wcsnlen): Likewise.
	* wcsmbs/wcspbrk.c (wcspbrk): Likewise.
	* wcsmbs/wcsrchr.c (WCSRCHR): Likewise.
	* wcsmbs/wcsspn.c (wcsspn): Likewise.
	* wcsmbs/wcsstr.c (wcsstr): Likewise.
	* wcsmbs/wcstok.c (wcstok): Likewise.
	* wcsmbs/wctob.c (wctob): Likewise.
	* wcsmbs/wmemchr.c (__wmemchr): Likewise.
	* wcsmbs/wmemcmp.c (WMEMCMP): Likewise.
	* wcsmbs/wmemcpy.c (__wmemcpy): Likewise.
	* wcsmbs/wmemmove.c (__wmemmove): Likewise.
	* wcsmbs/wmempcpy.c (__wmempcpy): Likewise.
	* wcsmbs/wmemset.c (__wmemset): Likewise.
	* wctype/wcfuncs.c (__towlower): Likewise.
	(__towupper): Likewise.

492 files changed, 1453 insertions, 2105 deletions

diff --git a/ChangeLog b/ChangeLog
index 3e35f81..2de4c46 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,748 @@
 2015-10-16  Joseph Myers  <joseph@codesourcery.com>
 
+	* crypt/cert.c (good_bye): Convert to prototype-style function
+	definition.
+	(get8): Likewise.
+	(put8): Likewise.
+	* crypt/crypt-entry.c (crypt): Likewise.
+	(__fcrypt): Likewise.
+	* crypt/crypt_util.c (_ufc_prbits): Likewise.
+	(_ufc_set_bits): Likewise.
+	(_ufc_clearmem): Likewise.
+	(__init_des_r): Likewise.
+	(shuffle_sb): Likewise.
+	(shuffle_sb): Likewise.
+	(_ufc_setup_salt_r): Likewise.
+	(_ufc_mk_keytab_r): Likewise.
+	(_ufc_dofinalperm_r): Likewise.
+	(encrypt): Likewise.
+	(__setkey_r): Likewise.
+	(setkey): Likewise.
+	* crypt/md5.c (md5_init_ctx): Likewise.
+	(md5_read_ctx): Likewise.
+	(md5_finish_ctx): Likewise.
+	(md5_stream): Likewise.
+	(md5_buffer): Likewise.
+	(md5_process_bytes): Likewise.
+	* crypt/sha256.c (__sha256_init_ctx): Likewise.
+	(__sha256_finish_ctx): Likewise.
+	(__sha256_process_bytes): Likewise.
+	* crypt/sha512.c (__sha512_init_ctx): Likewise.
+	(__sha512_finish_ctx): Likewise.
+	(__sha512_process_bytes): Likewise.
+	* ctype/isctype.c (__isctype): Likewise.
+	* debug/backtrace.c (__backtrace): Likewise.
+	* debug/backtracesymsfd.c (__backtrace_symbols_fd): Likewise.
+	* debug/fgets_chk.c (__fgets_chk): Likewise.
+	* debug/fgets_u_chk.c (__fgets_unlocked_chk): Likewise.
+	* debug/memcpy_chk.c (__memcpy_chk): Likewise.
+	* debug/memmove_chk.c (MEMMOVE_CHK): Likewise.
+	* debug/mempcpy_chk.c (__mempcpy_chk): Likewise.
+	* debug/memset_chk.c (__memset_chk): Likewise.
+	* debug/strcat_chk.c (__strcat_chk): Likewise.
+	* debug/strncat_chk.c (__strncat_chk): Likewise.
+	* debug/strncpy_chk.c (__strncpy_chk): Likewise.
+	* debug/vsprintf_chk.c (_IO_str_chk_overflow): Likewise.
+	* dirent/dirfd.c (dirfd): Likewise.
+	* dirent/getdents.c (__getdirentries): Likewise.
+	* dirent/getdents64.c (getdirentries64): Likewise.
+	* dirent/rewinddir.c (__rewinddir): Likewise.
+	* dirent/seekdir.c (seekdir): Likewise.
+	* dirent/telldir.c (telldir): Likewise.
+	* elf/sln.c (makesymlinks): Likewise.
+	(makesymlink): Likewise.
+	* gmon/gmon.c (__moncontrol): Likewise.
+	(__monstartup): Likewise.
+	(write_hist): Likewise.
+	(write_call_graph): Likewise.
+	(write_bb_counts): Likewise.
+	* grp/setgroups.c (setgroups): Likewise.
+	* inet/inet_lnaof.c (inet_lnaof): Likewise.
+	* inet/inet_net.c (inet_network): Likewise.
+	* inet/inet_netof.c (inet_netof): Likewise.
+	* inet/rcmd.c (rresvport_af): Likewise.
+	(rresvport): Likewise.
+	* io/access.c (__access): Likewise.
+	* io/chdir.c (__chdir): Likewise.
+	* io/chmod.c (__chmod): Likewise.
+	* io/chown.c (__chown): Likewise.
+	* io/close.c (__close): Likewise.
+	* io/creat.c (creat): Likewise.
+	* io/creat64.c (creat64): Likewise.
+	* io/dup.c (__dup): Likewise.
+	* io/dup2.c (__dup2): Likewise.
+	* io/dup3.c (__dup3): Likewise.
+	* io/euidaccess.c (__euidaccess): Likewise.
+	* io/faccessat.c (faccessat): Likewise.
+	* io/fchmod.c (__fchmod): Likewise.
+	* io/fchmodat.c (fchmodat): Likewise.
+	* io/fchown.c (__fchown): Likewise.
+	* io/fchownat.c (fchownat): Likewise.
+	* io/fcntl.c (__fcntl): Likewise.
+	* io/flock.c (__flock): Likewise.
+	* io/fts.c (fts_load): Likewise.
+	(fts_close): Likewise.
+	(fts_read): Likewise.
+	(fts_set): Likewise.
+	(fts_children): Likewise.
+	(fts_build): Likewise.
+	(fts_stat): Likewise.
+	(fts_sort): Likewise.
+	(fts_alloc): Likewise.
+	(fts_lfree): Likewise.
+	(fts_palloc): Likewise.
+	(fts_padjust): Likewise.
+	(fts_maxarglen): Likewise.
+	(fts_safe_changedir): Likewise.
+	* io/getwd.c (getwd): Likewise.
+	* io/isatty.c (__isatty): Likewise.
+	* io/lchown.c (__lchown): Likewise.
+	* io/link.c (__link): Likewise.
+	* io/linkat.c (linkat): Likewise.
+	* io/lseek.c (__libc_lseek): Likewise.
+	* io/mkdir.c (__mkdir): Likewise.
+	* io/mkdirat.c (mkdirat): Likewise.
+	* io/mkfifo.c (mkfifo): Likewise.
+	* io/mkfifoat.c (mkfifoat): Likewise.
+	* io/open.c (__libc_open): Likewise.
+	* io/open64.c (__libc_open64): Likewise.
+	* io/readlink.c (__readlink): Likewise.
+	* io/readlinkat.c (readlinkat): Likewise.
+	* io/rmdir.c (__rmdir): Likewise.
+	* io/symlink.c (__symlink): Likewise.
+	* io/symlinkat.c (symlinkat): Likewise.
+	* io/ttyname.c (ttyname): Likewise.
+	* io/ttyname_r.c (__ttyname_r): Likewise.
+	* io/umask.c (__umask): Likewise.
+	* io/unlink.c (__unlink): Likewise.
+	* io/unlinkat.c (unlinkat): Likewise.
+	* io/utime.c (utime): Likewise.
+	* libio/clearerr.c (clearerr): Likewise.
+	* libio/clearerr_u.c (clearerr_unlocked): Likewise.
+	* libio/feof.c (_IO_feof): Likewise.
+	* libio/feof_u.c (feof_unlocked): Likewise.
+	* libio/ferror.c (_IO_ferror): Likewise.
+	* libio/ferror_u.c (ferror_unlocked): Likewise.
+	* libio/filedoalloc.c (_IO_file_doallocate): Likewise.
+	* libio/fileno.c (__fileno): Likewise.
+	* libio/fputc.c (fputc): Likewise.
+	* libio/fputc_u.c (fputc_unlocked): Likewise.
+	* libio/fputwc.c (fputwc): Likewise.
+	* libio/fputwc_u.c (fputwc_unlocked): Likewise.
+	* libio/freopen.c (freopen): Likewise.
+	* libio/freopen64.c (freopen64): Likewise.
+	* libio/fseek.c (fseek): Likewise.
+	* libio/fseeko.c (fseeko): Likewise.
+	* libio/fseeko64.c (fseeko64): Likewise.
+	* libio/ftello.c (__ftello): Likewise.
+	* libio/ftello64.c (ftello64): Likewise.
+	* libio/fwide.c (fwide): Likewise.
+	* libio/genops.c (_IO_un_link): Likewise.
+	(_IO_link_in): Likewise.
+	(_IO_least_marker): Likewise.
+	(_IO_switch_to_main_get_area): Likewise.
+	(_IO_switch_to_backup_area): Likewise.
+	(_IO_switch_to_get_mode): Likewise.
+	(_IO_free_backup_area): Likewise.
+	(_IO_switch_to_put_mode): Likewise.
+	(__overflow): Likewise.
+	(__underflow): Likewise.
+	(__uflow): Likewise.
+	(_IO_setb): Likewise.
+	(_IO_doallocbuf): Likewise.
+	(_IO_default_underflow): Likewise.
+	(_IO_default_uflow): Likewise.
+	(_IO_default_xsputn): Likewise.
+	(_IO_sgetn): Likewise.
+	(_IO_default_xsgetn): Likewise.
+	(_IO_sync): Likewise.
+	(_IO_default_setbuf): Likewise.
+	(_IO_default_seekpos): Likewise.
+	(_IO_default_doallocate): Likewise.
+	(_IO_init): Likewise.
+	(_IO_old_init): Likewise.
+	(_IO_default_sync): Likewise.
+	(_IO_default_finish): Likewise.
+	(_IO_default_seekoff): Likewise.
+	(_IO_sputbackc): Likewise.
+	(_IO_sungetc): Likewise.
+	(_IO_set_column): Likewise.
+	(_IO_set_column): Likewise.
+	(_IO_adjust_column): Likewise.
+	(_IO_get_column): Likewise.
+	(_IO_init_marker): Likewise.
+	(_IO_remove_marker): Likewise.
+	(_IO_marker_difference): Likewise.
+	(_IO_marker_delta): Likewise.
+	(_IO_seekmark): Likewise.
+	(_IO_unsave_markers): Likewise.
+	(_IO_nobackup_pbackfail): Likewise.
+	(_IO_default_pbackfail): Likewise.
+	(_IO_default_seek): Likewise.
+	(_IO_default_stat): Likewise.
+	(_IO_default_read): Likewise.
+	(_IO_default_write): Likewise.
+	(_IO_default_showmanyc): Likewise.
+	(_IO_default_imbue): Likewise.
+	(_IO_iter_next): Likewise.
+	(_IO_iter_file): Likewise.
+	* libio/getc.c (_IO_getc): Likewise.
+	* libio/getwc.c (_IO_getwc): Likewise.
+	* libio/iofclose.c (_IO_new_fclose): Likewise.
+	* libio/iofdopen.c (_IO_new_fdopen): Likewise.
+	* libio/iofflush.c (_IO_fflush): Likewise.
+	* libio/iofflush_u.c (__fflush_unlocked): Likewise.
+	* libio/iofgetpos.c (_IO_new_fgetpos): Likewise.
+	* libio/iofgetpos64.c (_IO_new_fgetpos64): Likewise.
+	* libio/iofgets.c (_IO_fgets): Likewise.
+	* libio/iofgets_u.c (__fgets_unlocked): Likewise.
+	* libio/iofgetws.c (fgetws): Likewise.
+	* libio/iofgetws_u.c (fgetws_unlocked): Likewise.
+	* libio/iofopen64.c (_IO_fopen64): Likewise.
+	* libio/iofopncook.c (_IO_cookie_read): Likewise.
+	(_IO_cookie_write): Likewise.
+	(_IO_cookie_seek): Likewise.
+	(_IO_cookie_close): Likewise.
+	(_IO_cookie_seekoff): Likewise.
+	(_IO_old_cookie_seek): Likewise.
+	* libio/iofputs.c (_IO_fputs): Likewise.
+	* libio/iofputs_u.c (__fputs_unlocked): Likewise.
+	* libio/iofputws.c (fputws): Likewise.
+	* libio/iofputws_u.c (fputws_unlocked): Likewise.
+	* libio/iofread.c (_IO_fread): Likewise.
+	* libio/iofread_u.c (__fread_unlocked): Likewise.
+	* libio/iofsetpos.c (_IO_new_fsetpos): Likewise.
+	* libio/iofsetpos64.c (_IO_new_fsetpos64): Likewise.
+	* libio/ioftell.c (_IO_ftell): Likewise.
+	* libio/iofwrite.c (_IO_fwrite): Likewise.
+	* libio/iogetdelim.c (_IO_getdelim): Likewise.
+	* libio/iogets.c (_IO_gets): Likewise.
+	* libio/iopadn.c (_IO_padn): Likewise.
+	* libio/iopopen.c (_IO_new_proc_open): Likewise.
+	(_IO_new_popen): Likewise.
+	(_IO_new_proc_close): Likewise.
+	* libio/ioputs.c (_IO_puts): Likewise.
+	* libio/ioseekoff.c (_IO_seekoff_unlocked): Likewise.
+	(_IO_seekoff): Likewise.
+	* libio/ioseekpos.c (_IO_seekpos_unlocked): Likewise.
+	(_IO_seekpos): Likewise.
+	* libio/iosetbuffer.c (_IO_setbuffer): Likewise.
+	* libio/iosetvbuf.c (_IO_setvbuf): Likewise.
+	* libio/ioungetc.c (_IO_ungetc): Likewise.
+	* libio/ioungetwc.c (ungetwc): Likewise.
+	* libio/iovdprintf.c (_IO_vdprintf): Likewise.
+	* libio/iovsscanf.c (_IO_vsscanf): Likewise.
+	* libio/iowpadn.c (_IO_wpadn): Likewise.
+	* libio/libc_fatal.c (__libc_fatal): Likewise.
+	* libio/memstream.c (__open_memstream): Likewise.
+	(_IO_mem_sync): Likewise.
+	(_IO_mem_finish): Likewise.
+	* libio/oldfileops.c (_IO_old_file_init): Likewise.
+	(_IO_old_file_close_it): Likewise.
+	(_IO_old_file_finish): Likewise.
+	(_IO_old_file_fopen): Likewise.
+	(_IO_old_file_attach): Likewise.
+	(_IO_old_file_setbuf): Likewise.
+	(_IO_old_do_write): Likewise.
+	(old_do_write): Likewise.
+	(_IO_old_file_underflow): Likewise.
+	(_IO_old_file_overflow): Likewise.
+	(_IO_old_file_sync): Likewise.
+	(_IO_old_file_seekoff): Likewise.
+	(_IO_old_file_write): Likewise.
+	(_IO_old_file_xsputn): Likewise.
+	* libio/oldiofclose.c (_IO_old_fclose): Likewise.
+	* libio/oldiofdopen.c (_IO_old_fdopen): Likewise.
+	* libio/oldiofgetpos.c (_IO_old_fgetpos): Likewise.
+	* libio/oldiofgetpos64.c (_IO_old_fgetpos64): Likewise.
+	* libio/oldiofopen.c (_IO_old_fopen): Likewise.
+	* libio/oldiofsetpos.c (_IO_old_fsetpos): Likewise.
+	* libio/oldiofsetpos64.c (_IO_old_fsetpos64): Likewise.
+	* libio/oldiopopen.c (_IO_old_proc_open): Likewise.
+	(_IO_old_popen): Likewise.
+	(_IO_old_proc_close): Likewise.
+	* libio/oldpclose.c (__old_pclose): Likewise.
+	* libio/pclose.c (__new_pclose): Likewise.
+	* libio/peekc.c (_IO_peekc_locked): Likewise.
+	* libio/putc.c (_IO_putc): Likewise.
+	* libio/putc_u.c (putc_unlocked): Likewise.
+	* libio/putchar.c (putchar): Likewise.
+	* libio/putchar_u.c (putchar_unlocked): Likewise.
+	* libio/putwc.c (putwc): Likewise.
+	* libio/putwc_u.c (putwc_unlocked): Likewise.
+	* libio/putwchar.c (putwchar): Likewise.
+	* libio/putwchar_u.c (putwchar_unlocked): Likewise.
+	* libio/rewind.c (rewind): Likewise.
+	* libio/setbuf.c (setbuf): Likewise.
+	* libio/setlinebuf.c (setlinebuf): Likewise.
+	* libio/vasprintf.c (_IO_vasprintf): Likewise.
+	* libio/vscanf.c (_IO_vscanf): Likewise.
+	* libio/vsnprintf.c (_IO_strn_overflow): Likewise.
+	* libio/vswprintf.c (_IO_wstrn_overflow): Likewise.
+	* libio/wfiledoalloc.c (_IO_wfile_doallocate): Likewise.
+	* libio/wgenops.c (_IO_least_wmarker): Likewise.
+	(_IO_switch_to_main_wget_area): Likewise.
+	(_IO_switch_to_wbackup_area): Likewise.
+	(_IO_wsetb): Likewise.
+	(_IO_wdefault_pbackfail): Likewise.
+	(_IO_wdefault_finish): Likewise.
+	(_IO_wdefault_uflow): Likewise.
+	(__woverflow): Likewise.
+	(__wuflow): Likewise.
+	(__wunderflow): Likewise.
+	(_IO_wdefault_xsputn): Likewise.
+	(_IO_wdefault_xsgetn): Likewise.
+	(_IO_wdoallocbuf): Likewise.
+	(_IO_wdefault_doallocate): Likewise.
+	(_IO_switch_to_wget_mode): Likewise.
+	(_IO_free_wbackup_area): Likewise.
+	(_IO_switch_to_wput_mode): Likewise.
+	(_IO_sputbackwc): Likewise.
+	(_IO_sungetwc): Likewise.
+	(_IO_adjust_wcolumn): Likewise.
+	(_IO_init_wmarker): Likewise.
+	(_IO_wmarker_delta): Likewise.
+	(_IO_seekwmark): Likewise.
+	(_IO_unsave_wmarkers): Likewise.
+	* libio/wmemstream.c (open_wmemstream): Likewise.
+	(_IO_wmem_sync): Likewise.
+	(_IO_wmem_finish): Likewise.
+	* locale/nl_langinfo.c (nl_langinfo): Likewise.
+	* locale/nl_langinfo_l.c (__nl_langinfo_l): Likewise.
+	* locale/programs/simple-hash.c (init_hash): Likewise.
+	(delete_hash): Likewise.
+	(insert_entry): Likewise.
+	(set_entry): Likewise.
+	(next_prime): Likewise.
+	(is_prime): Likewise.
+	* locale/programs/xmalloc.c (fixup_null_alloc): Likewise.
+	(xmalloc): Likewise.
+	(xrealloc): Likewise.
+	* locale/programs/xstrdup.c (xstrdup): Likewise.
+	* localedata/collate-test.c (xstrcoll): Likewise.
+	* localedata/xfrm-test.c (xstrcmp): Likewise.
+	* login/getlogin_r.c (__getlogin_r): Likewise.
+	* login/getpt.c (__posix_openpt): Likewise.
+	* login/login_tty.c (login_tty): Likewise.
+	* login/setlogin.c (setlogin): Likewise.
+	* mach/msg-destroy.c (__mach_msg_destroy): Likewise.
+	(mach_msg_destroy_port): Likewise.
+	(mach_msg_destroy_memory): Likewise.
+	* malloc/mcheck.c (flood): Likewise.
+	* misc/acct.c (acct): Likewise.
+	* misc/brk.c (__brk): Likewise.
+	* misc/chflags.c (chflags): Likewise.
+	* misc/chroot.c (chroot): Likewise.
+	* misc/fchflags.c (fchflags): Likewise.
+	* misc/fstab.c (getfsspec): Likewise.
+	(getfsfile): Likewise.
+	* misc/fsync.c (fsync): Likewise.
+	* misc/ftruncate.c (__ftruncate): Likewise.
+	* misc/ftruncate64.c (__ftruncate64): Likewise.
+	* misc/getdomain.c (getdomainname): Likewise.
+	(getdomainname): Likewise.
+	* misc/gethostname.c (__gethostname): Likewise.
+	* misc/getpass.c (getpass): Likewise.
+	* misc/getttyent.c (skip): Likewise.
+	(value): Likewise.
+	* misc/gtty.c (gtty): Likewise.
+	* misc/hsearch.c (hsearch): Likewise.
+	(hcreate): Likewise.
+	* misc/hsearch_r.c (__hcreate_r): Likewise.
+	(__hdestroy_r): Likewise.
+	* misc/ioctl.c (__ioctl): Likewise.
+	* misc/mkdtemp.c (mkdtemp): Likewise.
+	* misc/mkostemp.c (mkostemp): Likewise.
+	* misc/mkostemp64.c (mkostemp64): Likewise.
+	* misc/mkostemps.c (mkostemps): Likewise.
+	* misc/mkostemps64.c (mkostemps64): Likewise.
+	* misc/mkstemp.c (mkstemp): Likewise.
+	* misc/mkstemp64.c (mkstemp64): Likewise.
+	* misc/mkstemps.c (mkstemps): Likewise.
+	* misc/mkstemps64.c (mkstemps64): Likewise.
+	* misc/mktemp.c (__mktemp): Likewise.
+	* misc/preadv.c (preadv): Likewise.
+	* misc/preadv64.c (preadv64): Likewise.
+	* misc/pwritev.c (pwritev): Likewise.
+	* misc/pwritev64.c (pwritev64): Likewise.
+	* misc/readv.c (__readv): Likewise.
+	* misc/revoke.c (revoke): Likewise.
+	* misc/setdomain.c (setdomainname): Likewise.
+	* misc/setegid.c (setegid): Likewise.
+	* misc/seteuid.c (seteuid): Likewise.
+	* misc/sethostid.c (sethostid): Likewise.
+	* misc/sethostname.c (sethostname): Likewise.
+	* misc/setregid.c (__setregid): Likewise.
+	* misc/setreuid.c (__setreuid): Likewise.
+	* misc/sstk.c (sstk): Likewise.
+	* misc/stty.c (stty): Likewise.
+	* misc/syscall.c (syscall): Likewise.
+	* misc/syslog.c (setlogmask): Likewise.
+	* misc/truncate.c (__truncate): Likewise.
+	* misc/truncate64.c (truncate64): Likewise.
+	* misc/ualarm.c (ualarm): Likewise.
+	* misc/usleep.c (usleep): Likewise.
+	* misc/ustat.c (ustat): Likewise.
+	* misc/writev.c (__writev): Likewise.
+	* nptl/cleanup_compat.c (_pthread_cleanup_pop): Likewise.
+	* nptl/old_pthread_cond_broadcast.c
+	(__pthread_cond_broadcast_2_0): Likewise.
+	* nptl/old_pthread_cond_destroy.c (__pthread_cond_destroy_2_0):
+	Likewise.
+	* nptl/old_pthread_cond_signal.c (__pthread_cond_signal_2_0):
+	Likewise.
+	* nptl/old_pthread_cond_wait.c (__pthread_cond_wait_2_0):
+	Likewise.
+	* nptl/pt-raise.c (raise): Likewise.
+	* nptl/pthread_barrier_destroy.c (pthread_barrier_destroy):
+	Likewise.
+	* nptl/pthread_barrier_wait.c (__pthread_barrier_wait): Likewise.
+	* nptl/pthread_barrierattr_destroy.c
+	(pthread_barrierattr_destroy): Likewise.
+	* nptl/pthread_barrierattr_init.c (pthread_barrierattr_init):
+	Likewise.
+	* nptl/pthread_barrierattr_setpshared.c
+	(pthread_barrierattr_setpshared): Likewise.
+	* nptl/pthread_cond_broadcast.c (__pthread_cond_broadcast):
+	Likewise.
+	* nptl/pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
+	* nptl/pthread_cond_init.c (__pthread_cond_init): Likewise.
+	* nptl/pthread_cond_signal.c (__pthread_cond_signal): Likewise.
+	* nptl/pthread_condattr_destroy.c (__pthread_condattr_destroy):
+	Likewise.
+	* nptl/pthread_condattr_getclock.c (pthread_condattr_getclock):
+	Likewise.
+	* nptl/pthread_condattr_getpshared.c
+	(pthread_condattr_getpshared): Likewise.
+	* nptl/pthread_condattr_init.c (__pthread_condattr_init):
+	Likewise.
+	* nptl/pthread_condattr_setpshared.c
+	(pthread_condattr_setpshared): Likewise.
+	* nptl/pthread_detach.c (pthread_detach): Likewise.
+	* nptl/pthread_equal.c (__pthread_equal): Likewise.
+	* nptl/pthread_getcpuclockid.c (pthread_getcpuclockid): Likewise.
+	* nptl/pthread_getspecific.c (__pthread_getspecific): Likewise.
+	* nptl/pthread_key_delete.c (pthread_key_delete): Likewise.
+	* nptl/pthread_mutex_consistent.c (pthread_mutex_consistent):
+	Likewise.
+	* nptl/pthread_mutex_destroy.c (__pthread_mutex_destroy):
+	Likewise.
+	* nptl/pthread_mutex_getprioceiling.c
+	(pthread_mutex_getprioceiling): Likewise.
+	* nptl/pthread_mutexattr_destroy.c (__pthread_mutexattr_destroy):
+	Likewise.
+	* nptl/pthread_mutexattr_getprotocol.c
+	(pthread_mutexattr_getprotocol): Likewise.
+	* nptl/pthread_mutexattr_getpshared.c
+	(pthread_mutexattr_getpshared): Likewise.
+	* nptl/pthread_mutexattr_getrobust.c
+	(pthread_mutexattr_getrobust): Likewise.
+	* nptl/pthread_mutexattr_gettype.c (pthread_mutexattr_gettype):
+	Likewise.
+	* nptl/pthread_mutexattr_init.c (__pthread_mutexattr_init):
+	Likewise.
+	* nptl/pthread_mutexattr_setprioceiling.c
+	(pthread_mutexattr_setprioceiling): Likewise.
+	* nptl/pthread_mutexattr_setprotocol.c
+	(pthread_mutexattr_setprotocol): Likewise.
+	* nptl/pthread_mutexattr_setpshared.c
+	(pthread_mutexattr_setpshared): Likewise.
+	* nptl/pthread_mutexattr_setrobust.c
+	(pthread_mutexattr_setrobust): Likewise.
+	* nptl/pthread_mutexattr_settype.c (__pthread_mutexattr_settype):
+	Likewise.
+	* nptl/pthread_rwlock_destroy.c (__pthread_rwlock_destroy):
+	Likewise.
+	* nptl/pthread_rwlockattr_destroy.c (pthread_rwlockattr_destroy):
+	Likewise.
+	* nptl/pthread_rwlockattr_getkind_np.c
+	(pthread_rwlockattr_getkind_np): Likewise.
+	* nptl/pthread_rwlockattr_getpshared.c
+	(pthread_rwlockattr_getpshared): Likewise.
+	* nptl/pthread_rwlockattr_init.c (pthread_rwlockattr_init):
+	Likewise.
+	* nptl/pthread_rwlockattr_setkind_np.c
+	(pthread_rwlockattr_setkind_np): Likewise.
+	* nptl/pthread_rwlockattr_setpshared.c
+	(pthread_rwlockattr_setpshared): Likewise.
+	* nptl/pthread_setcancelstate.c (__pthread_setcancelstate):
+	Likewise.
+	* nptl/pthread_setcanceltype.c (__pthread_setcanceltype):
+	Likewise.
+	* nptl/pthread_setconcurrency.c (pthread_setconcurrency):
+	Likewise.
+	* nptl/pthread_setschedprio.c (pthread_setschedprio): Likewise.
+	* nptl/pthread_setspecific.c (__pthread_setspecific): Likewise.
+	* nptl/pthread_spin_destroy.c (pthread_spin_destroy): Likewise.
+	* nptl/pthread_tryjoin.c (pthread_tryjoin_np): Likewise.
+	* nptl/sem_close.c (sem_close): Likewise.
+	* nptl/sem_destroy.c (__new_sem_destroy): Likewise.
+	* nptl/sem_init.c (__old_sem_init): Likewise.
+	* nptl/sigaction.c (__sigaction): Likewise.
+	* nptl/unregister-atfork.c (__unregister_atfork): Likewise.
+	* posix/_exit.c (_exit): Likewise.
+	* posix/alarm.c (alarm): Likewise.
+	* posix/confstr.c (confstr): Likewise.
+	* posix/fpathconf.c (__fpathconf): Likewise.
+	* posix/getgroups.c (__getgroups): Likewise.
+	* posix/getpgid.c (__getpgid): Likewise.
+	* posix/group_member.c (__group_member): Likewise.
+	* posix/pathconf.c (__pathconf): Likewise.
+	* posix/sched_getaffinity.c (sched_getaffinity): Likewise.
+	* posix/sched_setaffinity.c (sched_setaffinity): Likewise.
+	* posix/setgid.c (__setgid): Likewise.
+	* posix/setpgid.c (__setpgid): Likewise.
+	* posix/setuid.c (__setuid): Likewise.
+	* posix/sleep.c (__sleep): Likewise.
+	* posix/sysconf.c (__sysconf): Likewise.
+	* posix/times.c (__times): Likewise.
+	* posix/uname.c (__uname): Likewise.
+	* posix/waitid.c (__waitid): Likewise.
+	* pwd/getpw.c (__getpw): Likewise.
+	* resolv/base64.c (b64_pton): Likewise.
+	* resolv/gai_sigqueue.c (__gai_sigqueue): Likewise.
+	* resolv/gethnamaddr.c (Dprintf): Likewise.
+	(gethostbyname): Likewise.
+	(gethostbyname2): Likewise.
+	(gethostbyaddr): Likewise.
+	(_sethtent): Likewise.
+	(_gethtbyname): Likewise.
+	(_gethtbyname2): Likewise.
+	(_gethtbyaddr): Likewise.
+	(map_v4v6_address): Likewise.
+	(map_v4v6_hostent): Likewise.
+	(addrsort): Likewise.
+	(ht_sethostent): Likewise.
+	(ht_gethostbyname): Likewise.
+	(ht_gethostbyaddr): Likewise.
+	* resolv/inet_net_ntop.c (inet_net_ntop): Likewise.
+	(inet_net_ntop_ipv4): Likewise.
+	* resolv/inet_neta.c (inet_neta): Likewise.
+	* resolv/inet_ntop.c (inet_ntop): Likewise.
+	(inet_ntop4): Likewise.
+	(inet_ntop6): Likewise.
+	* resolv/inet_pton.c (__inet_pton): Likewise.
+	(inet_pton4): Likewise.
+	(inet_pton6): Likewise.
+	* resolv/res_debug.c (loc_aton): Likewise.
+	(loc_ntoa): Likewise.
+	* resource/getpriority.c (__getpriority): Likewise.
+	* resource/getrusage.c (__getrusage): Likewise.
+	* resource/nice.c (nice): Likewise.
+	* resource/setpriority.c (__setpriority): Likewise.
+	* resource/setrlimit64.c (setrlimit64): Likewise.
+	* resource/vlimit.c (vlimit): Likewise.
+	* resource/vtimes.c (vtimes): Likewise.
+	* rt/aio_error.c (aio_error): Likewise.
+	* rt/aio_return.c (aio_return): Likewise.
+	* rt/aio_sigqueue.c (__aio_sigqueue): Likewise.
+	* signal/kill.c (__kill): Likewise.
+	* signal/killpg.c (killpg): Likewise.
+	* signal/raise.c (raise): Likewise.
+	* signal/sigaction.c (__sigaction): Likewise.
+	* signal/sigaddset.c (sigaddset): Likewise.
+	* signal/sigaltstack.c (sigaltstack): Likewise.
+	* signal/sigandset.c (sigandset): Likewise.
+	* signal/sigblock.c (__sigblock): Likewise.
+	* signal/sigdelset.c (sigdelset): Likewise.
+	* signal/sigempty.c (sigemptyset): Likewise.
+	* signal/sigfillset.c (sigfillset): Likewise.
+	* signal/sighold.c (sighold): Likewise.
+	* signal/sigignore.c (sigignore): Likewise.
+	* signal/sigintr.c (siginterrupt): Likewise.
+	* signal/sigisempty.c (sigisemptyset): Likewise.
+	* signal/sigismem.c (sigismember): Likewise.
+	* signal/signal.c (signal): Likewise.
+	* signal/sigorset.c (sigorset): Likewise.
+	* signal/sigpause.c (__sigpause): Likewise.
+	* signal/sigpending.c (sigpending): Likewise.
+	* signal/sigprocmask.c (__sigprocmask): Likewise.
+	* signal/sigrelse.c (sigrelse): Likewise.
+	* signal/sigreturn.c (__sigreturn): Likewise.
+	* signal/sigset.c (sigset): Likewise.
+	* signal/sigsetmask.c (__sigsetmask): Likewise.
+	* signal/sigstack.c (sigstack): Likewise.
+	* signal/sigsuspend.c (__sigsuspend): Likewise.
+	* signal/sigvec.c (sigvec_wrapper_handler): Likewise.
+	* signal/sysv_signal.c (__sysv_signal): Likewise.
+	* socket/accept.c (accept): Likewise.
+	* socket/accept4.c (__libc_accept4): Likewise.
+	* socket/bind.c (__bind): Likewise.
+	* socket/connect.c (__connect): Likewise.
+	* socket/getpeername.c (getpeername): Likewise.
+	* socket/getsockname.c (__getsockname): Likewise.
+	* socket/getsockopt.c (getsockopt): Likewise.
+	* socket/listen.c (__listen): Likewise.
+	* socket/recv.c (__recv): Likewise.
+	* socket/recvmsg.c (__recvmsg): Likewise.
+	* socket/send.c (__send): Likewise.
+	* socket/sendmsg.c (__sendmsg): Likewise.
+	* socket/shutdown.c (shutdown): Likewise.
+	* socket/sockatmark.c (sockatmark): Likewise.
+	* socket/socket.c (__socket): Likewise.
+	* stdio-common/ctermid.c (ctermid): Likewise.
+	* stdio-common/cuserid.c (cuserid): Likewise.
+	* stdio-common/printf-prs.c (parse_printf_format): Likewise.
+	* stdio-common/remove.c (remove): Likewise.
+	* stdio-common/rename.c (rename): Likewise.
+	* stdio-common/renameat.c (renameat): Likewise.
+	* stdio-common/tempname.c (__gen_tempname): Likewise.
+	* stdio-common/xbug.c (InitBuffer): Likewise.
+	(AppendToBuffer): Likewise.
+	(ReadFile): Likewise.
+	* stdlib/a64l.c (a64l): Likewise.
+	* stdlib/drand48_r.c (drand48_r): Likewise.
+	* stdlib/getcontext.c (getcontext): Likewise.
+	* stdlib/getenv.c (getenv): Likewise.
+	* stdlib/l64a.c (l64a): Likewise.
+	* stdlib/llabs.c (llabs): Likewise.
+	* stdlib/lldiv.c (lldiv): Likewise.
+	* stdlib/lrand48_r.c (lrand48_r): Likewise.
+	* stdlib/mrand48_r.c (mrand48_r): Likewise.
+	* stdlib/putenv.c (putenv): Likewise.
+	* stdlib/random.c (__srandom): Likewise.
+	(__initstate): Likewise.
+	(__setstate): Likewise.
+	* stdlib/random_r.c (__srandom_r): Likewise.
+	(__setstate_r): Likewise.
+	(__random_r): Likewise.
+	* stdlib/secure-getenv.c (__libc_secure_getenv): Likewise.
+	* stdlib/setcontext.c (setcontext): Likewise.
+	* stdlib/setenv.c (setenv): Likewise.
+	(unsetenv): Likewise.
+	* stdlib/srand48.c (srand48): Likewise.
+	* stdlib/srand48_r.c (__srand48_r): Likewise.
+	* stdlib/swapcontext.c (swapcontext): Likewise.
+	* stdlib/system.c (__libc_system): Likewise.
+	* stdlib/tst-strtod.c (expand): Likewise.
+	* stdlib/tst-strtol.c (expand): Likewise.
+	* stdlib/tst-strtoll.c (expand): Likewise.
+	* streams/fattach.c (fattach): Likewise.
+	* streams/fdetach.c (fdetach): Likewise.
+	* streams/getmsg.c (getmsg): Likewise.
+	* streams/isastream.c (isastream): Likewise.
+	* string/ffs.c (__ffs): Likewise.
+	* string/ffsll.c (ffsll): Likewise.
+	* string/memcmp.c (memcmp_common_alignment): Likewise.
+	(memcmp_not_common_alignment): Likewise.
+	(MEMCMP): Likewise.
+	* string/memcpy.c (memcpy): Likewise.
+	* string/memmove.c (MEMMOVE): Likewise.
+	* string/memset.c (memset): Likewise.
+	* string/rawmemchr.c (RAWMEMCHR): Likewise.
+	* string/strchrnul.c (STRCHRNUL): Likewise.
+	* string/strerror.c (strerror): Likewise.
+	* string/strndup.c (__strndup): Likewise.
+	* string/strverscmp.c (__strverscmp): Likewise.
+	* sunrpc/clnt_raw.c (clntraw_freeres): Likewise.
+	* sunrpc/clnt_tcp.c (clnttcp_geterr): Likewise.
+	(clnttcp_freeres): Likewise.
+	* sunrpc/clnt_unix.c (clntunix_freeres): Likewise.
+	* sunrpc/pmap_prot.c (xdr_pmap): Likewise.
+	* sunrpc/pmap_prot2.c (xdr_pmaplist): Likewise.
+	* sunrpc/pmap_rmt.c (xdr_rmtcallres): Likewise.
+	* sunrpc/rpc_prot.c (xdr_replymsg): Likewise.
+	(xdr_callhdr): Likewise.
+	* sunrpc/rpcinfo.c (udpping): Likewise.
+	(tcpping): Likewise.
+	(pstatus): Likewise.
+	(pmapdump): Likewise.
+	(brdcst): Likewise.
+	(deletereg): Likewise.
+	(getprognum): Likewise.
+	(getvers): Likewise.
+	(get_inet_address): Likewise.
+	* sunrpc/svc_raw.c (svcraw_recv): Likewise.
+	* sunrpc/svc_udp.c (svcudp_create): Likewise.
+	(svcudp_stat): Likewise.
+	(svcudp_recv): Likewise.
+	(svcudp_reply): Likewise.
+	(svcudp_getargs): Likewise.
+	(svcudp_freeargs): Likewise.
+	(svcudp_destroy): Likewise.
+	* sunrpc/xdr.c (xdr_bytes): Likewise.
+	(xdr_netobj): Likewise.
+	(xdr_string): Likewise.
+	(xdr_wrapstring): Likewise.
+	* sunrpc/xdr_float.c (xdr_float): Likewise.
+	(xdr_double): Likewise.
+	* sunrpc/xdr_mem.c (xdrmem_setpos): Likewise.
+	* sunrpc/xdr_ref.c (xdr_pointer): Likewise.
+	* sysvipc/ftok.c (ftok): Likewise.
+	* sysvipc/msgctl.c (msgctl): Likewise.
+	* sysvipc/msgget.c (msgget): Likewise.
+	* sysvipc/msgrcv.c (msgrcv): Likewise.
+	* sysvipc/msgsnd.c (msgsnd): Likewise.
+	* sysvipc/semget.c (semget): Likewise.
+	* sysvipc/semop.c (semop): Likewise.
+	* sysvipc/shmat.c (shmat): Likewise.
+	* sysvipc/shmctl.c (shmctl): Likewise.
+	* sysvipc/shmdt.c (shmdt): Likewise.
+	* sysvipc/shmget.c (shmget): Likewise.
+	* termios/cfmakeraw.c (cfmakeraw): Likewise.
+	* termios/speed.c (cfgetospeed): Likewise.
+	(cfgetispeed): Likewise.
+	(cfsetospeed): Likewise.
+	(cfsetispeed): Likewise.
+	* termios/tcflow.c (tcflow): Likewise.
+	* termios/tcflush.c (tcflush): Likewise.
+	* termios/tcgetattr.c (__tcgetattr): Likewise.
+	* termios/tcgetpgrp.c (tcgetpgrp): Likewise.
+	* termios/tcgetsid.c (tcgetsid): Likewise.
+	* termios/tcsendbrk.c (tcsendbreak): Likewise.
+	* termios/tcsetpgrp.c (tcsetpgrp): Likewise.
+	* time/adjtime.c (__adjtime): Likewise.
+	* time/dysize.c (dysize): Likewise.
+	* time/ftime.c (ftime): Likewise.
+	* time/getitimer.c (__getitimer): Likewise.
+	* time/gettimeofday.c (__gettimeofday): Likewise.
+	* time/gmtime.c (__gmtime_r): Likewise.
+	(gmtime): Likewise.
+	* time/localtime.c (__localtime_r): Likewise.
+	(localtime): Likewise.
+	* time/offtime.c (__offtime): Likewise.
+	* time/settimeofday.c (__settimeofday): Likewise.
+	* time/stime.c (stime): Likewise.
+	* time/strftime_l.c (tm_diff): Likewise.
+	(iso_week_days): Likewise.
+	* time/strptime.c (strptime): Likewise.
+	* time/time.c (time): Likewise.
+	* time/timespec_get.c (timespec_get): Likewise.
+	* time/tzset.c (tzset_internal): Likewise.
+	(compute_change): Likewise.
+	(__tz_compute): Likewise.
+	* wcsmbs/btowc.c (__btowc): Likewise.
+	* wcsmbs/mbrlen.c (__mbrlen): Likewise.
+	* wcsmbs/mbsinit.c (__mbsinit): Likewise.
+	* wcsmbs/mbsrtowcs.c (__mbsrtowcs): Likewise.
+	* wcsmbs/wcpcpy.c (__wcpcpy): Likewise.
+	* wcsmbs/wcpncpy.c (__wcpncpy): Likewise.
+	* wcsmbs/wcscat.c (__wcscat): Likewise.
+	* wcsmbs/wcschrnul.c (__wcschrnul): Likewise.
+	* wcsmbs/wcscmp.c (WCSCMP): Likewise.
+	* wcsmbs/wcscpy.c (WCSCPY): Likewise.
+	* wcsmbs/wcscspn.c (wcscspn): Likewise.
+	* wcsmbs/wcsdup.c (wcsdup): Likewise.
+	* wcsmbs/wcslen.c (__wcslen): Likewise.
+	* wcsmbs/wcsncat.c (WCSNCAT): Likewise.
+	* wcsmbs/wcsncmp.c (WCSNCMP): Likewise.
+	* wcsmbs/wcsncpy.c (__wcsncpy): Likewise.
+	* wcsmbs/wcsnlen.c (__wcsnlen): Likewise.
+	* wcsmbs/wcspbrk.c (wcspbrk): Likewise.
+	* wcsmbs/wcsrchr.c (WCSRCHR): Likewise.
+	* wcsmbs/wcsspn.c (wcsspn): Likewise.
+	* wcsmbs/wcsstr.c (wcsstr): Likewise.
+	* wcsmbs/wcstok.c (wcstok): Likewise.
+	* wcsmbs/wctob.c (wctob): Likewise.
+	* wcsmbs/wmemchr.c (__wmemchr): Likewise.
+	* wcsmbs/wmemcmp.c (WMEMCMP): Likewise.
+	* wcsmbs/wmemcpy.c (__wmemcpy): Likewise.
+	* wcsmbs/wmemmove.c (__wmemmove): Likewise.
+	* wcsmbs/wmempcpy.c (__wmempcpy): Likewise.
+	* wcsmbs/wmemset.c (__wmemset): Likewise.
+	* wctype/wcfuncs.c (__towlower): Likewise.
+	(__towupper): Likewise.
+
 	* sysdeps/unix/sysv/linux/i386/lowlevellock.h
 	(lll_unlock_elision): Add adapt_count parameter.
 
diff --git a/crypt/cert.c b/crypt/cert.c
index 8c838e9..d651108 100644
--- a/crypt/cert.c
+++ b/crypt/cert.c
@@ -17,7 +17,8 @@ void get8 (char *cp);
 void put8 (char *cp);
 void good_bye (void) __attribute__ ((noreturn));
 
-void good_bye ()
+void
+good_bye (void)
 {
   if(totfails == 0) {
     printf("Passed DES validation suite\n");
@@ -80,8 +81,7 @@ main(argc, argv)
 	good_bye();
 }
 void
-get8(cp)
-char *cp;
+get8 (char *cp)
 {
 	int i,j,t;
 
@@ -95,8 +95,7 @@ char *cp;
 	}
 }
 void
-put8(cp)
-char *cp;
+put8 (char *cp)
 {
 	int i,j,t;
 
diff --git a/crypt/crypt-entry.c b/crypt/crypt-entry.c
index 7e655ba..73b369c 100644
--- a/crypt/crypt-entry.c
+++ b/crypt/crypt-entry.c
@@ -148,9 +148,7 @@ __crypt_r (key, salt, data)
 weak_alias (__crypt_r, crypt_r)
 
 char *
-crypt (key, salt)
-     const char *key;
-     const char *salt;
+crypt (const char *key, const char *salt)
 {
 #ifdef _LIBC
   /* Try to find out whether we have to use MD5 encryption replacement.  */
@@ -180,9 +178,7 @@ crypt (key, salt)
 weak_alias (crypt, fcrypt)
 #else
 char *
-__fcrypt (key, salt)
-     const char *key;
-     const char *salt;
+__fcrypt (const char *key, const char *salt)
 {
   return crypt (key, salt);
 }
diff --git a/crypt/crypt_util.c b/crypt/crypt_util.c
index b96ecc8..33d894a 100644
--- a/crypt/crypt_util.c
+++ b/crypt/crypt_util.c
@@ -261,9 +261,7 @@ __libc_lock_define_initialized (static, _ufc_tables_lock)
 #ifdef DEBUG
 
 void
-_ufc_prbits(a, n)
-     ufc_long *a;
-     int n;
+_ufc_prbits (ufc_long *a, int n)
 {
   ufc_long i, j, t, tmp;
   n /= 8;
@@ -279,9 +277,7 @@ _ufc_prbits(a, n)
 }
 
 static void
-_ufc_set_bits(v, b)
-     ufc_long v;
-     ufc_long *b;
+_ufc_set_bits (ufc_long v, ufc_long *b)
 {
   ufc_long i;
   *b = 0;
@@ -301,9 +297,7 @@ _ufc_set_bits(v, b)
  */
 
 void
-_ufc_clearmem(start, cnt)
-     char *start;
-     int cnt;
+_ufc_clearmem (char *start, int cnt)
 {
   while(cnt--)
     *start++ = '\0';
@@ -332,8 +326,7 @@ _ufc_copymem(from, to, cnt)
  */
 
 void
-__init_des_r(__data)
-     struct crypt_data * __restrict __data;
+__init_des_r (struct crypt_data * __restrict __data)
 {
   int comes_from_bit;
   int bit, sg;
@@ -558,9 +551,7 @@ __init_des (void)
 
 #ifdef _UFC_32_
 STATIC void
-shuffle_sb(k, saltbits)
-     long32 *k;
-     ufc_long saltbits;
+shuffle_sb (long32 *k, ufc_long saltbits)
 {
   ufc_long j;
   long32 x;
@@ -574,9 +565,7 @@ shuffle_sb(k, saltbits)
 
 #ifdef _UFC_64_
 STATIC void
-shuffle_sb(k, saltbits)
-     long64 *k;
-     ufc_long saltbits;
+shuffle_sb (long64 *k, ufc_long saltbits)
 {
   ufc_long j;
   long64 x;
@@ -614,9 +603,7 @@ bad_for_salt (char c)
  */
 
 bool
-_ufc_setup_salt_r(s, __data)
-     const char *s;
-     struct crypt_data * __restrict __data;
+_ufc_setup_salt_r (const char *s, struct crypt_data * __restrict __data)
 {
   ufc_long i, j, saltbits;
   char s0, s1;
@@ -675,9 +662,7 @@ _ufc_setup_salt_r(s, __data)
 }
 
 void
-_ufc_mk_keytab_r(key, __data)
-     const char *key;
-     struct crypt_data * __restrict __data;
+_ufc_mk_keytab_r (const char *key, struct crypt_data * __restrict __data)
 {
   ufc_long v1, v2, *k1;
   int i;
@@ -735,9 +720,7 @@ _ufc_mk_keytab_r(key, __data)
  */
 
 void
-_ufc_dofinalperm_r(res, __data)
-     ufc_long *res;
-     struct crypt_data * __restrict __data;
+_ufc_dofinalperm_r (ufc_long *res, struct crypt_data * __restrict __data)
 {
   ufc_long v1, v2, x;
   ufc_long l1,l2,r1,r2;
@@ -910,9 +893,7 @@ __encrypt_r(__block, __edflag, __data)
 weak_alias (__encrypt_r, encrypt_r)
 
 void
-encrypt(__block, __edflag)
-     char *__block;
-     int __edflag;
+encrypt (char *__block, int __edflag)
 {
   __encrypt_r(__block, __edflag, &_ufc_foobar);
 }
@@ -924,9 +905,7 @@ encrypt(__block, __edflag)
  */
 
 void
-__setkey_r(__key, __data)
-     const char *__key;
-     struct crypt_data * __restrict __data;
+__setkey_r (const char *__key, struct crypt_data * __restrict __data)
 {
   int i,j;
   unsigned char c;
@@ -944,8 +923,7 @@ __setkey_r(__key, __data)
 weak_alias (__setkey_r, setkey_r)
 
 void
-setkey(__key)
-     const char *__key;
+setkey (const char *__key)
 {
   __setkey_r(__key, &_ufc_foobar);
 }
diff --git a/crypt/md5.c b/crypt/md5.c
index 3c447c5..5c48f52 100644
--- a/crypt/md5.c
+++ b/crypt/md5.c
@@ -67,8 +67,7 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
 void
-md5_init_ctx (ctx)
-     struct md5_ctx *ctx;
+md5_init_ctx (struct md5_ctx *ctx)
 {
   ctx->A = 0x67452301;
   ctx->B = 0xefcdab89;
@@ -85,9 +84,7 @@ md5_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-md5_read_ctx (ctx, resbuf)
-     const struct md5_ctx *ctx;
-     void *resbuf;
+md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 {
   ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
   ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
@@ -103,9 +100,7 @@ md5_read_ctx (ctx, resbuf)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-md5_finish_ctx (ctx, resbuf)
-     struct md5_ctx *ctx;
-     void *resbuf;
+md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   md5_uint32 bytes = ctx->buflen;
@@ -134,9 +129,7 @@ md5_finish_ctx (ctx, resbuf)
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
 int
-md5_stream (stream, resblock)
-     FILE *stream;
-     void *resblock;
+md5_stream (FILE *stream, void *resblock)
 {
   /* Important: BLOCKSIZE must be a multiple of 64.  */
 #define BLOCKSIZE 4096
@@ -191,10 +184,7 @@ md5_stream (stream, resblock)
    output yields to the wanted ASCII representation of the message
    digest.  */
 void *
-md5_buffer (buffer, len, resblock)
-     const char *buffer;
-     size_t len;
-     void *resblock;
+md5_buffer (const char *buffer, size_t len, void *resblock)
 {
   struct md5_ctx ctx;
 
@@ -210,10 +200,7 @@ md5_buffer (buffer, len, resblock)
 
 
 void
-md5_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct md5_ctx *ctx;
+md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
diff --git a/crypt/sha256.c b/crypt/sha256.c
index b6db8b2..8241de5 100644
--- a/crypt/sha256.c
+++ b/crypt/sha256.c
@@ -87,8 +87,7 @@ sha256_process_block (const void *, size_t, struct sha256_ctx *);
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.2)  */
 void
-__sha256_init_ctx (ctx)
-     struct sha256_ctx *ctx;
+__sha256_init_ctx (struct sha256_ctx *ctx)
 {
   ctx->H[0] = 0x6a09e667;
   ctx->H[1] = 0xbb67ae85;
@@ -110,9 +109,7 @@ __sha256_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-__sha256_finish_ctx (ctx, resbuf)
-     struct sha256_ctx *ctx;
-     void *resbuf;
+__sha256_finish_ctx (struct sha256_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint32_t bytes = ctx->buflen;
@@ -145,10 +142,7 @@ __sha256_finish_ctx (ctx, resbuf)
 
 
 void
-__sha256_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct sha256_ctx *ctx;
+__sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
diff --git a/crypt/sha512.c b/crypt/sha512.c
index 608de82..8aa3d0b 100644
--- a/crypt/sha512.c
+++ b/crypt/sha512.c
@@ -107,8 +107,7 @@ sha512_process_block (const void *buffer, size_t len, struct sha512_ctx *ctx);
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.3)  */
 void
-__sha512_init_ctx (ctx)
-     struct sha512_ctx *ctx;
+__sha512_init_ctx (struct sha512_ctx *ctx)
 {
   ctx->H[0] = UINT64_C (0x6a09e667f3bcc908);
   ctx->H[1] = UINT64_C (0xbb67ae8584caa73b);
@@ -130,9 +129,7 @@ __sha512_init_ctx (ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
 void *
-__sha512_finish_ctx (ctx, resbuf)
-     struct sha512_ctx *ctx;
-     void *resbuf;
+__sha512_finish_ctx (struct sha512_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint64_t bytes = ctx->buflen;
@@ -167,10 +164,7 @@ __sha512_finish_ctx (ctx, resbuf)
 
 
 void
-__sha512_process_bytes (buffer, len, ctx)
-     const void *buffer;
-     size_t len;
-     struct sha512_ctx *ctx;
+__sha512_process_bytes (const void *buffer, size_t len, struct sha512_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
diff --git a/ctype/isctype.c b/ctype/isctype.c
index 39a2f32..355152a 100644
--- a/ctype/isctype.c
+++ b/ctype/isctype.c
@@ -20,9 +20,7 @@
 #undef __isctype
 
 int
-__isctype (ch, mask)
-     int ch;
-     int mask;
+__isctype (int ch, int mask)
 {
   return (((uint16_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_CLASS) + 128)
 	  [(int) (ch)] & mask);
diff --git a/debug/backtrace.c b/debug/backtrace.c
index 062f698..8a301d0 100644
--- a/debug/backtrace.c
+++ b/debug/backtrace.c
@@ -58,9 +58,7 @@
 #endif
 
 int
-__backtrace (array, size)
-     void **array;
-     int size;
+__backtrace (void **array, int size)
 {
   struct layout *current;
   void *top_frame;
diff --git a/debug/backtracesymsfd.c b/debug/backtracesymsfd.c
index c554dfe..8a8beb7 100644
--- a/debug/backtracesymsfd.c
+++ b/debug/backtracesymsfd.c
@@ -33,10 +33,7 @@
 
 
 void
-__backtrace_symbols_fd (array, size, fd)
-     void *const *array;
-     int size;
-     int fd;
+__backtrace_symbols_fd (void *const *array, int size, int fd)
 {
   struct iovec iov[9];
   int cnt;
diff --git a/debug/fgets_chk.c b/debug/fgets_chk.c
index 10aaf48..b0685c0 100644
--- a/debug/fgets_chk.c
+++ b/debug/fgets_chk.c
@@ -29,11 +29,7 @@
 #include <sys/param.h>
 
 char *
-__fgets_chk (buf, size, n, fp)
-     char *buf;
-     size_t size;
-     int n;
-     _IO_FILE *fp;
+__fgets_chk (char *buf, size_t size, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
diff --git a/debug/fgets_u_chk.c b/debug/fgets_u_chk.c
index 2480964..580e396 100644
--- a/debug/fgets_u_chk.c
+++ b/debug/fgets_u_chk.c
@@ -29,11 +29,7 @@
 #include <sys/param.h>
 
 char *
-__fgets_unlocked_chk (buf, size, n, fp)
-     char *buf;
-     size_t size;
-     int n;
-     _IO_FILE *fp;
+__fgets_unlocked_chk (char *buf, size_t size, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
diff --git a/debug/memcpy_chk.c b/debug/memcpy_chk.c
index b240bf5..a08eb31 100644
--- a/debug/memcpy_chk.c
+++ b/debug/memcpy_chk.c
@@ -22,11 +22,7 @@
 #include <memcopy.h>
 
 void *
-__memcpy_chk (dstpp, srcpp, len, dstlen)
-     void *dstpp;
-     const void *srcpp;
-     size_t len;
-     size_t dstlen;
+__memcpy_chk (void *dstpp, const void *srcpp, size_t len, size_t dstlen)
 {
   if (__glibc_unlikely (dstlen < len))
     __chk_fail ();
diff --git a/debug/memmove_chk.c b/debug/memmove_chk.c
index 3cd9e0b..45efab5 100644
--- a/debug/memmove_chk.c
+++ b/debug/memmove_chk.c
@@ -26,11 +26,7 @@
 #endif
 
 void *
-MEMMOVE_CHK (dest, src, len, destlen)
-     void *dest;
-     const void *src;
-     size_t len;
-     size_t destlen;
+MEMMOVE_CHK (void *dest, const void *src, size_t len, size_t destlen)
 {
   if (__glibc_unlikely (destlen < len))
     __chk_fail ();
diff --git a/debug/mempcpy_chk.c b/debug/mempcpy_chk.c
index 00a242a..a0780a9 100644
--- a/debug/mempcpy_chk.c
+++ b/debug/mempcpy_chk.c
@@ -23,11 +23,7 @@
 #include <memcopy.h>
 
 void *
-__mempcpy_chk (dstpp, srcpp, len, dstlen)
-     void *dstpp;
-     const void *srcpp;
-     size_t len;
-     size_t dstlen;
+__mempcpy_chk (void *dstpp, const void *srcpp, size_t len, size_t dstlen)
 {
   if (__glibc_unlikely (dstlen < len))
     __chk_fail ();
diff --git a/debug/memset_chk.c b/debug/memset_chk.c
index 293172f..43003b5 100644
--- a/debug/memset_chk.c
+++ b/debug/memset_chk.c
@@ -19,11 +19,7 @@
 #include <memcopy.h>
 
 void *
-__memset_chk (dstpp, c, len, dstlen)
-     void *dstpp;
-     int c;
-     size_t len;
-     size_t dstlen;
+__memset_chk (void *dstpp, int c, size_t len, size_t dstlen)
 {
   if (__glibc_unlikely (dstlen < len))
     __chk_fail ();
diff --git a/debug/strcat_chk.c b/debug/strcat_chk.c
index 8d7359f..3efca27 100644
--- a/debug/strcat_chk.c
+++ b/debug/strcat_chk.c
@@ -21,10 +21,7 @@
 
 /* Append SRC on the end of DEST.  */
 char *
-__strcat_chk (dest, src, destlen)
-     char *dest;
-     const char *src;
-     size_t destlen;
+__strcat_chk (char *dest, const char *src, size_t destlen)
 {
   char *s1 = dest;
   const char *s2 = src;
diff --git a/debug/strncat_chk.c b/debug/strncat_chk.c
index 2951d05..f12a812 100644
--- a/debug/strncat_chk.c
+++ b/debug/strncat_chk.c
@@ -21,11 +21,7 @@
 
 
 char *
-__strncat_chk (s1, s2, n, s1len)
-     char *s1;
-     const char *s2;
-     size_t n;
-     size_t s1len;
+__strncat_chk (char *s1, const char *s2, size_t n, size_t s1len)
 {
   char c;
   char *s = s1;
diff --git a/debug/strncpy_chk.c b/debug/strncpy_chk.c
index 98e703d..02b866c 100644
--- a/debug/strncpy_chk.c
+++ b/debug/strncpy_chk.c
@@ -20,11 +20,7 @@
 
 
 char *
-__strncpy_chk (s1, s2, n, s1len)
-     char *s1;
-     const char *s2;
-     size_t n;
-     size_t s1len;
+__strncpy_chk (char *s1, const char *s2, size_t n, size_t s1len)
 {
   if (__builtin_expect (s1len < n, 0))
     __chk_fail ();
diff --git a/debug/vsprintf_chk.c b/debug/vsprintf_chk.c
index 1ec67b5..bf243df 100644
--- a/debug/vsprintf_chk.c
+++ b/debug/vsprintf_chk.c
@@ -24,9 +24,7 @@
 static int _IO_str_chk_overflow (_IO_FILE *fp, int c) __THROW;
 
 static int
-_IO_str_chk_overflow (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_str_chk_overflow (_IO_FILE *fp, int c)
 {
   /* When we come to here this means the user supplied buffer is
      filled.  */
diff --git a/dirent/dirfd.c b/dirent/dirfd.c
index 516f886..0dd5115 100644
--- a/dirent/dirfd.c
+++ b/dirent/dirfd.c
@@ -21,8 +21,7 @@
 #include <errno.h>
 
 int
-dirfd (dirp)
-     DIR *dirp;
+dirfd (DIR *dirp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/dirent/getdents.c b/dirent/getdents.c
index 0766265..836af14 100644
--- a/dirent/getdents.c
+++ b/dirent/getdents.c
@@ -21,11 +21,7 @@
 #include <dirent.h>
 
 ssize_t
-__getdirentries (fd, buf, nbytes, basep)
-     int fd;
-     char *buf;
-     size_t nbytes;
-     off_t *basep;
+__getdirentries (int fd, char *buf, size_t nbytes, off_t *basep)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/dirent/getdents64.c b/dirent/getdents64.c
index 1d317cc..a9d4663 100644
--- a/dirent/getdents64.c
+++ b/dirent/getdents64.c
@@ -21,11 +21,7 @@
 #include <dirent.h>
 
 ssize_t
-getdirentries64 (fd, buf, nbytes, basep)
-     int fd;
-     char *buf;
-     size_t nbytes;
-     off64_t *basep;
+getdirentries64 (int fd, char *buf, size_t nbytes, off64_t *basep)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/dirent/rewinddir.c b/dirent/rewinddir.c
index e7a345a..75ea266 100644
--- a/dirent/rewinddir.c
+++ b/dirent/rewinddir.c
@@ -22,8 +22,7 @@
 
 /* Rewind DIRP to the beginning of the directory.  */
 void
-__rewinddir (dirp)
-     DIR *dirp;
+__rewinddir (DIR *dirp)
 {
   __set_errno (ENOSYS);
   /* No way to indicate failure.	*/
diff --git a/dirent/seekdir.c b/dirent/seekdir.c
index e4a725b..eb2993c 100644
--- a/dirent/seekdir.c
+++ b/dirent/seekdir.c
@@ -22,9 +22,7 @@
 
 /* Seek to position POS in DIRP.  */
 void
-seekdir (dirp, pos)
-     DIR *dirp;
-     long int pos;
+seekdir (DIR *dirp, long int pos)
 {
   if (dirp == NULL)
     {
diff --git a/dirent/telldir.c b/dirent/telldir.c
index fdb56cf..504404d 100644
--- a/dirent/telldir.c
+++ b/dirent/telldir.c
@@ -22,8 +22,7 @@
 
 /* Return the current position of DIRP.  */
 long int
-telldir (dirp)
-     DIR *dirp;
+telldir (DIR *dirp)
 {
   if (dirp == NULL)
     {
diff --git a/elf/sln.c b/elf/sln.c
index 1a7d24e..3865139 100644
--- a/elf/sln.c
+++ b/elf/sln.c
@@ -87,8 +87,7 @@ usage (void)
 }
 
 static int
-makesymlinks (file)
-     const char *file;
+makesymlinks (const char *file)
 {
 #ifndef PATH_MAX
 #define PATH_MAX 4095
@@ -163,9 +162,7 @@ makesymlinks (file)
 }
 
 static int
-makesymlink (src, dest)
-     const char *src;
-     const char *dest;
+makesymlink (const char *src, const char *dest)
 {
   struct stat stats;
   const char *error;
diff --git a/gmon/gmon.c b/gmon/gmon.c
index 9774d57..e9988c0 100644
--- a/gmon/gmon.c
+++ b/gmon/gmon.c
@@ -72,8 +72,7 @@ static void write_bb_counts (int fd) internal_function;
  *	all the data structures are ready.
  */
 void
-__moncontrol (mode)
-     int mode;
+__moncontrol (int mode)
 {
   struct gmonparam *p = &_gmonparam;
 
@@ -98,9 +97,7 @@ weak_alias (__moncontrol, moncontrol)
 
 
 void
-__monstartup (lowpc, highpc)
-     u_long lowpc;
-     u_long highpc;
+__monstartup (u_long lowpc, u_long highpc)
 {
   int o;
   char *cp;
@@ -175,8 +172,7 @@ weak_alias (__monstartup, monstartup)
 
 static void
 internal_function
-write_hist (fd)
-     int fd;
+write_hist (int fd)
 {
   u_char tag = GMON_TAG_TIME_HIST;
 
@@ -227,8 +223,7 @@ write_hist (fd)
 
 static void
 internal_function
-write_call_graph (fd)
-     int fd;
+write_call_graph (int fd)
 {
 #define NARCS_PER_WRITEV	32
   u_char tag = GMON_TAG_CG_ARC;
@@ -290,8 +285,7 @@ write_call_graph (fd)
 
 static void
 internal_function
-write_bb_counts (fd)
-     int fd;
+write_bb_counts (int fd)
 {
   struct __bb *grp;
   u_char tag = GMON_TAG_BB_COUNT;
diff --git a/grp/setgroups.c b/grp/setgroups.c
index 4d2c1e3..1203fce 100644
--- a/grp/setgroups.c
+++ b/grp/setgroups.c
@@ -21,9 +21,7 @@
 
 /* Set the group set for the current user to GROUPS (N of them).  */
 int
-setgroups (n, groups)
-     size_t n;
-     const gid_t *groups;
+setgroups (size_t n, const gid_t *groups)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/inet/inet_lnaof.c b/inet/inet_lnaof.c
index c993c8b..8fd759c 100644
--- a/inet/inet_lnaof.c
+++ b/inet/inet_lnaof.c
@@ -41,8 +41,7 @@ static char sccsid[] = "@(#)inet_lnaof.c	8.1 (Berkeley) 6/4/93";
  * number formats.
  */
 in_addr_t
-inet_lnaof(in)
-	struct in_addr in;
+inet_lnaof (struct in_addr in)
 {
 	u_int32_t i = ntohl(in.s_addr);
 
diff --git a/inet/inet_net.c b/inet/inet_net.c
index b28fdb1..1bce06d 100644
--- a/inet/inet_net.c
+++ b/inet/inet_net.c
@@ -60,8 +60,7 @@ static char sccsid[] = "@(#)inet_network.c	8.1 (Berkeley) 6/4/93";
  * network numbers.
  */
 u_int32_t
-inet_network(cp)
-	const char *cp;
+inet_network (const char *cp)
 {
 	u_int32_t val, base, n, i;
 	char c;
diff --git a/inet/inet_netof.c b/inet/inet_netof.c
index 9b0aed9..0f048e6 100644
--- a/inet/inet_netof.c
+++ b/inet/inet_netof.c
@@ -40,8 +40,7 @@ static char sccsid[] = "@(#)inet_netof.c	8.1 (Berkeley) 6/4/93";
  * address; handles class a/b/c network #'s.
  */
 in_addr_t
-inet_netof(in)
-	struct in_addr in;
+inet_netof (struct in_addr in)
 {
 	u_int32_t i = ntohl(in.s_addr);
 
diff --git a/inet/rcmd.c b/inet/rcmd.c
index 035cb0d..d3fe3c5 100644
--- a/inet/rcmd.c
+++ b/inet/rcmd.c
@@ -370,9 +370,7 @@ rcmd(ahost, rport, locuser, remuser, cmd, fd2p)
 }
 
 int
-rresvport_af(alport, family)
-	int *alport;
-	sa_family_t family;
+rresvport_af (int *alport, sa_family_t family)
 {
 	union {
 		struct sockaddr generic;
@@ -431,8 +429,7 @@ rresvport_af(alport, family)
 libc_hidden_def (rresvport_af)
 
 int
-rresvport(alport)
-	int *alport;
+rresvport (int *alport)
 {
 	return rresvport_af(alport, AF_INET);
 }
diff --git a/io/access.c b/io/access.c
index 43445a1..210e2cd 100644
--- a/io/access.c
+++ b/io/access.c
@@ -21,9 +21,7 @@
 
 /* Test for access to FILE.  */
 int
-__access (file, type)
-     const char *file;
-     int type;
+__access (const char *file, int type)
 {
   if (file == NULL || (type & ~(R_OK|W_OK|X_OK|F_OK)) != 0)
     {
diff --git a/io/chdir.c b/io/chdir.c
index 1003b9d..cb3a902 100644
--- a/io/chdir.c
+++ b/io/chdir.c
@@ -21,8 +21,7 @@
 
 /* Change the current directory to PATH.  */
 int
-__chdir (path)
-     const char *path;
+__chdir (const char *path)
 {
   if (path == NULL)
     {
diff --git a/io/chmod.c b/io/chmod.c
index 3dcc893..d2c8a2b 100644
--- a/io/chmod.c
+++ b/io/chmod.c
@@ -22,9 +22,7 @@
 
 /* Change the protections of FILE to MODE.  */
 int
-__chmod (file, mode)
-     const char *file;
-     mode_t mode;
+__chmod (const char *file, mode_t mode)
 {
   if (file == NULL)
     {
diff --git a/io/chown.c b/io/chown.c
index 280f2c1..16cadd0 100644
--- a/io/chown.c
+++ b/io/chown.c
@@ -22,10 +22,7 @@
 
 /* Change the owner and group of FILE.  */
 int
-__chown (file, owner, group)
-     const char *file;
-     uid_t owner;
-     gid_t group;
+__chown (const char *file, uid_t owner, gid_t group)
 {
   if (file == NULL)
     {
diff --git a/io/close.c b/io/close.c
index 267cfbc..b322467 100644
--- a/io/close.c
+++ b/io/close.c
@@ -20,8 +20,7 @@
 
 /* Close the file descriptor FD.  */
 int
-__close (fd)
-     int fd;
+__close (int fd)
 {
   if (fd < 0)
     {
diff --git a/io/creat.c b/io/creat.c
index c03810d..b281fa2 100644
--- a/io/creat.c
+++ b/io/creat.c
@@ -23,9 +23,7 @@
 
 /* Create FILE with protections MODE.  */
 int
-creat (file, mode)
-     const char *file;
-     mode_t mode;
+creat (const char *file, mode_t mode)
 {
   return __open (file, O_WRONLY|O_CREAT|O_TRUNC, mode);
 }
diff --git a/io/creat64.c b/io/creat64.c
index 6be8a77..b99b19d 100644
--- a/io/creat64.c
+++ b/io/creat64.c
@@ -22,9 +22,7 @@
 
 /* Create FILE with protections MODE.  */
 int
-creat64 (file, mode)
-     const char *file;
-     mode_t mode;
+creat64 (const char *file, mode_t mode)
 {
   return __open64 (file, O_WRONLY|O_CREAT|O_TRUNC, mode);
 }
diff --git a/io/dup.c b/io/dup.c
index a461a42..b501d22 100644
--- a/io/dup.c
+++ b/io/dup.c
@@ -21,8 +21,7 @@
 
 /* Duplicate FD, returning a new file descriptor open on the same file.  */
 int
-__dup (fd)
-     int fd;
+__dup (int fd)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/io/dup2.c b/io/dup2.c
index fa3c5d5..d175572 100644
--- a/io/dup2.c
+++ b/io/dup2.c
@@ -23,9 +23,7 @@
 /* Duplicate FD to FD2, closing the old FD2 and making FD2 be
    open the same file as FD is.  Return FD2 or -1.  */
 int
-__dup2 (fd, fd2)
-     int fd;
-     int fd2;
+__dup2 (int fd, int fd2)
 {
   if (fd < 0 || fd2 < 0)
     {
diff --git a/io/dup3.c b/io/dup3.c
index 1f7f093..78eba2f 100644
--- a/io/dup3.c
+++ b/io/dup3.c
@@ -24,10 +24,7 @@
    open the same file as FD is which setting flags according to
    FLAGS.  Return FD2 or -1.  */
 int
-__dup3 (fd, fd2, flags)
-     int fd;
-     int fd2;
-     int flags;
+__dup3 (int fd, int fd2, int flags)
 {
   if (fd < 0 || fd2 < 0)
     {
diff --git a/io/euidaccess.c b/io/euidaccess.c
index 0adead8..c89bced 100644
--- a/io/euidaccess.c
+++ b/io/euidaccess.c
@@ -21,9 +21,7 @@
 #include <unistd.h>
 
 int
-__euidaccess (file, type)
-     const char *file;
-     int type;
+__euidaccess (const char *file, int type)
 {
   if (file == NULL || (type & ~(R_OK|W_OK|X_OK|F_OK)) != 0)
     {
diff --git a/io/faccessat.c b/io/faccessat.c
index 3bf8b79..8aa13f1 100644
--- a/io/faccessat.c
+++ b/io/faccessat.c
@@ -23,11 +23,7 @@
 #include <sys/types.h>
 
 int
-faccessat (fd, file, type, flag)
-     int fd;
-     const char *file;
-     int type;
-     int flag;
+faccessat (int fd, const char *file, int type, int flag)
 {
   if (file == NULL || (flag & ~(AT_SYMLINK_NOFOLLOW | AT_EACCESS)) != 0
       || (type & ~(R_OK|W_OK|X_OK|F_OK)) != 0)
diff --git a/io/fchmod.c b/io/fchmod.c
index f0aac92..99148fe 100644
--- a/io/fchmod.c
+++ b/io/fchmod.c
@@ -22,9 +22,7 @@
 
 /* Change the permissions of the file referenced by FD to MODE.  */
 int
-__fchmod (fd, mode)
-     int fd;
-     mode_t mode;
+__fchmod (int fd, mode_t mode)
 {
   if (fd < 0)
     {
diff --git a/io/fchmodat.c b/io/fchmodat.c
index 1cd794b..7a58883 100644
--- a/io/fchmodat.c
+++ b/io/fchmodat.c
@@ -24,11 +24,7 @@
 #include <sys/stat.h>
 
 int
-fchmodat (fd, file, mode, flag)
-     int fd;
-     const char *file;
-     mode_t mode;
-     int flag;
+fchmodat (int fd, const char *file, mode_t mode, int flag)
 {
   if (file == NULL || (flag & ~AT_SYMLINK_NOFOLLOW) != 0)
     {
diff --git a/io/fchown.c b/io/fchown.c
index 441e559..4f9837e 100644
--- a/io/fchown.c
+++ b/io/fchown.c
@@ -22,10 +22,7 @@
 
 /* Change the owner and group of the file referred to by FD.  */
 int
-__fchown (fd, owner, group)
-     int fd;
-     uid_t owner;
-     gid_t group;
+__fchown (int fd, uid_t owner, gid_t group)
 {
   if (fd < 0)
     {
diff --git a/io/fchownat.c b/io/fchownat.c
index e9e3bd6..4c53fa8 100644
--- a/io/fchownat.c
+++ b/io/fchownat.c
@@ -23,12 +23,7 @@
 
 /* Change the owner and group of FILE.  */
 int
-fchownat (fd, file, owner, group, flag)
-     int fd;
-     const char *file;
-     uid_t owner;
-     gid_t group;
-     int flag;
+fchownat (int fd, const char *file, uid_t owner, gid_t group, int flag)
 {
   if (file == NULL || (flag & ~AT_SYMLINK_NOFOLLOW) != 0)
     {
diff --git a/io/fcntl.c b/io/fcntl.c
index 5b1156d..996a0d5 100644
--- a/io/fcntl.c
+++ b/io/fcntl.c
@@ -20,9 +20,7 @@
 
 /* Perform file control operations on FD.  */
 int
-__fcntl (fd, cmd)
-     int fd;
-     int cmd;
+__fcntl (int fd, int cmd)
 {
   if (fd < 0)
     {
diff --git a/io/flock.c b/io/flock.c
index fc999ad..084c123 100644
--- a/io/flock.c
+++ b/io/flock.c
@@ -21,9 +21,7 @@
 /* Apply or remove an advisory lock, according to OPERATION,
    on the file FD refers to.  */
 int
-__flock (fd, operation)
-     int fd;
-     int operation;
+__flock (int fd, int operation)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/io/fts.c b/io/fts.c
index 46cbb72..ac1d340 100644
--- a/io/fts.c
+++ b/io/fts.c
@@ -202,9 +202,7 @@ mem1:	free(sp);
 
 static void
 internal_function
-fts_load(sp, p)
-	FTS *sp;
-	FTSENT *p;
+fts_load (FTS *sp, FTSENT *p)
 {
 	int len;
 	char *cp;
@@ -228,8 +226,7 @@ fts_load(sp, p)
 }
 
 int
-fts_close(sp)
-	FTS *sp;
+fts_close (FTS *sp)
 {
 	FTSENT *freep, *p;
 	int saved_errno;
@@ -282,8 +279,7 @@ fts_close(sp)
 	    ? p->fts_pathlen - 1 : p->fts_pathlen)
 
 FTSENT *
-fts_read(sp)
-	FTS *sp;
+fts_read (FTS *sp)
 {
 	FTSENT *p, *tmp;
 	int instr;
@@ -479,10 +475,7 @@ name:		t = sp->fts_path + NAPPEND(p->fts_parent);
  */
 /* ARGSUSED */
 int
-fts_set(sp, p, instr)
-	FTS *sp;
-	FTSENT *p;
-	int instr;
+fts_set (FTS *sp, FTSENT *p, int instr)
 {
 	if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
 	    instr != FTS_NOINSTR && instr != FTS_SKIP) {
@@ -494,9 +487,7 @@ fts_set(sp, p, instr)
 }
 
 FTSENT *
-fts_children(sp, instr)
-	FTS *sp;
-	int instr;
+fts_children (FTS *sp, int instr)
 {
 	FTSENT *p;
 	int fd;
@@ -587,9 +578,7 @@ dirent_not_directory(const struct dirent *dp)
  */
 static FTSENT *
 internal_function
-fts_build(sp, type)
-	FTS *sp;
-	int type;
+fts_build (FTS *sp, int type)
 {
 	struct dirent *dp;
 	FTSENT *p, *head;
@@ -852,10 +841,7 @@ mem1:				saved_errno = errno;
 
 static u_short
 internal_function
-fts_stat(sp, p, follow)
-	FTS *sp;
-	FTSENT *p;
-	int follow;
+fts_stat (FTS *sp, FTSENT *p, int follow)
 {
 	FTSENT *t;
 	dev_t dev;
@@ -936,10 +922,7 @@ err:		memset(sbp, 0, sizeof(struct stat));
 
 static FTSENT *
 internal_function
-fts_sort(sp, head, nitems)
-	FTS *sp;
-	FTSENT *head;
-	int nitems;
+fts_sort (FTS *sp, FTSENT *head, int nitems)
 {
 	FTSENT **ap, *p;
 
@@ -974,10 +957,7 @@ fts_sort(sp, head, nitems)
 
 static FTSENT *
 internal_function
-fts_alloc(sp, name, namelen)
-	FTS *sp;
-	const char *name;
-	size_t namelen;
+fts_alloc (FTS *sp, const char *name, size_t namelen)
 {
 	FTSENT *p;
 	size_t len;
@@ -1014,8 +994,7 @@ fts_alloc(sp, name, namelen)
 
 static void
 internal_function
-fts_lfree(head)
-	FTSENT *head;
+fts_lfree (FTSENT *head)
 {
 	FTSENT *p;
 
@@ -1034,9 +1013,7 @@ fts_lfree(head)
  */
 static int
 internal_function
-fts_palloc(sp, more)
-	FTS *sp;
-	size_t more;
+fts_palloc (FTS *sp, size_t more)
 {
 	char *p;
 
@@ -1068,9 +1045,7 @@ fts_palloc(sp, more)
  */
 static void
 internal_function
-fts_padjust(sp, head)
-	FTS *sp;
-	FTSENT *head;
+fts_padjust (FTS *sp, FTSENT *head)
 {
 	FTSENT *p;
 	char *addr = sp->fts_path;
@@ -1095,8 +1070,7 @@ fts_padjust(sp, head)
 
 static size_t
 internal_function
-fts_maxarglen(argv)
-	char * const *argv;
+fts_maxarglen (char * const *argv)
 {
 	size_t len, max;
 
@@ -1113,11 +1087,7 @@ fts_maxarglen(argv)
  */
 static int
 internal_function
-fts_safe_changedir(sp, p, fd, path)
-	FTS *sp;
-	FTSENT *p;
-	int fd;
-	const char *path;
+fts_safe_changedir (FTS *sp, FTSENT *p, int fd, const char *path)
 {
 	int ret, oerrno, newfd;
 	struct stat64 sb;
diff --git a/io/getwd.c b/io/getwd.c
index bbda67c..2a9fc73 100644
--- a/io/getwd.c
+++ b/io/getwd.c
@@ -23,8 +23,7 @@
 
 
 char *
-getwd (buf)
-     char *buf;
+getwd (char *buf)
 {
 #ifndef PATH_MAX
 #define PATH_MAX 1024
diff --git a/io/isatty.c b/io/isatty.c
index ea68464..cf39774 100644
--- a/io/isatty.c
+++ b/io/isatty.c
@@ -20,8 +20,7 @@
 
 /* Return 1 if FD is a terminal, 0 if not.  */
 int
-__isatty (fd)
-     int fd;
+__isatty (int fd)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/io/lchown.c b/io/lchown.c
index eceaf62..6dbb9af 100644
--- a/io/lchown.c
+++ b/io/lchown.c
@@ -22,10 +22,7 @@
 
 /* Change the owner and group of FILE.  */
 int
-__lchown (file, owner, group)
-     const char *file;
-     uid_t owner;
-     gid_t group;
+__lchown (const char *file, uid_t owner, gid_t group)
 {
   if (file == NULL)
     {
diff --git a/io/link.c b/io/link.c
index 1a42557..9eeb4a4 100644
--- a/io/link.c
+++ b/io/link.c
@@ -22,9 +22,7 @@
 
 /* Make a link to FROM called TO.  */
 int
-__link (from, to)
-     const char *from;
-     const char *to;
+__link (const char *from, const char *to)
 {
   if (from == NULL || to == NULL)
     {
diff --git a/io/linkat.c b/io/linkat.c
index b999f24..99d47ee 100644
--- a/io/linkat.c
+++ b/io/linkat.c
@@ -23,12 +23,7 @@
 
 /* Make a link to FROM relative to FROMFD called TO relative to TOFD.  */
 int
-linkat (fromfd, from, tofd, to, flags)
-     int fromfd;
-     const char *from;
-     int tofd;
-     const char *to;
-     int flags;
+linkat (int fromfd, const char *from, int tofd, const char *to, int flags)
 {
   if (from == NULL || to == NULL)
     {
diff --git a/io/lseek.c b/io/lseek.c
index ac90483..7ab5f29 100644
--- a/io/lseek.c
+++ b/io/lseek.c
@@ -21,10 +21,7 @@
 
 /* Seek to OFFSET on FD, starting from WHENCE.  */
 off_t
-__libc_lseek (fd, offset, whence)
-     int fd;
-     off_t offset;
-     int whence;
+__libc_lseek (int fd, off_t offset, int whence)
 {
   if (fd < 0)
     {
diff --git a/io/mkdir.c b/io/mkdir.c
index e1dfe84..cb27350 100644
--- a/io/mkdir.c
+++ b/io/mkdir.c
@@ -23,9 +23,7 @@
 
 /* Create a directory named PATH with protections MODE.  */
 int
-__mkdir (path, mode)
-     const char *path;
-     mode_t mode;
+__mkdir (const char *path, mode_t mode)
 {
   if (path == NULL)
     {
diff --git a/io/mkdirat.c b/io/mkdirat.c
index 7ba3145..4b14e33 100644
--- a/io/mkdirat.c
+++ b/io/mkdirat.c
@@ -24,10 +24,7 @@
 
 /* Create a directory named PATH relative to FD with protections MODE.  */
 int
-mkdirat (fd, path, mode)
-     int fd;
-     const char *path;
-     mode_t mode;
+mkdirat (int fd, const char *path, mode_t mode)
 {
   if (path == NULL)
     {
diff --git a/io/mkfifo.c b/io/mkfifo.c
index fddd6c9..c2d2774 100644
--- a/io/mkfifo.c
+++ b/io/mkfifo.c
@@ -23,9 +23,7 @@
 
 /* Create a named pipe (FIFO) named PATH with protections MODE.  */
 int
-mkfifo (path, mode)
-     const char *path;
-     mode_t mode;
+mkfifo (const char *path, mode_t mode)
 {
   if (path == NULL)
     {
diff --git a/io/mkfifoat.c b/io/mkfifoat.c
index 311e009..5e82cb0 100644
--- a/io/mkfifoat.c
+++ b/io/mkfifoat.c
@@ -25,10 +25,7 @@
 /* Create a named pipe (FIFO) named PATH relative to FD with
    protections MODE.  */
 int
-mkfifoat (fd, path, mode)
-     int fd;
-     const char *path;
-     mode_t mode;
+mkfifoat (int fd, const char *path, mode_t mode)
 {
   if (path == NULL)
     {
diff --git a/io/open.c b/io/open.c
index c0000ba..a1c8866 100644
--- a/io/open.c
+++ b/io/open.c
@@ -26,9 +26,7 @@
 /* Open FILE with access OFLAG.  If O_CREAT or O_TMPFILE is in OFLAG,
    a third argument is the file protection.  */
 int
-__libc_open (file, oflag)
-     const char *file;
-     int oflag;
+__libc_open (const char *file, int oflag)
 {
   int mode;
 
diff --git a/io/open64.c b/io/open64.c
index f87ee57..5b94b8a 100644
--- a/io/open64.c
+++ b/io/open64.c
@@ -24,9 +24,7 @@
 /* Open FILE with access OFLAG.  If O_CREAT or O_TMPFILE is in OFLAG,
    a third argument is the file protection.  */
 int
-__libc_open64 (file, oflag)
-     const char *file;
-     int oflag;
+__libc_open64 (const char *file, int oflag)
 {
   int mode;
 
diff --git a/io/readlink.c b/io/readlink.c
index 4516e64..197e94e 100644
--- a/io/readlink.c
+++ b/io/readlink.c
@@ -22,10 +22,7 @@
    LEN bytes of BUF.  The contents are not null-terminated.
    Returns the number of characters read, or -1 for errors.  */
 ssize_t
-__readlink (path, buf, len)
-     const char *path;
-     char *buf;
-     size_t len;
+__readlink (const char *path, char *buf, size_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/io/readlinkat.c b/io/readlinkat.c
index 63b48ea..359ce3a 100644
--- a/io/readlinkat.c
+++ b/io/readlinkat.c
@@ -23,11 +23,7 @@
    more than LEN bytes of BUF.  The contents are not null-terminated.
    Returns the number of characters read, or -1 for errors.  */
 ssize_t
-readlinkat (fd, path, buf, len)
-     int fd;
-     const char *path;
-     char *buf;
-     size_t len;
+readlinkat (int fd, const char *path, char *buf, size_t len)
 {
   if (path == NULL)
     {
diff --git a/io/rmdir.c b/io/rmdir.c
index f4ad166..596bca1 100644
--- a/io/rmdir.c
+++ b/io/rmdir.c
@@ -22,8 +22,7 @@
 
 /* Remove the directory PATH.  */
 int
-__rmdir (path)
-     const char *path;
+__rmdir (const char *path)
 {
   if (path == NULL)
     {
diff --git a/io/symlink.c b/io/symlink.c
index 77d1203..b5f2f60 100644
--- a/io/symlink.c
+++ b/io/symlink.c
@@ -22,9 +22,7 @@
 
 /* Make a link to FROM called TO.  */
 int
-__symlink (from, to)
-     const char *from;
-     const char *to;
+__symlink (const char *from, const char *to)
 {
   if (from == NULL || to == NULL)
     {
diff --git a/io/symlinkat.c b/io/symlinkat.c
index 0c8747d..70bf9a2 100644
--- a/io/symlinkat.c
+++ b/io/symlinkat.c
@@ -23,10 +23,7 @@
 
 /* Make a link to FROM called TO relative to FD.  */
 int
-symlinkat (from, fd, to)
-     const char *from;
-     int fd;
-     const char *to;
+symlinkat (const char *from, int fd, const char *to)
 {
   if (from == NULL || to == NULL)
     {
diff --git a/io/ttyname.c b/io/ttyname.c
index 6332d29..f70ebd1 100644
--- a/io/ttyname.c
+++ b/io/ttyname.c
@@ -25,8 +25,7 @@ char *__ttyname = NULL;
 /* Return the pathname of the terminal FD is open on, or NULL on errors.
    The returned storage is good only until the next call to this function.  */
 char *
-ttyname (fd)
-     int fd;
+ttyname (int fd)
 {
   __set_errno (ENOSYS);
   return NULL;
diff --git a/io/ttyname_r.c b/io/ttyname_r.c
index 50dbd67..a57b932 100644
--- a/io/ttyname_r.c
+++ b/io/ttyname_r.c
@@ -22,10 +22,7 @@
 /* Store at most BUFLEN characters the pathname of the terminal FD is
    open on in BUF.  Return 0 on success,  otherwise an error number.  */
 int
-__ttyname_r (fd, buf, buflen)
-     int fd;
-     char *buf;
-     size_t buflen;
+__ttyname_r (int fd, char *buf, size_t buflen)
 {
   __set_errno (ENOSYS);
   return ENOSYS;
diff --git a/io/umask.c b/io/umask.c
index 2afb837..0e9a738 100644
--- a/io/umask.c
+++ b/io/umask.c
@@ -21,8 +21,7 @@
 
 /* Set the file creation mask to MASK, returning the old mask.  */
 mode_t
-__umask (mask)
-     mode_t mask;
+__umask (mode_t mask)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/io/unlink.c b/io/unlink.c
index 65ec5c6..42ed33c 100644
--- a/io/unlink.c
+++ b/io/unlink.c
@@ -22,8 +22,7 @@
 
 /* Remove the link named NAME.  */
 int
-__unlink (name)
-     const char *name;
+__unlink (const char *name)
 {
   if (name == NULL)
     {
diff --git a/io/unlinkat.c b/io/unlinkat.c
index 9122d73..e77d1de 100644
--- a/io/unlinkat.c
+++ b/io/unlinkat.c
@@ -23,10 +23,7 @@
 
 /* Remove the link named NAME.  */
 int
-unlinkat (fd, name, flag)
-     int fd;
-     const char *name;
-     int flag;
+unlinkat (int fd, const char *name, int flag)
 {
   if (name == NULL || (flag & AT_REMOVEDIR) != 0)
     {
diff --git a/io/utime.c b/io/utime.c
index 830d341..faac909 100644
--- a/io/utime.c
+++ b/io/utime.c
@@ -23,9 +23,7 @@
 /* Set the access and modification times of FILE to those given in TIMES.
    If TIMES is NULL, set them to the current time.  */
 int
-utime (file, times)
-     const char *file;
-     const struct utimbuf *times;
+utime (const char *file, const struct utimbuf *times)
 {
   if (file == NULL)
     {
diff --git a/libio/clearerr.c b/libio/clearerr.c
index 0a52e05..1a610a6 100644
--- a/libio/clearerr.c
+++ b/libio/clearerr.c
@@ -19,8 +19,7 @@
 #include "stdio.h"
 
 void
-clearerr (fp)
-     FILE *fp;
+clearerr (FILE *fp)
 {
   CHECK_FILE (fp, /*nothing*/);
   _IO_flockfile (fp);
diff --git a/libio/clearerr_u.c b/libio/clearerr_u.c
index 73b5bc3..d0452b2 100644
--- a/libio/clearerr_u.c
+++ b/libio/clearerr_u.c
@@ -19,8 +19,7 @@
 #include "stdio.h"
 
 void
-clearerr_unlocked (fp)
-     FILE *fp;
+clearerr_unlocked (FILE *fp)
 {
   CHECK_FILE (fp, /*nothing*/);
   _IO_clearerr (fp);
diff --git a/libio/feof.c b/libio/feof.c
index c89182c..febf106 100644
--- a/libio/feof.c
+++ b/libio/feof.c
@@ -28,8 +28,7 @@
 #include "stdio.h"
 
 int
-_IO_feof (fp)
-     _IO_FILE* fp;
+_IO_feof (_IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/feof_u.c b/libio/feof_u.c
index 4f552ca..a582093 100644
--- a/libio/feof_u.c
+++ b/libio/feof_u.c
@@ -30,8 +30,7 @@
 #undef feof_unlocked
 
 int
-feof_unlocked (fp)
-     _IO_FILE* fp;
+feof_unlocked (_IO_FILE *fp)
 {
   CHECK_FILE (fp, EOF);
   return _IO_feof_unlocked (fp);
diff --git a/libio/ferror.c b/libio/ferror.c
index 3f73e76..90a3b69 100644
--- a/libio/ferror.c
+++ b/libio/ferror.c
@@ -28,8 +28,7 @@
 #include "stdio.h"
 
 int
-_IO_ferror (fp)
-     _IO_FILE* fp;
+_IO_ferror (_IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/ferror_u.c b/libio/ferror_u.c
index 08831a0..f182cb2 100644
--- a/libio/ferror_u.c
+++ b/libio/ferror_u.c
@@ -30,8 +30,7 @@
 #undef ferror_unlocked
 
 int
-ferror_unlocked (fp)
-     _IO_FILE* fp;
+ferror_unlocked (_IO_FILE *fp)
 {
   CHECK_FILE (fp, EOF);
   return _IO_ferror_unlocked (fp);
diff --git a/libio/filedoalloc.c b/libio/filedoalloc.c
index 78aa3d5..81d2da6 100644
--- a/libio/filedoalloc.c
+++ b/libio/filedoalloc.c
@@ -91,8 +91,7 @@ local_isatty (int fd)
  */
 
 int
-_IO_file_doallocate (fp)
-     _IO_FILE *fp;
+_IO_file_doallocate (_IO_FILE *fp)
 {
   _IO_size_t size;
   char *p;
diff --git a/libio/fileno.c b/libio/fileno.c
index c1b02d5..fbf86aa 100644
--- a/libio/fileno.c
+++ b/libio/fileno.c
@@ -28,8 +28,7 @@
 #include <stdio.h>
 
 int
-__fileno (fp)
-     _IO_FILE* fp;
+__fileno (_IO_FILE *fp)
 {
   CHECK_FILE (fp, EOF);
 
diff --git a/libio/fputc.c b/libio/fputc.c
index 1d52c80..bd271d0 100644
--- a/libio/fputc.c
+++ b/libio/fputc.c
@@ -28,9 +28,7 @@
 #include "stdio.h"
 
 int
-fputc (c, fp)
-     int c;
-     _IO_FILE *fp;
+fputc (int c, _IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/fputc_u.c b/libio/fputc_u.c
index c8c15ca..9b275f2 100644
--- a/libio/fputc_u.c
+++ b/libio/fputc_u.c
@@ -30,9 +30,7 @@
 #undef fputc_unlocked
 
 int
-fputc_unlocked (c, fp)
-     int c;
-     _IO_FILE *fp;
+fputc_unlocked (int c, _IO_FILE *fp)
 {
   CHECK_FILE (fp, EOF);
   return _IO_putc_unlocked (c, fp);
diff --git a/libio/fputwc.c b/libio/fputwc.c
index 3781af0..48b8243 100644
--- a/libio/fputwc.c
+++ b/libio/fputwc.c
@@ -28,9 +28,7 @@
 #include <wchar.h>
 
 wint_t
-fputwc (wc, fp)
-     wchar_t wc;
-     _IO_FILE *fp;
+fputwc (wchar_t wc, _IO_FILE *fp)
 {
   wint_t result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/fputwc_u.c b/libio/fputwc_u.c
index 86e1059..5f247bb 100644
--- a/libio/fputwc_u.c
+++ b/libio/fputwc_u.c
@@ -30,9 +30,7 @@
 #undef fputwc_unlocked
 
 wint_t
-fputwc_unlocked (wc, fp)
-     wchar_t wc;
-     _IO_FILE *fp;
+fputwc_unlocked (wchar_t wc, _IO_FILE *fp)
 {
   CHECK_FILE (fp, WEOF);
   if (_IO_fwide (fp, 1) < 0)
diff --git a/libio/freopen.c b/libio/freopen.c
index 035fa1f..30691cb 100644
--- a/libio/freopen.c
+++ b/libio/freopen.c
@@ -35,11 +35,8 @@
 
 #include <kernel-features.h>
 
-FILE*
-freopen (filename, mode, fp)
-     const char* filename;
-     const char* mode;
-     FILE* fp;
+FILE *
+freopen (const char *filename, const char *mode, FILE *fp)
 {
   FILE *result;
   CHECK_FILE (fp, NULL);
diff --git a/libio/freopen64.c b/libio/freopen64.c
index fc6ccb1..cdb3ec1 100644
--- a/libio/freopen64.c
+++ b/libio/freopen64.c
@@ -35,10 +35,7 @@
 #include <kernel-features.h>
 
 FILE *
-freopen64 (filename, mode, fp)
-     const char* filename;
-     const char* mode;
-     FILE *fp;
+freopen64 (const char *filename, const char *mode, FILE *fp)
 {
   FILE *result;
   CHECK_FILE (fp, NULL);
diff --git a/libio/fseek.c b/libio/fseek.c
index 1ee89ba..c643ff3 100644
--- a/libio/fseek.c
+++ b/libio/fseek.c
@@ -28,10 +28,7 @@
 #include <stdio.h>
 
 int
-fseek (fp, offset, whence)
-     _IO_FILE* fp;
-     long int offset;
-     int whence;
+fseek (_IO_FILE *fp, long int offset, int whence)
 {
   int result;
   CHECK_FILE (fp, -1);
diff --git a/libio/fseeko.c b/libio/fseeko.c
index 304bb42..fa1e2a9 100644
--- a/libio/fseeko.c
+++ b/libio/fseeko.c
@@ -28,10 +28,7 @@
 #include "stdio.h"
 
 int
-fseeko (fp, offset, whence)
-     _IO_FILE* fp;
-     off_t offset;
-     int whence;
+fseeko (_IO_FILE *fp, off_t offset, int whence)
 {
   int result;
   CHECK_FILE (fp, -1);
diff --git a/libio/fseeko64.c b/libio/fseeko64.c
index 8dc57cb..2d7b4d7 100644
--- a/libio/fseeko64.c
+++ b/libio/fseeko64.c
@@ -32,10 +32,7 @@
 #ifndef __OFF_T_MATCHES_OFF64_T
 
 int
-fseeko64 (fp, offset, whence)
-     _IO_FILE* fp;
-     __off64_t offset;
-     int whence;
+fseeko64 (_IO_FILE *fp, __off64_t offset, int whence)
 {
   int result;
   CHECK_FILE (fp, -1);
diff --git a/libio/ftello.c b/libio/ftello.c
index fc56f7c..1c1c1a3 100644
--- a/libio/ftello.c
+++ b/libio/ftello.c
@@ -31,8 +31,7 @@
 
 
 off_t
-__ftello (fp)
-     _IO_FILE *fp;
+__ftello (_IO_FILE *fp)
 {
   _IO_off64_t pos;
   CHECK_FILE (fp, -1L);
diff --git a/libio/ftello64.c b/libio/ftello64.c
index 998fc15..0e6a077 100644
--- a/libio/ftello64.c
+++ b/libio/ftello64.c
@@ -32,8 +32,7 @@
 #ifndef __OFF_T_MATCHES_OFF64_T
 
 off64_t
-ftello64 (fp)
-     _IO_FILE *fp;
+ftello64 (_IO_FILE *fp)
 {
   _IO_off64_t pos;
   CHECK_FILE (fp, -1L);
diff --git a/libio/fwide.c b/libio/fwide.c
index 1a93e74..fee98bd 100644
--- a/libio/fwide.c
+++ b/libio/fwide.c
@@ -29,9 +29,7 @@
 #include <wchar.h>
 
 int
-fwide (fp, mode)
-     _IO_FILE *fp;
-     int mode;
+fwide (_IO_FILE *fp, int mode)
 {
   int result;
 
diff --git a/libio/genops.c b/libio/genops.c
index 45c9d41..873bd77 100644
--- a/libio/genops.c
+++ b/libio/genops.c
@@ -55,8 +55,7 @@ flush_cleanup (void *not_used)
 #endif
 
 void
-_IO_un_link (fp)
-     struct _IO_FILE_plus *fp;
+_IO_un_link (struct _IO_FILE_plus *fp)
 {
   if (fp->file._flags & _IO_LINKED)
     {
@@ -94,8 +93,7 @@ _IO_un_link (fp)
 libc_hidden_def (_IO_un_link)
 
 void
-_IO_link_in (fp)
-     struct _IO_FILE_plus *fp;
+_IO_link_in (struct _IO_FILE_plus *fp)
 {
   if ((fp->file._flags & _IO_LINKED) == 0)
     {
@@ -124,9 +122,7 @@ libc_hidden_def (_IO_link_in)
 _IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p);
 
 _IO_ssize_t
-_IO_least_marker (fp, end_p)
-     _IO_FILE *fp;
-     char *end_p;
+_IO_least_marker (_IO_FILE *fp, char *end_p)
 {
   _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
   struct _IO_marker *mark;
@@ -139,8 +135,7 @@ _IO_least_marker (fp, end_p)
 /* Switch current get area from backup buffer to (start of) main get area. */
 
 void
-_IO_switch_to_main_get_area (fp)
-     _IO_FILE *fp;
+_IO_switch_to_main_get_area (_IO_FILE *fp)
 {
   char *tmp;
   fp->_flags &= ~_IO_IN_BACKUP;
@@ -159,8 +154,7 @@ _IO_switch_to_main_get_area (fp)
 /* Switch current get area from main get area to (end of) backup area. */
 
 void
-_IO_switch_to_backup_area (fp)
-     _IO_FILE *fp;
+_IO_switch_to_backup_area (_IO_FILE *fp)
 {
   char *tmp;
   fp->_flags |= _IO_IN_BACKUP;
@@ -177,8 +171,7 @@ _IO_switch_to_backup_area (fp)
 }
 
 int
-_IO_switch_to_get_mode (fp)
-     _IO_FILE *fp;
+_IO_switch_to_get_mode (_IO_FILE *fp)
 {
   if (fp->_IO_write_ptr > fp->_IO_write_base)
     if (_IO_OVERFLOW (fp, EOF) == EOF)
@@ -201,8 +194,7 @@ _IO_switch_to_get_mode (fp)
 libc_hidden_def (_IO_switch_to_get_mode)
 
 void
-_IO_free_backup_area (fp)
-     _IO_FILE *fp;
+_IO_free_backup_area (_IO_FILE *fp)
 {
   if (_IO_in_backup (fp))
     _IO_switch_to_main_get_area (fp);  /* Just in case. */
@@ -215,8 +207,7 @@ libc_hidden_def (_IO_free_backup_area)
 
 #if 0
 int
-_IO_switch_to_put_mode (fp)
-     _IO_FILE *fp;
+_IO_switch_to_put_mode (_IO_FILE *fp)
 {
   fp->_IO_write_base = fp->_IO_read_ptr;
   fp->_IO_write_ptr = fp->_IO_read_ptr;
@@ -233,9 +224,7 @@ _IO_switch_to_put_mode (fp)
 #endif
 
 int
-__overflow (f, ch)
-     _IO_FILE *f;
-     int ch;
+__overflow (_IO_FILE *f, int ch)
 {
   /* This is a single-byte stream.  */
   if (f->_mode == 0)
@@ -325,8 +314,7 @@ save_for_backup (fp, end_p)
 }
 
 int
-__underflow (fp)
-     _IO_FILE *fp;
+__underflow (_IO_FILE *fp)
 {
 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
   if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
@@ -358,8 +346,7 @@ __underflow (fp)
 libc_hidden_def (__underflow)
 
 int
-__uflow (fp)
-     _IO_FILE *fp;
+__uflow (_IO_FILE *fp)
 {
 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
   if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
@@ -391,11 +378,7 @@ __uflow (fp)
 libc_hidden_def (__uflow)
 
 void
-_IO_setb (f, b, eb, a)
-     _IO_FILE *f;
-     char *b;
-     char *eb;
-     int a;
+_IO_setb (_IO_FILE *f, char *b, char *eb, int a)
 {
   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
     free (f->_IO_buf_base);
@@ -409,8 +392,7 @@ _IO_setb (f, b, eb, a)
 libc_hidden_def (_IO_setb)
 
 void
-_IO_doallocbuf (fp)
-     _IO_FILE *fp;
+_IO_doallocbuf (_IO_FILE *fp)
 {
   if (fp->_IO_buf_base)
     return;
@@ -422,15 +404,13 @@ _IO_doallocbuf (fp)
 libc_hidden_def (_IO_doallocbuf)
 
 int
-_IO_default_underflow (fp)
-     _IO_FILE *fp;
+_IO_default_underflow (_IO_FILE *fp)
 {
   return EOF;
 }
 
 int
-_IO_default_uflow (fp)
-     _IO_FILE *fp;
+_IO_default_uflow (_IO_FILE *fp)
 {
   int ch = _IO_UNDERFLOW (fp);
   if (ch == EOF)
@@ -440,10 +420,7 @@ _IO_default_uflow (fp)
 libc_hidden_def (_IO_default_uflow)
 
 _IO_size_t
-_IO_default_xsputn (f, data, n)
-     _IO_FILE *f;
-     const void *data;
-     _IO_size_t n;
+_IO_default_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
 {
   const char *s = (char *) data;
   _IO_size_t more = n;
@@ -486,10 +463,7 @@ _IO_default_xsputn (f, data, n)
 libc_hidden_def (_IO_default_xsputn)
 
 _IO_size_t
-_IO_sgetn (fp, data, n)
-     _IO_FILE *fp;
-     void *data;
-     _IO_size_t n;
+_IO_sgetn (_IO_FILE *fp, void *data, _IO_size_t n)
 {
   /* FIXME handle putback buffer here! */
   return _IO_XSGETN (fp, data, n);
@@ -497,10 +471,7 @@ _IO_sgetn (fp, data, n)
 libc_hidden_def (_IO_sgetn)
 
 _IO_size_t
-_IO_default_xsgetn (fp, data, n)
-     _IO_FILE *fp;
-     void *data;
-     _IO_size_t n;
+_IO_default_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
 {
   _IO_size_t more = n;
   char *s = (char*) data;
@@ -542,18 +513,14 @@ libc_hidden_def (_IO_default_xsgetn)
 #if 0
 /* Seems not to be needed. --drepper */
 int
-_IO_sync (fp)
-     _IO_FILE *fp;
+_IO_sync (_IO_FILE *fp)
 {
   return 0;
 }
 #endif
 
 _IO_FILE *
-_IO_default_setbuf (fp, p, len)
-     _IO_FILE *fp;
-     char *p;
-     _IO_ssize_t len;
+_IO_default_setbuf (_IO_FILE *fp, char *p, _IO_ssize_t len)
 {
     if (_IO_SYNC (fp) == EOF)
 	return NULL;
@@ -573,17 +540,13 @@ _IO_default_setbuf (fp, p, len)
 }
 
 _IO_off64_t
-_IO_default_seekpos (fp, pos, mode)
-     _IO_FILE *fp;
-     _IO_off64_t pos;
-     int mode;
+_IO_default_seekpos (_IO_FILE *fp, _IO_off64_t pos, int mode)
 {
   return _IO_SEEKOFF (fp, pos, 0, mode);
 }
 
 int
-_IO_default_doallocate (fp)
-     _IO_FILE *fp;
+_IO_default_doallocate (_IO_FILE *fp)
 {
   char *buf;
 
@@ -597,18 +560,14 @@ _IO_default_doallocate (fp)
 libc_hidden_def (_IO_default_doallocate)
 
 void
-_IO_init (fp, flags)
-     _IO_FILE *fp;
-     int flags;
+_IO_init (_IO_FILE *fp, int flags)
 {
   _IO_no_init (fp, flags, -1, NULL, NULL);
 }
 libc_hidden_def (_IO_init)
 
 void
-_IO_old_init (fp, flags)
-     _IO_FILE *fp;
-     int flags;
+_IO_old_init (_IO_FILE *fp, int flags)
 {
   fp->_flags = _IO_MAGIC|flags;
   fp->_flags2 = 0;
@@ -673,8 +632,7 @@ _IO_no_init (fp, flags, orientation, wd, jmp)
 }
 
 int
-_IO_default_sync (fp)
-     _IO_FILE *fp;
+_IO_default_sync (_IO_FILE *fp)
 {
   return 0;
 }
@@ -683,9 +641,7 @@ _IO_default_sync (fp)
    current implementation, this function can get called twice! */
 
 void
-_IO_default_finish (fp, dummy)
-     _IO_FILE *fp;
-     int dummy;
+_IO_default_finish (_IO_FILE *fp, int dummy)
 {
   struct _IO_marker *mark;
   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
@@ -713,19 +669,13 @@ _IO_default_finish (fp, dummy)
 libc_hidden_def (_IO_default_finish)
 
 _IO_off64_t
-_IO_default_seekoff (fp, offset, dir, mode)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
-     int mode;
+_IO_default_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
 {
   return _IO_pos_BAD;
 }
 
 int
-_IO_sputbackc (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_sputbackc (_IO_FILE *fp, int c)
 {
   int result;
 
@@ -746,8 +696,7 @@ _IO_sputbackc (fp, c)
 libc_hidden_def (_IO_sputbackc)
 
 int
-_IO_sungetc (fp)
-     _IO_FILE *fp;
+_IO_sungetc (_IO_FILE *fp)
 {
   int result;
 
@@ -769,9 +718,7 @@ _IO_sungetc (fp)
 /* Seems not to be needed.  */
 #if 0
 void
-_IO_set_column (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_set_column (_IO_FILE *fp, int c)
 {
   if (c == -1)
     fp->_column = -1;
@@ -780,9 +727,7 @@ _IO_set_column (fp, c)
 }
 #else
 int
-_IO_set_column (fp, i)
-     _IO_FILE *fp;
-     int i;
+_IO_set_column (_IO_FILE *fp, int i)
 {
   fp->_cur_column = i + 1;
   return 0;
@@ -792,10 +737,7 @@ _IO_set_column (fp, i)
 
 
 unsigned
-_IO_adjust_column (start, line, count)
-     unsigned start;
-     const char *line;
-     int count;
+_IO_adjust_column (unsigned start, const char *line, int count)
 {
   const char *ptr = line + count;
   while (ptr > line)
@@ -808,8 +750,7 @@ libc_hidden_def (_IO_adjust_column)
 #if 0
 /* Seems not to be needed. --drepper */
 int
-_IO_get_column (fp)
-     _IO_FILE *fp;
+_IO_get_column (_IO_FILE *fp)
 {
   if (fp->_cur_column)
     return _IO_adjust_column (fp->_cur_column - 1,
@@ -1029,9 +970,7 @@ _IO_cleanup (void)
 
 
 void
-_IO_init_marker (marker, fp)
-     struct _IO_marker *marker;
-     _IO_FILE *fp;
+_IO_init_marker (struct _IO_marker *marker, _IO_FILE *fp)
 {
   marker->_sbuf = fp;
   if (_IO_in_put_mode (fp))
@@ -1047,8 +986,7 @@ _IO_init_marker (marker, fp)
 }
 
 void
-_IO_remove_marker (marker)
-     struct _IO_marker *marker;
+_IO_remove_marker (struct _IO_marker *marker)
 {
   /* Unlink from sb's chain. */
   struct _IO_marker **ptr = &marker->_sbuf->_markers;
@@ -1071,17 +1009,14 @@ _IO_remove_marker (marker)
 #define BAD_DELTA EOF
 
 int
-_IO_marker_difference (mark1, mark2)
-     struct _IO_marker *mark1;
-     struct _IO_marker *mark2;
+_IO_marker_difference (struct _IO_marker *mark1, struct _IO_marker *mark2)
 {
   return mark1->_pos - mark2->_pos;
 }
 
 /* Return difference between MARK and current position of MARK's stream. */
 int
-_IO_marker_delta (mark)
-     struct _IO_marker *mark;
+_IO_marker_delta (struct _IO_marker *mark)
 {
   int cur_pos;
   if (mark->_sbuf == NULL)
@@ -1094,10 +1029,7 @@ _IO_marker_delta (mark)
 }
 
 int
-_IO_seekmark (fp, mark, delta)
-     _IO_FILE *fp;
-     struct _IO_marker *mark;
-     int delta;
+_IO_seekmark (_IO_FILE *fp, struct _IO_marker *mark, int delta)
 {
   if (mark->_sbuf != fp)
     return EOF;
@@ -1117,8 +1049,7 @@ _IO_seekmark (fp, mark, delta)
 }
 
 void
-_IO_unsave_markers (fp)
-     _IO_FILE *fp;
+_IO_unsave_markers (_IO_FILE *fp)
 {
   struct _IO_marker *mark = fp->_markers;
   if (mark)
@@ -1148,9 +1079,7 @@ libc_hidden_def (_IO_unsave_markers)
 #if 0
 /* Seems not to be needed. --drepper */
 int
-_IO_nobackup_pbackfail (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_nobackup_pbackfail (_IO_FILE *fp, int c)
 {
   if (fp->_IO_read_ptr > fp->_IO_read_base)
 	fp->_IO_read_ptr--;
@@ -1161,9 +1090,7 @@ _IO_nobackup_pbackfail (fp, c)
 #endif
 
 int
-_IO_default_pbackfail (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_default_pbackfail (_IO_FILE *fp, int c)
 {
   if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
       && (unsigned char) fp->_IO_read_ptr[-1] == c)
@@ -1220,51 +1147,37 @@ _IO_default_pbackfail (fp, c)
 libc_hidden_def (_IO_default_pbackfail)
 
 _IO_off64_t
-_IO_default_seek (fp, offset, dir)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
+_IO_default_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
 {
   return _IO_pos_BAD;
 }
 
 int
-_IO_default_stat (fp, st)
-     _IO_FILE *fp;
-     void* st;
+_IO_default_stat (_IO_FILE *fp, void *st)
 {
   return EOF;
 }
 
 _IO_ssize_t
-_IO_default_read (fp, data, n)
-     _IO_FILE* fp;
-     void *data;
-     _IO_ssize_t n;
+_IO_default_read (_IO_FILE *fp, void *data, _IO_ssize_t n)
 {
   return -1;
 }
 
 _IO_ssize_t
-_IO_default_write (fp, data, n)
-     _IO_FILE *fp;
-     const void *data;
-     _IO_ssize_t n;
+_IO_default_write (_IO_FILE *fp, const void *data, _IO_ssize_t n)
 {
   return 0;
 }
 
 int
-_IO_default_showmanyc (fp)
-     _IO_FILE *fp;
+_IO_default_showmanyc (_IO_FILE *fp)
 {
   return -1;
 }
 
 void
-_IO_default_imbue (fp, locale)
-     _IO_FILE *fp;
-     void *locale;
+_IO_default_imbue (_IO_FILE *fp, void *locale)
 {
 }
 
@@ -1283,16 +1196,14 @@ _IO_iter_end (void)
 libc_hidden_def (_IO_iter_end)
 
 _IO_ITER
-_IO_iter_next(iter)
-    _IO_ITER iter;
+_IO_iter_next (_IO_ITER iter)
 {
   return iter->_chain;
 }
 libc_hidden_def (_IO_iter_next)
 
 _IO_FILE *
-_IO_iter_file(iter)
-    _IO_ITER iter;
+_IO_iter_file (_IO_ITER iter)
 {
   return iter;
 }
diff --git a/libio/getc.c b/libio/getc.c
index 270c47a..d19a229 100644
--- a/libio/getc.c
+++ b/libio/getc.c
@@ -30,8 +30,7 @@
 #undef _IO_getc
 
 int
-_IO_getc (fp)
-     FILE *fp;
+_IO_getc (FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/getwc.c b/libio/getwc.c
index a6e8fd7..7b64533 100644
--- a/libio/getwc.c
+++ b/libio/getwc.c
@@ -31,8 +31,7 @@
 #undef _IO_getwc
 
 wint_t
-_IO_getwc (fp)
-     FILE *fp;
+_IO_getwc (FILE *fp)
 {
   wint_t result;
   CHECK_FILE (fp, WEOF);
diff --git a/libio/iofclose.c b/libio/iofclose.c
index 3281e3f4..4e079ed 100644
--- a/libio/iofclose.c
+++ b/libio/iofclose.c
@@ -35,8 +35,7 @@
 #endif
 
 int
-_IO_new_fclose (fp)
-     _IO_FILE *fp;
+_IO_new_fclose (_IO_FILE *fp)
 {
   int status;
 
diff --git a/libio/iofdopen.c b/libio/iofdopen.c
index e7d84ae..e01524b 100644
--- a/libio/iofdopen.c
+++ b/libio/iofdopen.c
@@ -41,9 +41,7 @@
 #endif
 
 _IO_FILE *
-_IO_new_fdopen (fd, mode)
-     int fd;
-     const char *mode;
+_IO_new_fdopen (int fd, const char *mode)
 {
   int read_write;
   struct locked_FILE
diff --git a/libio/iofflush.c b/libio/iofflush.c
index 236e145..37a0f9c 100644
--- a/libio/iofflush.c
+++ b/libio/iofflush.c
@@ -28,8 +28,7 @@
 #include <stdio.h>
 
 int
-_IO_fflush (fp)
-     _IO_FILE *fp;
+_IO_fflush (_IO_FILE *fp)
 {
   if (fp == NULL)
     return _IO_flush_all ();
diff --git a/libio/iofflush_u.c b/libio/iofflush_u.c
index e004479..ee76373 100644
--- a/libio/iofflush_u.c
+++ b/libio/iofflush_u.c
@@ -28,8 +28,7 @@
 #include <stdio.h>
 
 int
-__fflush_unlocked (fp)
-     _IO_FILE *fp;
+__fflush_unlocked (_IO_FILE *fp)
 {
   if (fp == NULL)
     return _IO_flush_all ();
diff --git a/libio/iofgetpos.c b/libio/iofgetpos.c
index 8f900d51..9b7eec9 100644
--- a/libio/iofgetpos.c
+++ b/libio/iofgetpos.c
@@ -40,9 +40,7 @@
 #include <shlib-compat.h>
 
 int
-_IO_new_fgetpos (fp, posp)
-     _IO_FILE *fp;
-     _IO_fpos_t *posp;
+_IO_new_fgetpos (_IO_FILE *fp, _IO_fpos_t *posp)
 {
   _IO_off64_t pos;
   int result = 0;
diff --git a/libio/iofgetpos64.c b/libio/iofgetpos64.c
index 71b0d64..c9e7bb0 100644
--- a/libio/iofgetpos64.c
+++ b/libio/iofgetpos64.c
@@ -31,9 +31,7 @@
 #ifndef __OFF_T_MATCHES_OFF64_T
 
 int
-_IO_new_fgetpos64 (fp, posp)
-     _IO_FILE *fp;
-     _IO_fpos64_t *posp;
+_IO_new_fgetpos64 (_IO_FILE *fp, _IO_fpos64_t *posp)
 {
   _IO_off64_t pos;
   int result = 0;
diff --git a/libio/iofgets.c b/libio/iofgets.c
index f001b62..5fcb876 100644
--- a/libio/iofgets.c
+++ b/libio/iofgets.c
@@ -28,10 +28,7 @@
 #include <stdio.h>
 
 char *
-_IO_fgets (buf, n, fp)
-     char *buf;
-     int n;
-     _IO_FILE *fp;
+_IO_fgets (char *buf, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
diff --git a/libio/iofgets_u.c b/libio/iofgets_u.c
index f6acf64..8bbb3d3 100644
--- a/libio/iofgets_u.c
+++ b/libio/iofgets_u.c
@@ -28,10 +28,7 @@
 #include <stdio.h>
 
 char *
-__fgets_unlocked (buf, n, fp)
-     char *buf;
-     int n;
-     _IO_FILE *fp;
+__fgets_unlocked (char *buf, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   char *result;
diff --git a/libio/iofgetws.c b/libio/iofgetws.c
index a18fb3d..9ead37a 100644
--- a/libio/iofgetws.c
+++ b/libio/iofgetws.c
@@ -28,10 +28,7 @@
 #include <wchar.h>
 
 wchar_t *
-fgetws (buf, n, fp)
-     wchar_t *buf;
-     int n;
-     _IO_FILE *fp;
+fgetws (wchar_t *buf, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   wchar_t *result;
diff --git a/libio/iofgetws_u.c b/libio/iofgetws_u.c
index 6717978..124d587 100644
--- a/libio/iofgetws_u.c
+++ b/libio/iofgetws_u.c
@@ -28,10 +28,7 @@
 #include <wchar.h>
 
 wchar_t *
-fgetws_unlocked (buf, n, fp)
-     wchar_t *buf;
-     int n;
-     _IO_FILE *fp;
+fgetws_unlocked (wchar_t *buf, int n, _IO_FILE *fp)
 {
   _IO_size_t count;
   wchar_t *result;
diff --git a/libio/iofopen64.c b/libio/iofopen64.c
index 89f13aa..f602345 100644
--- a/libio/iofopen64.c
+++ b/libio/iofopen64.c
@@ -32,9 +32,7 @@
 #if !defined _LIBC || (defined O_LARGEFILE && O_LARGEFILE != 0)
 
 _IO_FILE *
-_IO_fopen64 (filename, mode)
-     const char *filename;
-     const char *mode;
+_IO_fopen64 (const char *filename, const char *mode)
 {
   return __fopen_internal (filename, mode, 0);
 }
diff --git a/libio/iofopncook.c b/libio/iofopncook.c
index 978a7fa..b16a263 100644
--- a/libio/iofopncook.c
+++ b/libio/iofopncook.c
@@ -40,10 +40,7 @@ static _IO_off64_t _IO_cookie_seekoff (_IO_FILE *fp, _IO_off64_t offset,
 static int _IO_cookie_close (_IO_FILE* fp);
 
 static _IO_ssize_t
-_IO_cookie_read (fp, buf, size)
-     _IO_FILE *fp;
-     void *buf;
-     _IO_ssize_t size;
+_IO_cookie_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
 {
   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
 
@@ -54,10 +51,7 @@ _IO_cookie_read (fp, buf, size)
 }
 
 static _IO_ssize_t
-_IO_cookie_write (fp, buf, size)
-     _IO_FILE *fp;
-     const void *buf;
-     _IO_ssize_t size;
+_IO_cookie_write (_IO_FILE *fp, const void *buf, _IO_ssize_t size)
 {
   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
 
@@ -75,10 +69,7 @@ _IO_cookie_write (fp, buf, size)
 }
 
 static _IO_off64_t
-_IO_cookie_seek (fp, offset, dir)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
+_IO_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
 {
   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
 
@@ -90,8 +81,7 @@ _IO_cookie_seek (fp, offset, dir)
 }
 
 static int
-_IO_cookie_close (fp)
-     _IO_FILE *fp;
+_IO_cookie_close (_IO_FILE *fp)
 {
   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
 
@@ -103,11 +93,7 @@ _IO_cookie_close (fp)
 
 
 static _IO_off64_t
-_IO_cookie_seekoff (fp, offset, dir, mode)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
-     int mode;
+_IO_cookie_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
 {
   /* We must force the fileops code to always use seek to determine
      the position.  */
@@ -218,10 +204,7 @@ _IO_FILE * _IO_old_fopencookie (void *cookie, const char *mode,
 
 static _IO_off64_t
 attribute_compat_text_section
-_IO_old_cookie_seek (fp, offset, dir)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
+_IO_old_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
 {
   struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
   int (*seek) (_IO_FILE *, _IO_off_t, int);
diff --git a/libio/iofputs.c b/libio/iofputs.c
index d1e34e4..504d0e9 100644
--- a/libio/iofputs.c
+++ b/libio/iofputs.c
@@ -28,9 +28,7 @@
 #include <string.h>
 
 int
-_IO_fputs (str, fp)
-      const char *str;
-      _IO_FILE *fp;
+_IO_fputs (const char *str, _IO_FILE *fp)
 {
   _IO_size_t len = strlen (str);
   int result = EOF;
diff --git a/libio/iofputs_u.c b/libio/iofputs_u.c
index f823686..4dc3e3c 100644
--- a/libio/iofputs_u.c
+++ b/libio/iofputs_u.c
@@ -29,9 +29,7 @@
 #include <string.h>
 
 int
-__fputs_unlocked (str, fp)
-      const char *str;
-      _IO_FILE *fp;
+__fputs_unlocked (const char *str, _IO_FILE *fp)
 {
   _IO_size_t len = strlen (str);
   int result = EOF;
diff --git a/libio/iofputws.c b/libio/iofputws.c
index 4c59a3a..b3b7f99 100644
--- a/libio/iofputws.c
+++ b/libio/iofputws.c
@@ -28,9 +28,7 @@
 #include <wchar.h>
 
 int
-fputws (str, fp)
-      const wchar_t *str;
-      _IO_FILE *fp;
+fputws (const wchar_t *str, _IO_FILE *fp)
 {
   _IO_size_t len = __wcslen (str);
   int result = EOF;
diff --git a/libio/iofputws_u.c b/libio/iofputws_u.c
index 092aeb4..aa7447b 100644
--- a/libio/iofputws_u.c
+++ b/libio/iofputws_u.c
@@ -29,9 +29,7 @@
 #include <wchar.h>
 
 int
-fputws_unlocked (str, fp)
-      const wchar_t *str;
-      _IO_FILE *fp;
+fputws_unlocked (const wchar_t *str, _IO_FILE *fp)
 {
   _IO_size_t len = __wcslen (str);
   int result = EOF;
diff --git a/libio/iofread.c b/libio/iofread.c
index 817df76..eb69b05 100644
--- a/libio/iofread.c
+++ b/libio/iofread.c
@@ -27,11 +27,7 @@
 #include "libioP.h"
 
 _IO_size_t
-_IO_fread (buf, size, count, fp)
-     void *buf;
-     _IO_size_t size;
-     _IO_size_t count;
-     _IO_FILE *fp;
+_IO_fread (void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
 {
   _IO_size_t bytes_requested = size * count;
   _IO_size_t bytes_read;
diff --git a/libio/iofread_u.c b/libio/iofread_u.c
index ba0bc3e..997b714 100644
--- a/libio/iofread_u.c
+++ b/libio/iofread_u.c
@@ -30,11 +30,7 @@
 #undef fread_unlocked
 
 _IO_size_t
-__fread_unlocked (buf, size, count, fp)
-     void *buf;
-     _IO_size_t size;
-     _IO_size_t count;
-     _IO_FILE *fp;
+__fread_unlocked (void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
 {
   _IO_size_t bytes_requested = size * count;
   _IO_size_t bytes_read;
diff --git a/libio/iofsetpos.c b/libio/iofsetpos.c
index 21cc2f7..ab031d1 100644
--- a/libio/iofsetpos.c
+++ b/libio/iofsetpos.c
@@ -39,9 +39,7 @@
 #include <shlib-compat.h>
 
 int
-_IO_new_fsetpos (fp, posp)
-     _IO_FILE *fp;
-     const _IO_fpos_t *posp;
+_IO_new_fsetpos (_IO_FILE *fp, const _IO_fpos_t *posp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/iofsetpos64.c b/libio/iofsetpos64.c
index 95ade6e..d0e7cfb 100644
--- a/libio/iofsetpos64.c
+++ b/libio/iofsetpos64.c
@@ -31,9 +31,7 @@
 #ifndef __OFF_T_MATCHES_OFF64_T
 
 int
-_IO_new_fsetpos64 (fp, posp)
-     _IO_FILE *fp;
-     const _IO_fpos64_t *posp;
+_IO_new_fsetpos64 (_IO_FILE *fp, const _IO_fpos64_t *posp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/ioftell.c b/libio/ioftell.c
index 5b7fec6..cf5b713 100644
--- a/libio/ioftell.c
+++ b/libio/ioftell.c
@@ -30,8 +30,7 @@
 /* ANSI explicily requires setting errno to a positive value on failure. */
 
 long int
-_IO_ftell (fp)
-     _IO_FILE *fp;
+_IO_ftell (_IO_FILE *fp)
 {
   _IO_off64_t pos;
   CHECK_FILE (fp, -1L);
diff --git a/libio/iofwrite.c b/libio/iofwrite.c
index 8913146..48ad4bc 100644
--- a/libio/iofwrite.c
+++ b/libio/iofwrite.c
@@ -27,11 +27,7 @@
 #include "libioP.h"
 
 _IO_size_t
-_IO_fwrite (buf, size, count, fp)
-     const void *buf;
-     _IO_size_t size;
-     _IO_size_t count;
-     _IO_FILE *fp;
+_IO_fwrite (const void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
 {
   _IO_size_t request = size * count;
   _IO_size_t written = 0;
diff --git a/libio/iogetdelim.c b/libio/iogetdelim.c
index ac93044..acc71cc 100644
--- a/libio/iogetdelim.c
+++ b/libio/iogetdelim.c
@@ -37,11 +37,7 @@
    null terminator), or -1 on error or EOF.  */
 
 _IO_ssize_t
-_IO_getdelim (lineptr, n, delimiter, fp)
-     char **lineptr;
-     _IO_size_t *n;
-     int delimiter;
-     _IO_FILE *fp;
+_IO_getdelim (char **lineptr, _IO_size_t *n, int delimiter, _IO_FILE *fp)
 {
   _IO_ssize_t result;
   _IO_ssize_t cur_len = 0;
diff --git a/libio/iogets.c b/libio/iogets.c
index 9851e77..ead0cb2 100644
--- a/libio/iogets.c
+++ b/libio/iogets.c
@@ -27,9 +27,8 @@
 #include "libioP.h"
 #include <limits.h>
 
-char*
-_IO_gets (buf)
-     char *buf;
+char *
+_IO_gets (char *buf)
 {
   _IO_size_t count;
   int ch;
diff --git a/libio/iopadn.c b/libio/iopadn.c
index 304ce08..b0acd8e 100644
--- a/libio/iopadn.c
+++ b/libio/iopadn.c
@@ -33,10 +33,7 @@ static char const zeroes[PADSIZE] =
 {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
 
 _IO_ssize_t
-_IO_padn (fp, pad, count)
-      _IO_FILE *fp;
-      int pad;
-      _IO_ssize_t count;
+_IO_padn (_IO_FILE *fp, int pad, _IO_ssize_t count)
 {
   char padbuf[PADSIZE];
   const char *padptr;
diff --git a/libio/iopopen.c b/libio/iopopen.c
index 53da776..bb6e996 100644
--- a/libio/iopopen.c
+++ b/libio/iopopen.c
@@ -106,10 +106,7 @@ unlock (void *not_used)
 #endif
 
 _IO_FILE *
-_IO_new_proc_open (fp, command, mode)
-     _IO_FILE *fp;
-     const char *command;
-     const char *mode;
+_IO_new_proc_open (_IO_FILE *fp, const char *command, const char *mode)
 {
   int read_or_write;
   int parent_end, child_end;
@@ -272,9 +269,7 @@ _IO_new_proc_open (fp, command, mode)
 }
 
 _IO_FILE *
-_IO_new_popen (command, mode)
-     const char *command;
-     const char *mode;
+_IO_new_popen (const char *command, const char *mode)
 {
   struct locked_FILE
   {
@@ -306,8 +301,7 @@ _IO_new_popen (command, mode)
 }
 
 int
-_IO_new_proc_close (fp)
-     _IO_FILE *fp;
+_IO_new_proc_close (_IO_FILE *fp)
 {
   /* This is not name-space clean. FIXME! */
   int wstatus;
diff --git a/libio/ioputs.c b/libio/ioputs.c
index 39b4bb7..c05e40e 100644
--- a/libio/ioputs.c
+++ b/libio/ioputs.c
@@ -29,8 +29,7 @@
 #include <limits.h>
 
 int
-_IO_puts (str)
-     const char *str;
+_IO_puts (const char *str)
 {
   int result = EOF;
   _IO_size_t len = strlen (str);
diff --git a/libio/ioseekoff.c b/libio/ioseekoff.c
index 11765cf..ef5c7d9 100644
--- a/libio/ioseekoff.c
+++ b/libio/ioseekoff.c
@@ -35,11 +35,7 @@ extern int errno;
 #endif
 
 _IO_off64_t
-_IO_seekoff_unlocked (fp, offset, dir, mode)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
-     int mode;
+_IO_seekoff_unlocked (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
 {
   if (dir != _IO_seek_cur && dir != _IO_seek_set && dir != _IO_seek_end)
     {
@@ -71,11 +67,7 @@ _IO_seekoff_unlocked (fp, offset, dir, mode)
 
 
 _IO_off64_t
-_IO_seekoff (fp, offset, dir, mode)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
-     int mode;
+_IO_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
 {
   _IO_off64_t retval;
 
diff --git a/libio/ioseekpos.c b/libio/ioseekpos.c
index a7652a1..2616985 100644
--- a/libio/ioseekpos.c
+++ b/libio/ioseekpos.c
@@ -27,10 +27,7 @@
 #include <libioP.h>
 
 _IO_off64_t
-_IO_seekpos_unlocked (fp, pos, mode)
-     _IO_FILE *fp;
-     _IO_off64_t pos;
-     int mode;
+_IO_seekpos_unlocked (_IO_FILE *fp, _IO_off64_t pos, int mode)
 {
   /* If we have a backup buffer, get rid of it, since the __seekoff
      callback may not know to do the right thing about it.
@@ -51,10 +48,7 @@ _IO_seekpos_unlocked (fp, pos, mode)
 
 
 _IO_off64_t
-_IO_seekpos (fp, pos, mode)
-     _IO_FILE *fp;
-     _IO_off64_t pos;
-     int mode;
+_IO_seekpos (_IO_FILE *fp, _IO_off64_t pos, int mode)
 {
   _IO_off64_t retval;
 
diff --git a/libio/iosetbuffer.c b/libio/iosetbuffer.c
index 0a41c10..4e10dce 100644
--- a/libio/iosetbuffer.c
+++ b/libio/iosetbuffer.c
@@ -27,10 +27,7 @@
 #include "libioP.h"
 
 void
-_IO_setbuffer (fp, buf, size)
-     _IO_FILE *fp;
-     char *buf;
-     _IO_size_t size;
+_IO_setbuffer (_IO_FILE *fp, char *buf, _IO_size_t size)
 {
   CHECK_FILE (fp, );
   _IO_acquire_lock (fp);
diff --git a/libio/iosetvbuf.c b/libio/iosetvbuf.c
index 71a64f8..5e3dd94 100644
--- a/libio/iosetvbuf.c
+++ b/libio/iosetvbuf.c
@@ -31,11 +31,7 @@
 #define _IONBF 2 /* No buffering. */
 
 int
-_IO_setvbuf (fp, buf, mode, size)
-     _IO_FILE *fp;
-     char *buf;
-     int mode;
-     _IO_size_t size;
+_IO_setvbuf (_IO_FILE *fp, char *buf, int mode, _IO_size_t size)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/ioungetc.c b/libio/ioungetc.c
index 8553399..7f1fdaf 100644
--- a/libio/ioungetc.c
+++ b/libio/ioungetc.c
@@ -27,9 +27,7 @@
 #include "libioP.h"
 
 int
-_IO_ungetc (c, fp)
-     int c;
-     _IO_FILE *fp;
+_IO_ungetc (int c, _IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/ioungetwc.c b/libio/ioungetwc.c
index afc5ce4..25fe67e 100644
--- a/libio/ioungetwc.c
+++ b/libio/ioungetwc.c
@@ -28,9 +28,7 @@
 #include <wchar.h>
 
 wint_t
-ungetwc (c, fp)
-     wint_t c;
-     _IO_FILE *fp;
+ungetwc (wint_t c, _IO_FILE *fp)
 {
   wint_t result;
   CHECK_FILE (fp, WEOF);
diff --git a/libio/iovdprintf.c b/libio/iovdprintf.c
index 116912a..f49ff5f 100644
--- a/libio/iovdprintf.c
+++ b/libio/iovdprintf.c
@@ -28,10 +28,7 @@
 #include <stdio_ext.h>
 
 int
-_IO_vdprintf (d, format, arg)
-     int d;
-     const char *format;
-     _IO_va_list arg;
+_IO_vdprintf (int d, const char *format, _IO_va_list arg)
 {
   struct _IO_FILE_plus tmpfil;
   struct _IO_wide_data wd;
diff --git a/libio/iovsscanf.c b/libio/iovsscanf.c
index c4fbd1b..be8346e 100644
--- a/libio/iovsscanf.c
+++ b/libio/iovsscanf.c
@@ -28,10 +28,7 @@
 #include "strfile.h"
 
 int
-_IO_vsscanf (string, format, args)
-     const char *string;
-     const char *format;
-     _IO_va_list args;
+_IO_vsscanf (const char *string, const char *format, _IO_va_list args)
 {
   int ret;
   _IO_strfile sf;
diff --git a/libio/iowpadn.c b/libio/iowpadn.c
index e65a649..affbd32 100644
--- a/libio/iowpadn.c
+++ b/libio/iowpadn.c
@@ -39,10 +39,7 @@ static wchar_t const zeroes[PADSIZE] =
 };
 
 _IO_ssize_t
-_IO_wpadn (fp, pad, count)
-      _IO_FILE *fp;
-      wint_t pad;
-      _IO_ssize_t count;
+_IO_wpadn (_IO_FILE *fp, wint_t pad, _IO_ssize_t count)
 {
   wchar_t padbuf[PADSIZE];
   const wchar_t *padptr;
diff --git a/libio/libc_fatal.c b/libio/libc_fatal.c
index 096cd28..677acc1 100644
--- a/libio/libc_fatal.c
+++ b/libio/libc_fatal.c
@@ -19,8 +19,7 @@
 
 /* Abort with an error message.  */
 void
-__libc_fatal (message)
-     const char *message;
+__libc_fatal (const char *message)
 {
   /* This function should write MESSAGE out in the most reliable way.
      It is called in situations like internal stdio lossage.  */
diff --git a/libio/memstream.c b/libio/memstream.c
index 84742d1..58a3484 100644
--- a/libio/memstream.c
+++ b/libio/memstream.c
@@ -61,9 +61,7 @@ static const struct _IO_jump_t _IO_mem_jumps =
    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
    and the number of characters written on fflush or fclose.  */
 _IO_FILE *
-__open_memstream (bufloc, sizeloc)
-     char **bufloc;
-     _IO_size_t *sizeloc;
+__open_memstream (char **bufloc, _IO_size_t *sizeloc)
 {
   struct locked_FILE
   {
@@ -105,8 +103,7 @@ weak_alias (__open_memstream, open_memstream)
 
 
 static int
-_IO_mem_sync (fp)
-     _IO_FILE* fp;
+_IO_mem_sync (_IO_FILE *fp)
 {
   struct _IO_FILE_memstream *mp = (struct _IO_FILE_memstream *) fp;
 
@@ -126,9 +123,7 @@ _IO_mem_sync (fp)
 
 
 static void
-_IO_mem_finish (fp, dummy)
-     _IO_FILE* fp;
-     int dummy;
+_IO_mem_finish (_IO_FILE *fp, int dummy)
 {
   struct _IO_FILE_memstream *mp = (struct _IO_FILE_memstream *) fp;
 
diff --git a/libio/oldfileops.c b/libio/oldfileops.c
index 25797c8..4bf0ddb 100644
--- a/libio/oldfileops.c
+++ b/libio/oldfileops.c
@@ -114,8 +114,7 @@ extern int errno;
 
 void
 attribute_compat_text_section
-_IO_old_file_init (fp)
-     struct _IO_FILE_plus *fp;
+_IO_old_file_init (struct _IO_FILE_plus *fp)
 {
   /* POSIX.1 allows another file handle to be used to change the position
      of our file descriptor.  Hence we actually don't know the actual
@@ -141,8 +140,7 @@ _IO_old_file_init (fp)
 
 int
 attribute_compat_text_section
-_IO_old_file_close_it (fp)
-     _IO_FILE *fp;
+_IO_old_file_close_it (_IO_FILE *fp)
 {
   int write_status, close_status;
   if (!_IO_file_is_open (fp))
@@ -170,9 +168,7 @@ _IO_old_file_close_it (fp)
 
 void
 attribute_compat_text_section
-_IO_old_file_finish (fp, dummy)
-     _IO_FILE *fp;
-     int dummy;
+_IO_old_file_finish (_IO_FILE *fp, int dummy)
 {
   if (_IO_file_is_open (fp))
     {
@@ -185,10 +181,7 @@ _IO_old_file_finish (fp, dummy)
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_file_fopen (fp, filename, mode)
-     _IO_FILE *fp;
-     const char *filename;
-     const char *mode;
+_IO_old_file_fopen (_IO_FILE *fp, const char *filename, const char *mode)
 {
   int oflags = 0, omode;
   int read_write, fdesc;
@@ -235,9 +228,7 @@ _IO_old_file_fopen (fp, filename, mode)
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_file_attach (fp, fd)
-     _IO_FILE *fp;
-     int fd;
+_IO_old_file_attach (_IO_FILE *fp, int fd)
 {
   if (_IO_file_is_open (fp))
     return NULL;
@@ -255,10 +246,7 @@ _IO_old_file_attach (fp, fd)
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_file_setbuf (fp, p, len)
-     _IO_FILE *fp;
-     char *p;
-     _IO_ssize_t len;
+_IO_old_file_setbuf (_IO_FILE *fp, char *p, _IO_ssize_t len)
 {
     if (_IO_default_setbuf (fp, p, len) == NULL)
       return NULL;
@@ -277,10 +265,7 @@ static int old_do_write (_IO_FILE *, const char *, _IO_size_t);
 
 int
 attribute_compat_text_section
-_IO_old_do_write (fp, data, to_do)
-     _IO_FILE *fp;
-     const char *data;
-     _IO_size_t to_do;
+_IO_old_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
 {
   return (to_do == 0 || (_IO_size_t) old_do_write (fp, data, to_do) == to_do)
 	 ? 0 : EOF;
@@ -288,10 +273,7 @@ _IO_old_do_write (fp, data, to_do)
 
 static int
 attribute_compat_text_section
-old_do_write (fp, data, to_do)
-     _IO_FILE *fp;
-     const char *data;
-     _IO_size_t to_do;
+old_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
 {
   _IO_size_t count;
   if (fp->_flags & _IO_IS_APPENDING)
@@ -321,8 +303,7 @@ old_do_write (fp, data, to_do)
 
 int
 attribute_compat_text_section
-_IO_old_file_underflow (fp)
-     _IO_FILE *fp;
+_IO_old_file_underflow (_IO_FILE *fp)
 {
   _IO_ssize_t count;
 #if 0
@@ -386,9 +367,7 @@ _IO_old_file_underflow (fp)
 
 int
 attribute_compat_text_section
-_IO_old_file_overflow (f, ch)
-      _IO_FILE *f;
-      int ch;
+_IO_old_file_overflow (_IO_FILE *f, int ch)
 {
   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
     {
@@ -438,8 +417,7 @@ _IO_old_file_overflow (f, ch)
 
 int
 attribute_compat_text_section
-_IO_old_file_sync (fp)
-     _IO_FILE *fp;
+_IO_old_file_sync (_IO_FILE *fp)
 {
   _IO_ssize_t delta;
   int retval = 0;
@@ -473,11 +451,7 @@ _IO_old_file_sync (fp)
 
 _IO_off64_t
 attribute_compat_text_section
-_IO_old_file_seekoff (fp, offset, dir, mode)
-     _IO_FILE *fp;
-     _IO_off64_t offset;
-     int dir;
-     int mode;
+_IO_old_file_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
 {
   _IO_off_t result;
   _IO_off64_t delta, new_offset;
@@ -660,10 +634,7 @@ resync:
 
 _IO_ssize_t
 attribute_compat_text_section
-_IO_old_file_write (f, data, n)
-     _IO_FILE *f;
-     const void *data;
-     _IO_ssize_t n;
+_IO_old_file_write (_IO_FILE *f, const void *data, _IO_ssize_t n)
 {
   _IO_ssize_t to_do = n;
   while (to_do > 0)
@@ -685,10 +656,7 @@ _IO_old_file_write (f, data, n)
 
 _IO_size_t
 attribute_compat_text_section
-_IO_old_file_xsputn (f, data, n)
-     _IO_FILE *f;
-     const void *data;
-     _IO_size_t n;
+_IO_old_file_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
 {
   const char *s = (char *) data;
   _IO_size_t to_do = n;
diff --git a/libio/oldiofclose.c b/libio/oldiofclose.c
index a967c2d..aee8c53 100644
--- a/libio/oldiofclose.c
+++ b/libio/oldiofclose.c
@@ -33,8 +33,7 @@
 
 int
 attribute_compat_text_section
-_IO_old_fclose (fp)
-     _IO_FILE *fp;
+_IO_old_fclose (_IO_FILE *fp)
 {
   int status;
 
diff --git a/libio/oldiofdopen.c b/libio/oldiofdopen.c
index e068ec7..f701858 100644
--- a/libio/oldiofdopen.c
+++ b/libio/oldiofdopen.c
@@ -38,9 +38,7 @@
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_fdopen (fd, mode)
-     int fd;
-     const char *mode;
+_IO_old_fdopen (int fd, const char *mode)
 {
   int read_write;
   int posix_mode = 0;
diff --git a/libio/oldiofgetpos.c b/libio/oldiofgetpos.c
index e76a5a1..0b4c350 100644
--- a/libio/oldiofgetpos.c
+++ b/libio/oldiofgetpos.c
@@ -32,9 +32,7 @@
 
 int
 attribute_compat_text_section
-_IO_old_fgetpos (fp, posp)
-     _IO_FILE *fp;
-     _IO_fpos_t *posp;
+_IO_old_fgetpos (_IO_FILE *fp, _IO_fpos_t *posp)
 {
   _IO_off_t pos;
   CHECK_FILE (fp, EOF);
diff --git a/libio/oldiofgetpos64.c b/libio/oldiofgetpos64.c
index db27f88..5a0b02b 100644
--- a/libio/oldiofgetpos64.c
+++ b/libio/oldiofgetpos64.c
@@ -32,9 +32,7 @@
 
 int
 attribute_compat_text_section
-_IO_old_fgetpos64 (fp, posp)
-     _IO_FILE *fp;
-     _IO_fpos64_t *posp;
+_IO_old_fgetpos64 (_IO_FILE *fp, _IO_fpos64_t *posp)
 {
   _IO_off64_t pos;
   CHECK_FILE (fp, EOF);
diff --git a/libio/oldiofopen.c b/libio/oldiofopen.c
index a90a601..0441d00 100644
--- a/libio/oldiofopen.c
+++ b/libio/oldiofopen.c
@@ -34,9 +34,7 @@
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_fopen (filename, mode)
-     const char *filename;
-     const char *mode;
+_IO_old_fopen (const char *filename, const char *mode)
 {
   struct locked_FILE
   {
diff --git a/libio/oldiofsetpos.c b/libio/oldiofsetpos.c
index 24571b4..b85cb82 100644
--- a/libio/oldiofsetpos.c
+++ b/libio/oldiofsetpos.c
@@ -31,9 +31,7 @@
 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
 int
 attribute_compat_text_section
-_IO_old_fsetpos (fp, posp)
-     _IO_FILE *fp;
-     const _IO_fpos_t *posp;
+_IO_old_fsetpos (_IO_FILE *fp, const _IO_fpos_t *posp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/oldiofsetpos64.c b/libio/oldiofsetpos64.c
index 3b8eba1..914c571 100644
--- a/libio/oldiofsetpos64.c
+++ b/libio/oldiofsetpos64.c
@@ -32,9 +32,7 @@
 
 int
 attribute_compat_text_section
-_IO_old_fsetpos64 (fp, posp)
-     _IO_FILE *fp;
-     const _IO_fpos64_t *posp;
+_IO_old_fsetpos64 (_IO_FILE *fp, const _IO_fpos64_t *posp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/oldiopopen.c b/libio/oldiopopen.c
index fb4c7b8..b22aa46 100644
--- a/libio/oldiopopen.c
+++ b/libio/oldiopopen.c
@@ -115,10 +115,7 @@ unlock (void *not_used)
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_proc_open (fp, command, mode)
-     _IO_FILE *fp;
-     const char *command;
-     const char *mode;
+_IO_old_proc_open (_IO_FILE *fp, const char *command, const char *mode)
 {
   volatile int read_or_write;
   volatile int parent_end, child_end;
@@ -194,9 +191,7 @@ _IO_old_proc_open (fp, command, mode)
 
 _IO_FILE *
 attribute_compat_text_section
-_IO_old_popen (command, mode)
-     const char *command;
-     const char *mode;
+_IO_old_popen (const char *command, const char *mode)
 {
   struct locked_FILE
   {
@@ -229,8 +224,7 @@ _IO_old_popen (command, mode)
 
 int
 attribute_compat_text_section
-_IO_old_proc_close (fp)
-     _IO_FILE *fp;
+_IO_old_proc_close (_IO_FILE *fp)
 {
   /* This is not name-space clean. FIXME! */
   int wstatus;
diff --git a/libio/oldpclose.c b/libio/oldpclose.c
index cafa405..2f29490 100644
--- a/libio/oldpclose.c
+++ b/libio/oldpclose.c
@@ -34,8 +34,7 @@
 
 int
 attribute_compat_text_section
-__old_pclose (fp)
-     FILE *fp;
+__old_pclose (FILE *fp)
 {
 #if 0
   /* Does not actually test that stream was created by popen(). Instead,
diff --git a/libio/pclose.c b/libio/pclose.c
index 019b74d..e79860e 100644
--- a/libio/pclose.c
+++ b/libio/pclose.c
@@ -30,8 +30,7 @@
 #include <shlib-compat.h>
 
 int
-__new_pclose (fp)
-     FILE *fp;
+__new_pclose (FILE *fp)
 {
 #if 0
   /* Does not actually test that stream was created by popen(). Instead,
diff --git a/libio/peekc.c b/libio/peekc.c
index c7b443b..af3b909 100644
--- a/libio/peekc.c
+++ b/libio/peekc.c
@@ -30,8 +30,7 @@
 #undef _IO_peekc
 
 int
-_IO_peekc_locked (fp)
-     _IO_FILE *fp;
+_IO_peekc_locked (_IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/putc.c b/libio/putc.c
index 46140de..fa0d72c 100644
--- a/libio/putc.c
+++ b/libio/putc.c
@@ -21,9 +21,7 @@
 #undef _IO_putc
 
 int
-_IO_putc (c, fp)
-     int c;
-     _IO_FILE *fp;
+_IO_putc (int c, _IO_FILE *fp)
 {
   int result;
   CHECK_FILE (fp, EOF);
diff --git a/libio/putc_u.c b/libio/putc_u.c
index e97a78e..80636dc 100644
--- a/libio/putc_u.c
+++ b/libio/putc_u.c
@@ -21,9 +21,7 @@
 #undef putc_unlocked
 
 int
-putc_unlocked (c, fp)
-     int c;
-     _IO_FILE *fp;
+putc_unlocked (int c, _IO_FILE *fp)
 {
   CHECK_FILE (fp, EOF);
   return _IO_putc_unlocked (c, fp);
diff --git a/libio/putchar.c b/libio/putchar.c
index d401d2b..ca8910a 100644
--- a/libio/putchar.c
+++ b/libio/putchar.c
@@ -21,8 +21,7 @@
 #undef putchar
 
 int
-putchar (c)
-     int c;
+putchar (int c)
 {
   int result;
   _IO_acquire_lock (_IO_stdout);
diff --git a/libio/putchar_u.c b/libio/putchar_u.c
index 2fd767b..2b90572 100644
--- a/libio/putchar_u.c
+++ b/libio/putchar_u.c
@@ -21,8 +21,7 @@
 #undef putchar_unlocked
 
 int
-putchar_unlocked (c)
-     int c;
+putchar_unlocked (int c)
 {
   CHECK_FILE (_IO_stdout, EOF);
   return _IO_putc_unlocked (c, _IO_stdout);
diff --git a/libio/putwc.c b/libio/putwc.c
index b441f24..91e1b07 100644
--- a/libio/putwc.c
+++ b/libio/putwc.c
@@ -19,9 +19,7 @@
 #include <wchar.h>
 
 wint_t
-putwc (wc, fp)
-     wchar_t wc;
-     _IO_FILE *fp;
+putwc (wchar_t wc, _IO_FILE *fp)
 {
   wint_t result;
   CHECK_FILE (fp, WEOF);
diff --git a/libio/putwc_u.c b/libio/putwc_u.c
index e2f59ec..0079f14 100644
--- a/libio/putwc_u.c
+++ b/libio/putwc_u.c
@@ -19,9 +19,7 @@
 #include <wchar.h>
 
 wint_t
-putwc_unlocked (wc, fp)
-     wchar_t wc;
-     _IO_FILE *fp;
+putwc_unlocked (wchar_t wc, _IO_FILE *fp)
 {
   CHECK_FILE (fp, WEOF);
   return _IO_putwc_unlocked (wc, fp);
diff --git a/libio/putwchar.c b/libio/putwchar.c
index 41d834b..0fefe3a 100644
--- a/libio/putwchar.c
+++ b/libio/putwchar.c
@@ -19,8 +19,7 @@
 #include <wchar.h>
 
 wint_t
-putwchar (wc)
-     wchar_t wc;
+putwchar (wchar_t wc)
 {
   wint_t result;
   _IO_acquire_lock (_IO_stdout);
diff --git a/libio/putwchar_u.c b/libio/putwchar_u.c
index dec9e38..792aec4 100644
--- a/libio/putwchar_u.c
+++ b/libio/putwchar_u.c
@@ -19,8 +19,7 @@
 #include <wchar.h>
 
 wint_t
-putwchar_unlocked (wc)
-     wchar_t wc;
+putwchar_unlocked (wchar_t wc)
 {
   CHECK_FILE (_IO_stdout, WEOF);
   return _IO_putwc_unlocked (wc, _IO_stdout);
diff --git a/libio/rewind.c b/libio/rewind.c
index baa804a..5a19106 100644
--- a/libio/rewind.c
+++ b/libio/rewind.c
@@ -28,8 +28,7 @@
 #include <stdio.h>
 
 void
-rewind (fp)
-     _IO_FILE *fp;
+rewind (_IO_FILE *fp)
 {
   CHECK_FILE (fp, );
   _IO_acquire_lock (fp);
diff --git a/libio/setbuf.c b/libio/setbuf.c
index a418bc1..251b487 100644
--- a/libio/setbuf.c
+++ b/libio/setbuf.c
@@ -28,9 +28,7 @@
 #include "stdio.h"
 
 void
-setbuf (fp, buf)
-     _IO_FILE *fp;
-     char *buf;
+setbuf (_IO_FILE *fp, char *buf)
 {
   _IO_setbuffer (fp, buf, _IO_BUFSIZ);
 }
diff --git a/libio/setlinebuf.c b/libio/setlinebuf.c
index 482f0af..ea763cf 100644
--- a/libio/setlinebuf.c
+++ b/libio/setlinebuf.c
@@ -30,8 +30,7 @@
 #undef setlinebuf
 
 void
-setlinebuf (stream)
-     _IO_FILE *stream;
+setlinebuf (_IO_FILE *stream)
 {
   _IO_setvbuf (stream, NULL, 1, 0);
 }
diff --git a/libio/vasprintf.c b/libio/vasprintf.c
index 7f9c105..61cdfdd 100644
--- a/libio/vasprintf.c
+++ b/libio/vasprintf.c
@@ -32,10 +32,7 @@
 #include "strfile.h"
 
 int
-_IO_vasprintf (result_ptr, format, args)
-     char **result_ptr;
-     const char *format;
-     _IO_va_list args;
+_IO_vasprintf (char **result_ptr, const char *format, _IO_va_list args)
 {
   /* Initial size of the buffer to be used.  Will be doubled each time an
      overflow occurs.  */
diff --git a/libio/vscanf.c b/libio/vscanf.c
index 5a17c1d..223f84f 100644
--- a/libio/vscanf.c
+++ b/libio/vscanf.c
@@ -30,9 +30,7 @@
 #undef vscanf
 
 int
-_IO_vscanf (format, args)
-     const char *format;
-     _IO_va_list args;
+_IO_vscanf (const char *format, _IO_va_list args)
 {
   return _IO_vfscanf (_IO_stdin, format, args, NULL);
 }
diff --git a/libio/vsnprintf.c b/libio/vsnprintf.c
index e2752d8..fdceb3d 100644
--- a/libio/vsnprintf.c
+++ b/libio/vsnprintf.c
@@ -30,9 +30,7 @@
 static int _IO_strn_overflow (_IO_FILE *fp, int c) __THROW;
 
 static int
-_IO_strn_overflow (fp, c)
-     _IO_FILE *fp;
-     int c;
+_IO_strn_overflow (_IO_FILE *fp, int c)
 {
   /* When we come to here this means the user supplied buffer is
      filled.  But since we must return the number of characters which
diff --git a/libio/vswprintf.c b/libio/vswprintf.c
index c10e586..1533a6d 100644
--- a/libio/vswprintf.c
+++ b/libio/vswprintf.c
@@ -31,9 +31,7 @@
 static wint_t _IO_wstrn_overflow (_IO_FILE *fp, wint_t c) __THROW;
 
 static wint_t
-_IO_wstrn_overflow (fp, c)
-     _IO_FILE *fp;
-     wint_t c;
+_IO_wstrn_overflow (_IO_FILE *fp, wint_t c)
 {
   /* When we come to here this means the user supplied buffer is
      filled.  But since we must return the number of characters which
diff --git a/libio/wfiledoalloc.c b/libio/wfiledoalloc.c
index 4acf3f8..dc71092 100644
--- a/libio/wfiledoalloc.c
+++ b/libio/wfiledoalloc.c
@@ -78,8 +78,7 @@
  */
 
 int
-_IO_wfile_doallocate (fp)
-     _IO_FILE *fp;
+_IO_wfile_doallocate (_IO_FILE *fp)
 {
   _IO_size_t size;
   wchar_t *p;
diff --git a/libio/wgenops.c b/libio/wgenops.c
index e7d2d1c..e038f2c 100644
--- a/libio/wgenops.c
+++ b/libio/wgenops.c
@@ -48,9 +48,7 @@ static int save_for_wbackup (_IO_FILE *fp, wchar_t *end_p) __THROW
 /* Return minimum _pos markers
    Assumes the current get area is the main get area. */
 _IO_ssize_t
-_IO_least_wmarker (fp, end_p)
-     _IO_FILE *fp;
-     wchar_t *end_p;
+_IO_least_wmarker (_IO_FILE *fp, wchar_t *end_p)
 {
   _IO_ssize_t least_so_far = end_p - fp->_wide_data->_IO_read_base;
   struct _IO_marker *mark;
@@ -63,8 +61,7 @@ libc_hidden_def (_IO_least_wmarker)
 
 /* Switch current get area from backup buffer to (start of) main get area. */
 void
-_IO_switch_to_main_wget_area (fp)
-     _IO_FILE *fp;
+_IO_switch_to_main_wget_area (_IO_FILE *fp)
 {
   wchar_t *tmp;
   fp->_flags &= ~_IO_IN_BACKUP;
@@ -84,8 +81,7 @@ libc_hidden_def (_IO_switch_to_main_wget_area)
 
 /* Switch current get area from main get area to (end of) backup area. */
 void
-_IO_switch_to_wbackup_area (fp)
-     _IO_FILE *fp;
+_IO_switch_to_wbackup_area (_IO_FILE *fp)
 {
   wchar_t *tmp;
   fp->_flags |= _IO_IN_BACKUP;
@@ -104,11 +100,7 @@ libc_hidden_def (_IO_switch_to_wbackup_area)
 
 
 void
-_IO_wsetb (f, b, eb, a)
-     _IO_FILE *f;
-     wchar_t *b;
-     wchar_t *eb;
-     int a;
+_IO_wsetb (_IO_FILE *f, wchar_t *b, wchar_t *eb, int a)
 {
   if (f->_wide_data->_IO_buf_base && !(f->_flags2 & _IO_FLAGS2_USER_WBUF))
     free (f->_wide_data->_IO_buf_base);
@@ -123,9 +115,7 @@ libc_hidden_def (_IO_wsetb)
 
 
 wint_t
-_IO_wdefault_pbackfail (fp, c)
-     _IO_FILE *fp;
-     wint_t c;
+_IO_wdefault_pbackfail (_IO_FILE *fp, wint_t c)
 {
   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
       && !_IO_in_backup (fp)
@@ -188,9 +178,7 @@ libc_hidden_def (_IO_wdefault_pbackfail)
 
 
 void
-_IO_wdefault_finish (fp, dummy)
-     _IO_FILE *fp;
-     int dummy;
+_IO_wdefault_finish (_IO_FILE *fp, int dummy)
 {
   struct _IO_marker *mark;
   if (fp->_wide_data->_IO_buf_base && !(fp->_flags2 & _IO_FLAGS2_USER_WBUF))
@@ -219,8 +207,7 @@ libc_hidden_def (_IO_wdefault_finish)
 
 
 wint_t
-_IO_wdefault_uflow (fp)
-     _IO_FILE *fp;
+_IO_wdefault_uflow (_IO_FILE *fp)
 {
   wint_t wch;
   wch = _IO_UNDERFLOW (fp);
@@ -232,9 +219,7 @@ libc_hidden_def (_IO_wdefault_uflow)
 
 
 wint_t
-__woverflow (f, wch)
-     _IO_FILE *f;
-     wint_t wch;
+__woverflow (_IO_FILE *f, wint_t wch)
 {
   if (f->_mode == 0)
     _IO_fwide (f, 1);
@@ -244,8 +229,7 @@ libc_hidden_def (__woverflow)
 
 
 wint_t
-__wuflow (fp)
-     _IO_FILE *fp;
+__wuflow (_IO_FILE *fp)
 {
   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
     return WEOF;
@@ -275,8 +259,7 @@ __wuflow (fp)
 libc_hidden_def (__wuflow)
 
 wint_t
-__wunderflow (fp)
-     _IO_FILE *fp;
+__wunderflow (_IO_FILE *fp)
 {
   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
     return WEOF;
@@ -307,10 +290,7 @@ libc_hidden_def (__wunderflow)
 
 
 _IO_size_t
-_IO_wdefault_xsputn (f, data, n)
-     _IO_FILE *f;
-     const void *data;
-     _IO_size_t n;
+_IO_wdefault_xsputn (_IO_FILE *f, const void *data, _IO_size_t n)
 {
   const wchar_t *s = (const wchar_t *) data;
   _IO_size_t more = n;
@@ -358,10 +338,7 @@ libc_hidden_def (_IO_wdefault_xsputn)
 
 
 _IO_size_t
-_IO_wdefault_xsgetn (fp, data, n)
-     _IO_FILE *fp;
-     void *data;
-     _IO_size_t n;
+_IO_wdefault_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
 {
   _IO_size_t more = n;
   wchar_t *s = (wchar_t*) data;
@@ -405,8 +382,7 @@ libc_hidden_def (_IO_wdefault_xsgetn)
 
 
 void
-_IO_wdoallocbuf (fp)
-     _IO_FILE *fp;
+_IO_wdoallocbuf (_IO_FILE *fp)
 {
   if (fp->_wide_data->_IO_buf_base)
     return;
@@ -420,8 +396,7 @@ libc_hidden_def (_IO_wdoallocbuf)
 
 
 int
-_IO_wdefault_doallocate (fp)
-     _IO_FILE *fp;
+_IO_wdefault_doallocate (_IO_FILE *fp)
 {
   wchar_t *buf;
 
@@ -435,8 +410,7 @@ libc_hidden_def (_IO_wdefault_doallocate)
 
 
 int
-_IO_switch_to_wget_mode (fp)
-     _IO_FILE *fp;
+_IO_switch_to_wget_mode (_IO_FILE *fp)
 {
   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
     if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
@@ -460,8 +434,7 @@ _IO_switch_to_wget_mode (fp)
 libc_hidden_def (_IO_switch_to_wget_mode)
 
 void
-_IO_free_wbackup_area (fp)
-     _IO_FILE *fp;
+_IO_free_wbackup_area (_IO_FILE *fp)
 {
   if (_IO_in_backup (fp))
     _IO_switch_to_main_wget_area (fp);  /* Just in case. */
@@ -474,8 +447,7 @@ libc_hidden_def (_IO_free_wbackup_area)
 
 #if 0
 int
-_IO_switch_to_wput_mode (fp)
-     _IO_FILE *fp;
+_IO_switch_to_wput_mode (_IO_FILE *fp)
 {
   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_read_ptr;
   fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_read_ptr;
@@ -594,9 +566,7 @@ save_for_wbackup (fp, end_p)
 }
 
 wint_t
-_IO_sputbackwc (fp, c)
-     _IO_FILE *fp;
-     wint_t c;
+_IO_sputbackwc (_IO_FILE *fp, wint_t c)
 {
   wint_t result;
 
@@ -617,8 +587,7 @@ _IO_sputbackwc (fp, c)
 libc_hidden_def (_IO_sputbackwc)
 
 wint_t
-_IO_sungetwc (fp)
-     _IO_FILE *fp;
+_IO_sungetwc (_IO_FILE *fp)
 {
   wint_t result;
 
@@ -638,10 +607,7 @@ _IO_sungetwc (fp)
 
 
 unsigned
-_IO_adjust_wcolumn (start, line, count)
-     unsigned start;
-     const wchar_t *line;
-     int count;
+_IO_adjust_wcolumn (unsigned start, const wchar_t *line, int count)
 {
   const wchar_t *ptr = line + count;
   while (ptr > line)
@@ -651,9 +617,7 @@ _IO_adjust_wcolumn (start, line, count)
 }
 
 void
-_IO_init_wmarker (marker, fp)
-     struct _IO_marker *marker;
-     _IO_FILE *fp;
+_IO_init_wmarker (struct _IO_marker *marker, _IO_FILE *fp)
 {
   marker->_sbuf = fp;
   if (_IO_in_put_mode (fp))
@@ -673,8 +637,7 @@ _IO_init_wmarker (marker, fp)
 
 /* Return difference between MARK and current position of MARK's stream. */
 int
-_IO_wmarker_delta (mark)
-     struct _IO_marker *mark;
+_IO_wmarker_delta (struct _IO_marker *mark)
 {
   int cur_pos;
   if (mark->_sbuf == NULL)
@@ -689,10 +652,7 @@ _IO_wmarker_delta (mark)
 }
 
 int
-_IO_seekwmark (fp, mark, delta)
-     _IO_FILE *fp;
-     struct _IO_marker *mark;
-     int delta;
+_IO_seekwmark (_IO_FILE *fp, struct _IO_marker *mark, int delta)
 {
   if (mark->_sbuf != fp)
     return EOF;
@@ -713,8 +673,7 @@ _IO_seekwmark (fp, mark, delta)
 }
 
 void
-_IO_unsave_wmarkers (fp)
-     _IO_FILE *fp;
+_IO_unsave_wmarkers (_IO_FILE *fp)
 {
   struct _IO_marker *mark = fp->_markers;
   if (mark)
diff --git a/libio/wmemstream.c b/libio/wmemstream.c
index 61b5d8b..f20c9a3 100644
--- a/libio/wmemstream.c
+++ b/libio/wmemstream.c
@@ -62,9 +62,7 @@ static const struct _IO_jump_t _IO_wmem_jumps =
    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
    and the number of characters written on fflush or fclose.  */
 _IO_FILE *
-open_wmemstream (bufloc, sizeloc)
-     wchar_t **bufloc;
-     _IO_size_t *sizeloc;
+open_wmemstream (wchar_t **bufloc, _IO_size_t *sizeloc)
 {
   struct locked_FILE
   {
@@ -105,8 +103,7 @@ open_wmemstream (bufloc, sizeloc)
 
 
 static int
-_IO_wmem_sync (fp)
-     _IO_FILE* fp;
+_IO_wmem_sync (_IO_FILE *fp)
 {
   struct _IO_FILE_wmemstream *mp = (struct _IO_FILE_wmemstream *) fp;
 
@@ -127,9 +124,7 @@ _IO_wmem_sync (fp)
 
 
 static void
-_IO_wmem_finish (fp, dummy)
-     _IO_FILE* fp;
-     int dummy;
+_IO_wmem_finish (_IO_FILE *fp, int dummy)
 {
   struct _IO_FILE_wmemstream *mp = (struct _IO_FILE_wmemstream *) fp;
 
diff --git a/locale/nl_langinfo.c b/locale/nl_langinfo.c
index ccd7ea4..69749a4 100644
--- a/locale/nl_langinfo.c
+++ b/locale/nl_langinfo.c
@@ -26,8 +26,7 @@
 /* Return a string with the data for locale-dependent parameter ITEM.  */
 
 char *
-nl_langinfo (item)
-     nl_item item;
+nl_langinfo (nl_item item)
 {
   return __nl_langinfo_l (item, _NL_CURRENT_LOCALE);
 }
diff --git a/locale/nl_langinfo_l.c b/locale/nl_langinfo_l.c
index 156e09a..db2b094 100644
--- a/locale/nl_langinfo_l.c
+++ b/locale/nl_langinfo_l.c
@@ -27,9 +27,7 @@
 /* Return a string with the data for locale-dependent parameter ITEM.  */
 
 char *
-__nl_langinfo_l (item, l)
-     nl_item item;
-     __locale_t l;
+__nl_langinfo_l (nl_item item, __locale_t l)
 {
   int category = _NL_ITEM_CATEGORY (item);
   unsigned int index = _NL_ITEM_INDEX (item);
diff --git a/locale/programs/simple-hash.c b/locale/programs/simple-hash.c
index a4412f9..2c81185 100644
--- a/locale/programs/simple-hash.c
+++ b/locale/programs/simple-hash.c
@@ -66,9 +66,7 @@ static int is_prime (unsigned long int candidate);
 
 
 int
-init_hash (htab, init_size)
-     hash_table *htab;
-     unsigned long int init_size;
+init_hash (hash_table *htab, unsigned long int init_size)
 {
   /* We need the size to be a prime.  */
   init_size = next_prime (init_size);
@@ -88,8 +86,7 @@ init_hash (htab, init_size)
 
 
 int
-delete_hash (htab)
-     hash_table *htab;
+delete_hash (hash_table *htab)
 {
   free (htab->table);
   obstack_free (&htab->mem_pool, NULL);
@@ -98,11 +95,7 @@ delete_hash (htab)
 
 
 int
-insert_entry (htab, key, keylen, data)
-     hash_table *htab;
-     const void *key;
-     size_t keylen;
-     void *data;
+insert_entry (hash_table *htab, const void *key, size_t keylen, void *data)
 {
   unsigned long int hval = compute_hashval (key, keylen);
   hash_entry *table = (hash_entry *) htab->table;
@@ -194,11 +187,7 @@ find_entry (htab, key, keylen, result)
 
 
 int
-set_entry (htab, key, keylen, newval)
-     hash_table *htab;
-     const void *key;
-     size_t keylen;
-     void *newval;
+set_entry (hash_table *htab, const void *key, size_t keylen, void *newval)
 {
   hash_entry *table = (hash_entry *) htab->table;
   size_t idx = lookup (htab, key, keylen, compute_hashval (key, keylen));
@@ -287,8 +276,7 @@ lookup (htab, key, keylen, hval)
 
 
 unsigned long int
-next_prime (seed)
-     unsigned long int seed;
+next_prime (unsigned long int seed)
 {
   /* Make it definitely odd.  */
   seed |= 1;
@@ -301,8 +289,7 @@ next_prime (seed)
 
 
 static int
-is_prime (candidate)
-     unsigned long int candidate;
+is_prime (unsigned long int candidate)
 {
   /* No even number and none less than 10 will be passed here.  */
   unsigned long int divn = 3;
diff --git a/locale/programs/xmalloc.c b/locale/programs/xmalloc.c
index 36bc17f..2528c5f 100644
--- a/locale/programs/xmalloc.c
+++ b/locale/programs/xmalloc.c
@@ -52,8 +52,7 @@ void free ();
 int xmalloc_exit_failure = EXIT_FAILURE;
 
 static VOID *
-fixup_null_alloc (n)
-     size_t n;
+fixup_null_alloc (size_t n)
 {
   VOID *p;
 
@@ -68,8 +67,7 @@ fixup_null_alloc (n)
 /* Allocate N bytes of memory dynamically, with error checking.  */
 
 VOID *
-xmalloc (n)
-     size_t n;
+xmalloc (size_t n)
 {
   VOID *p;
 
@@ -98,9 +96,7 @@ xcalloc (n, s)
    If P is NULL, run xmalloc.  */
 
 VOID *
-xrealloc (p, n)
-     VOID *p;
-     size_t n;
+xrealloc (VOID *p, size_t n)
 {
   if (p == 0)
     return xmalloc (n);
diff --git a/locale/programs/xstrdup.c b/locale/programs/xstrdup.c
index a8fadb3..445d67c 100644
--- a/locale/programs/xstrdup.c
+++ b/locale/programs/xstrdup.c
@@ -30,8 +30,7 @@ char *xstrdup (char *string) __THROW;
 /* Return a newly allocated copy of STRING.  */
 
 char *
-xstrdup (string)
-     char *string;
+xstrdup (char *string)
 {
   return strcpy (xmalloc (strlen (string) + 1), string);
 }
diff --git a/localedata/collate-test.c b/localedata/collate-test.c
index e2bb99c..0b3ec73 100644
--- a/localedata/collate-test.c
+++ b/localedata/collate-test.c
@@ -121,9 +121,7 @@ main (int argc, char *argv[])
 
 
 static int
-xstrcoll (ptr1, ptr2)
-     const void *ptr1;
-     const void *ptr2;
+xstrcoll (const void *ptr1, const void *ptr2)
 {
   const struct lines *l1 = (const struct lines *) ptr1;
   const struct lines *l2 = (const struct lines *) ptr2;
diff --git a/localedata/xfrm-test.c b/localedata/xfrm-test.c
index 3ab21402f..35b1a63 100644
--- a/localedata/xfrm-test.c
+++ b/localedata/xfrm-test.c
@@ -172,9 +172,7 @@ main (int argc, char *argv[])
 
 
 static int
-xstrcmp (ptr1, ptr2)
-     const void *ptr1;
-     const void *ptr2;
+xstrcmp (const void *ptr1, const void *ptr2)
 {
   const struct lines *l1 = (const struct lines *) ptr1;
   const struct lines *l2 = (const struct lines *) ptr2;
diff --git a/login/getlogin_r.c b/login/getlogin_r.c
index 8848b61..2d9a903 100644
--- a/login/getlogin_r.c
+++ b/login/getlogin_r.c
@@ -23,9 +23,7 @@
    If it cannot be determined or some other error occurred, return the error
    code.  Otherwise return 0.  */
 int
-__getlogin_r (name, name_len)
-     char *name;
-     size_t name_len;
+__getlogin_r (char *name, size_t name_len)
 {
   __set_errno (ENOSYS);
   return errno;
diff --git a/login/getpt.c b/login/getpt.c
index a60f01b..bfc712f 100644
--- a/login/getpt.c
+++ b/login/getpt.c
@@ -31,8 +31,7 @@ weak_alias (__getpt, getpt)
 
 /* We cannot define posix_openpt in general for BSD systems.  */
 int
-__posix_openpt (oflag)
-     int oflag;
+__posix_openpt (int oflag)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/login/login_tty.c b/login/login_tty.c
index 2ba276d..a94f5cb 100644
--- a/login/login_tty.c
+++ b/login/login_tty.c
@@ -39,8 +39,7 @@ static char sccsid[] = "@(#)login_tty.c	8.1 (Berkeley) 6/4/93";
 #include <utmp.h>
 
 int
-login_tty(fd)
-	int fd;
+login_tty (int fd)
 {
 	(void) setsid();
 #ifdef TIOCSCTTY
diff --git a/login/setlogin.c b/login/setlogin.c
index c07d7cb..40b62a3 100644
--- a/login/setlogin.c
+++ b/login/setlogin.c
@@ -20,8 +20,7 @@
 
 /* Set the login name returned by `getlogin'.  */
 int
-setlogin (name)
-     const char *name;
+setlogin (const char *name)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/mach/msg-destroy.c b/mach/msg-destroy.c
index aad7a770..bc7dd55 100644
--- a/mach/msg-destroy.c
+++ b/mach/msg-destroy.c
@@ -58,8 +58,7 @@ static void mach_msg_destroy_memory(vm_offset_t, vm_size_t);
  */
 
 void
-__mach_msg_destroy(msg)
-    mach_msg_header_t *msg;
+__mach_msg_destroy (mach_msg_header_t *msg)
 {
     mach_msg_bits_t mbits = msg->msgh_bits;
 
@@ -192,9 +191,7 @@ __mach_msg_destroy(msg)
 weak_alias (__mach_msg_destroy, mach_msg_destroy)
 
 static void
-mach_msg_destroy_port(port, type)
-    mach_port_t port;
-    mach_msg_type_name_t type;
+mach_msg_destroy_port (mach_port_t port, mach_msg_type_name_t type)
 {
     if (MACH_PORT_VALID(port)) switch (type) {
       case MACH_MSG_TYPE_MOVE_SEND:
@@ -227,9 +224,7 @@ mach_msg_destroy_port(port, type)
 }
 
 static void
-mach_msg_destroy_memory(addr, size)
-    vm_offset_t addr;
-    vm_size_t size;
+mach_msg_destroy_memory (vm_offset_t addr, vm_size_t size)
 {
     if (size > 0)
 	(void) __vm_deallocate(__mach_task_self(), addr, size);
diff --git a/malloc/mcheck.c b/malloc/mcheck.c
index d430318..6a5f01e 100644
--- a/malloc/mcheck.c
+++ b/malloc/mcheck.c
@@ -69,10 +69,8 @@ static int pedantic;
 # define flood memset
 #else
 static void flood (__ptr_t, int, size_t);
-static void flood (ptr, val, size)
-__ptr_t ptr;
-int val;
-size_t size;
+static void
+flood (__ptr_t ptr, int val, size_t size)
 {
   char *cp = ptr;
   while (size--)
diff --git a/misc/acct.c b/misc/acct.c
index c5569e5..5423317 100644
--- a/misc/acct.c
+++ b/misc/acct.c
@@ -22,8 +22,7 @@
    a record for each process as it terminates, to this file.  If NAME is NULL,
    turn accounting off.  This call is restricted to the super-user.  */
 int
-acct (name)
-     const char *name;
+acct (const char *name)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/brk.c b/misc/brk.c
index 28c4203..e3d4fa3 100644
--- a/misc/brk.c
+++ b/misc/brk.c
@@ -24,8 +24,7 @@ void *__curbrk;
 /* Set the end of the process's data space to ADDR.
    Return 0 if successful, -1 if not.  */
 int
-__brk (addr)
-     void *addr;
+__brk (void *addr)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/chflags.c b/misc/chflags.c
index 241be86..84cc606 100644
--- a/misc/chflags.c
+++ b/misc/chflags.c
@@ -24,9 +24,7 @@
 int chflags (const char *file, unsigned long int flags) __THROW;
 
 int
-chflags (file, flags)
-     const char *file;
-     unsigned long int flags;
+chflags (const char *file, unsigned long int flags)
 {
   if (file == NULL)
     {
diff --git a/misc/chroot.c b/misc/chroot.c
index 232a29f..4c0fe7d 100644
--- a/misc/chroot.c
+++ b/misc/chroot.c
@@ -21,8 +21,7 @@
 /* Make PATH be the root directory (the starting point for absolute paths).
    This call is restricted to the super-user.  */
 int
-chroot (path)
-     const char *path;
+chroot (const char *path)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/fchflags.c b/misc/fchflags.c
index b9f2675..ad0d728 100644
--- a/misc/fchflags.c
+++ b/misc/fchflags.c
@@ -24,9 +24,7 @@
 int fchflags (int fd, unsigned long int flags) __THROW;
 
 int
-fchflags (fd, flags)
-     int fd;
-     unsigned long int flags;
+fchflags (int fd, unsigned long int flags)
 {
   if (fd < 0)
     {
diff --git a/misc/fstab.c b/misc/fstab.c
index 97c62fe..244db81 100644
--- a/misc/fstab.c
+++ b/misc/fstab.c
@@ -61,8 +61,7 @@ getfsent (void)
 
 
 struct fstab *
-getfsspec (name)
-     const char *name;
+getfsspec (const char *name)
 {
   struct fstab_state *state;
   struct mntent *m;
@@ -78,8 +77,7 @@ getfsspec (name)
 
 
 struct fstab *
-getfsfile (name)
-     const char *name;
+getfsfile (const char *name)
 {
   struct fstab_state *state;
   struct mntent *m;
diff --git a/misc/fsync.c b/misc/fsync.c
index 05f3acf..8f1d959 100644
--- a/misc/fsync.c
+++ b/misc/fsync.c
@@ -20,8 +20,7 @@
 
 /* Make all changes done to FD actually appear on disk.  */
 int
-fsync (fd)
-     int fd;
+fsync (int fd)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/ftruncate.c b/misc/ftruncate.c
index 2d43c76..a015c6e 100644
--- a/misc/ftruncate.c
+++ b/misc/ftruncate.c
@@ -21,9 +21,7 @@
 
 /* Truncate the file referenced by FD to LENGTH bytes.  */
 int
-__ftruncate (fd, length)
-     int fd;
-     off_t length;
+__ftruncate (int fd, off_t length)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/ftruncate64.c b/misc/ftruncate64.c
index 1c41fea..2e71bed 100644
--- a/misc/ftruncate64.c
+++ b/misc/ftruncate64.c
@@ -21,9 +21,7 @@
 
 /* Truncate the file referenced by FD to LENGTH bytes.  */
 int
-__ftruncate64 (fd, length)
-     int fd;
-     off64_t length;
+__ftruncate64 (int fd, off64_t length)
 {
   if ((off_t) length != length)
     {
diff --git a/misc/getdomain.c b/misc/getdomain.c
index c5ab3a5..db57c3d 100644
--- a/misc/getdomain.c
+++ b/misc/getdomain.c
@@ -29,9 +29,7 @@
 /* The `uname' information includes the domain name.  */
 
 int
-getdomainname (name, len)
-    char *name;
-    size_t len;
+getdomainname (char *name, size_t len)
 {
   struct utsname u;
   size_t u_len;
@@ -47,9 +45,7 @@ getdomainname (name, len)
 #else
 
 int
-getdomainname (name, len)
-     char *name;
-     size_t len;
+getdomainname (char *name, size_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/gethostname.c b/misc/gethostname.c
index 15097a8..ca682b4 100644
--- a/misc/gethostname.c
+++ b/misc/gethostname.c
@@ -22,9 +22,7 @@
    The result is null-terminated if LEN is large enough for the full
    name and the terminator.  */
 int
-__gethostname (name, len)
-     char *name;
-     size_t len;
+__gethostname (char *name, size_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/getpass.c b/misc/getpass.c
index 78fe8f2..a6d1c88 100644
--- a/misc/getpass.c
+++ b/misc/getpass.c
@@ -43,8 +43,7 @@ call_fclose (void *arg)
 }
 
 char *
-getpass (prompt)
-     const char *prompt;
+getpass (const char *prompt)
 {
   FILE *in, *out;
   struct termios s, t;
diff --git a/misc/getttyent.c b/misc/getttyent.c
index fcdbc22..d2af870 100644
--- a/misc/getttyent.c
+++ b/misc/getttyent.c
@@ -142,8 +142,7 @@ weak_alias (__getttyent, getttyent)
  */
 static char *
 internal_function
-skip(p)
-	char *p;
+skip (char *p)
 {
 	char *t;
 	int c, q;
@@ -177,8 +176,7 @@ skip(p)
 
 static char *
 internal_function
-value(p)
-	char *p;
+value (char *p)
 {
 
 	return ((p = index(p, '=')) ? ++p : NULL);
diff --git a/misc/gtty.c b/misc/gtty.c
index 9a64a9a..798185e 100644
--- a/misc/gtty.c
+++ b/misc/gtty.c
@@ -21,9 +21,7 @@
 
 /* Fill in *PARAMS with terminal parameters associated with FD.  */
 int
-gtty (fd, params)
-     int fd;
-     struct sgttyb *params;
+gtty (int fd, struct sgttyb *params)
 {
   if (params == NULL)
     {
diff --git a/misc/hsearch.c b/misc/hsearch.c
index 7a0b0dc..9442f69 100644
--- a/misc/hsearch.c
+++ b/misc/hsearch.c
@@ -24,9 +24,7 @@ static struct hsearch_data htab;
 
 /* Define the non-reentrant function using the reentrant counterparts.  */
 ENTRY *
-hsearch (item, action)
-     ENTRY item;
-     ACTION action;
+hsearch (ENTRY item, ACTION action)
 {
   ENTRY *result;
 
@@ -37,8 +35,7 @@ hsearch (item, action)
 
 
 int
-hcreate (nel)
-     size_t nel;
+hcreate (size_t nel)
 {
   return __hcreate_r (nel, &htab);
 }
diff --git a/misc/hsearch_r.c b/misc/hsearch_r.c
index 559df29..9d6cd81 100644
--- a/misc/hsearch_r.c
+++ b/misc/hsearch_r.c
@@ -62,9 +62,7 @@ isprime (unsigned int number)
    The contents of the table is zeroed, especially the field used
    becomes zero.  */
 int
-__hcreate_r (nel, htab)
-     size_t nel;
-     struct hsearch_data *htab;
+__hcreate_r (size_t nel, struct hsearch_data *htab)
 {
   /* Test for correct arguments.  */
   if (htab == NULL)
@@ -111,8 +109,7 @@ weak_alias (__hcreate_r, hcreate_r)
 /* After using the hash table it has to be destroyed. The used memory can
    be freed and the local static variable can be marked as not used.  */
 void
-__hdestroy_r (htab)
-     struct hsearch_data *htab;
+__hdestroy_r (struct hsearch_data *htab)
 {
   /* Test for correct arguments.  */
   if (htab == NULL)
diff --git a/misc/ioctl.c b/misc/ioctl.c
index f75f3e4..d07c3d9 100644
--- a/misc/ioctl.c
+++ b/misc/ioctl.c
@@ -21,9 +21,7 @@
 /* Perform the I/O control operation specified by REQUEST on FD.
    The actual type and use of ARG and the return value depend on REQUEST.  */
 int
-__ioctl (fd, request)
-     int fd;
-     unsigned long int request;
+__ioctl (int fd, unsigned long int request)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/mkdtemp.c b/misc/mkdtemp.c
index 1f733cd..1da1062 100644
--- a/misc/mkdtemp.c
+++ b/misc/mkdtemp.c
@@ -24,8 +24,7 @@
    The directory is created, mode 700, and its name is returned.
    (This function comes from OpenBSD.) */
 char *
-mkdtemp (template)
-     char *template;
+mkdtemp (char *template)
 {
   if (__gen_tempname (template, 0, 0, __GT_DIR))
     return NULL;
diff --git a/misc/mkostemp.c b/misc/mkostemp.c
index 807e477..73d952b 100644
--- a/misc/mkostemp.c
+++ b/misc/mkostemp.c
@@ -27,9 +27,7 @@
    they are replaced with a string that makes the filename unique.
    Then open the file and return a fd. */
 int
-mkostemp (template, flags)
-     char *template;
-     int flags;
+mkostemp (char *template, int flags)
 {
   return __gen_tempname (template, 0, flags, __GT_FILE);
 }
diff --git a/misc/mkostemp64.c b/misc/mkostemp64.c
index 2b9c868..0581553 100644
--- a/misc/mkostemp64.c
+++ b/misc/mkostemp64.c
@@ -27,9 +27,7 @@
    they are replaced with a string that makes the filename unique.
    Then open the file and return a fd. */
 int
-mkostemp64 (template, flags)
-     char *template;
-     int flags;
+mkostemp64 (char *template, int flags)
 {
   return __gen_tempname (template, 0, flags | O_LARGEFILE, __GT_FILE);
 }
diff --git a/misc/mkostemps.c b/misc/mkostemps.c
index 892dc69..a7ef17b 100644
--- a/misc/mkostemps.c
+++ b/misc/mkostemps.c
@@ -28,10 +28,7 @@
    "XXXXXX"; they are replaced with a string that makes the filename
    unique.  Then open the file and return a fd. */
 int
-mkostemps (template, suffixlen, flags)
-     char *template;
-     int suffixlen;
-     int flags;
+mkostemps (char *template, int suffixlen, int flags)
 {
   if (suffixlen < 0)
     {
diff --git a/misc/mkostemps64.c b/misc/mkostemps64.c
index 7b48b5c..02ab259 100644
--- a/misc/mkostemps64.c
+++ b/misc/mkostemps64.c
@@ -28,10 +28,7 @@
    "XXXXXX"; they are replaced with a string that makes the filename
    unique.  Then open the file and return a fd. */
 int
-mkostemps64 (template, suffixlen, flags)
-     char *template;
-     int suffixlen;
-     int flags;
+mkostemps64 (char *template, int suffixlen, int flags)
 {
   if (suffixlen < 0)
     {
diff --git a/misc/mkstemp.c b/misc/mkstemp.c
index c5018d1..638115f 100644
--- a/misc/mkstemp.c
+++ b/misc/mkstemp.c
@@ -27,8 +27,7 @@
    they are replaced with a string that makes the filename unique.
    Then open the file and return a fd. */
 int
-mkstemp (template)
-     char *template;
+mkstemp (char *template)
 {
   return __gen_tempname (template, 0, 0, __GT_FILE);
 }
diff --git a/misc/mkstemp64.c b/misc/mkstemp64.c
index e4b8605..340171b 100644
--- a/misc/mkstemp64.c
+++ b/misc/mkstemp64.c
@@ -27,8 +27,7 @@
    they are replaced with a string that makes the filename unique.
    Then open the file and return a fd. */
 int
-mkstemp64 (template)
-     char *template;
+mkstemp64 (char *template)
 {
   return __gen_tempname (template, 0, O_LARGEFILE, __GT_FILE);
 }
diff --git a/misc/mkstemps.c b/misc/mkstemps.c
index ca17d1d..5765731 100644
--- a/misc/mkstemps.c
+++ b/misc/mkstemps.c
@@ -28,9 +28,7 @@
    "XXXXXX"; they are replaced with a string that makes the filename
    unique.  Then open the file and return a fd. */
 int
-mkstemps (template, suffixlen)
-     char *template;
-     int suffixlen;
+mkstemps (char *template, int suffixlen)
 {
   if (suffixlen < 0)
     {
diff --git a/misc/mkstemps64.c b/misc/mkstemps64.c
index dd786f1..210f495 100644
--- a/misc/mkstemps64.c
+++ b/misc/mkstemps64.c
@@ -28,9 +28,7 @@
    "XXXXXX"; they are replaced with a string that makes the filename
    unique.  Then open the file and return a fd. */
 int
-mkstemps64 (template, suffixlen)
-     char *template;
-     int suffixlen;
+mkstemps64 (char *template, int suffixlen)
 {
   if (suffixlen < 0)
     {
diff --git a/misc/mktemp.c b/misc/mktemp.c
index 763dee8..940e99c 100644
--- a/misc/mktemp.c
+++ b/misc/mktemp.c
@@ -22,8 +22,7 @@
    The last six characters of TEMPLATE must be "XXXXXX";
    they are replaced with a string that makes the filename unique.  */
 char *
-__mktemp (template)
-     char *template;
+__mktemp (char *template)
 {
   if (__gen_tempname (template, 0, 0, __GT_NOCREATE) < 0)
     /* We return the null string if we can't find a unique file name.  */
diff --git a/misc/preadv.c b/misc/preadv.c
index 36296e3..ad676c3 100644
--- a/misc/preadv.c
+++ b/misc/preadv.c
@@ -26,11 +26,7 @@
    'pread' (see <unistd.h>) except that data are put in VECTOR instead
    of a contiguous buffer.  */
 ssize_t
-preadv (fd, vector, count, offset)
-     int fd;
-     const struct iovec *vector;
-     int count;
-     off_t offset;
+preadv (int fd, const struct iovec *vector, int count, off_t offset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/preadv64.c b/misc/preadv64.c
index d73ad87..df8df24 100644
--- a/misc/preadv64.c
+++ b/misc/preadv64.c
@@ -26,11 +26,7 @@
    'pread' (see <unistd.h>) except that data are put in VECTOR instead
    of a contiguous buffer.  */
 ssize_t
-preadv64 (fd, vector, count, offset)
-     int fd;
-     const struct iovec *vector;
-     int count;
-     off64_t offset;
+preadv64 (int fd, const struct iovec *vector, int count, off64_t offset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/pwritev.c b/misc/pwritev.c
index 0b09809..980fed4 100644
--- a/misc/pwritev.c
+++ b/misc/pwritev.c
@@ -26,11 +26,7 @@
    <unistd.h>) except that the data are taken from VECTOR instead of a
    contiguous buffer.  */
 ssize_t
-pwritev (fd, vector, count, offset)
-     int fd;
-     const struct iovec *vector;
-     int count;
-     off_t offset;
+pwritev (int fd, const struct iovec *vector, int count, off_t offset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/pwritev64.c b/misc/pwritev64.c
index 8201b2c..c89bbd8 100644
--- a/misc/pwritev64.c
+++ b/misc/pwritev64.c
@@ -26,11 +26,7 @@
    <unistd.h>) except that the data are taken from VECTOR instead of a
    contiguous buffer.  */
 ssize_t
-pwritev64 (fd, vector, count, offset)
-     int fd;
-     const struct iovec *vector;
-     int count;
-     off64_t offset;
+pwritev64 (int fd, const struct iovec *vector, int count, off64_t offset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/readv.c b/misc/readv.c
index de78708..dc4d34a 100644
--- a/misc/readv.c
+++ b/misc/readv.c
@@ -25,10 +25,7 @@
    Operates just like `read' (see <unistd.h>) except that data are
    put in VECTOR instead of a contiguous buffer.  */
 ssize_t
-__readv (fd, vector, count)
-     int fd;
-     const struct iovec *vector;
-     int count;
+__readv (int fd, const struct iovec *vector, int count)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/revoke.c b/misc/revoke.c
index 2baf5d6..1d00037 100644
--- a/misc/revoke.c
+++ b/misc/revoke.c
@@ -20,8 +20,7 @@
 #include <errno.h>
 
 int
-revoke (file)
-     const char *file;
+revoke (const char *file)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/setdomain.c b/misc/setdomain.c
index 3cc03b1..b25b39c 100644
--- a/misc/setdomain.c
+++ b/misc/setdomain.c
@@ -21,9 +21,7 @@
 /* Set the name of the current YP domain to NAME, which is LEN bytes long.
    This call is restricted to the super-user.  */
 int
-setdomainname (name, len)
-     const char *name;
-     size_t len;
+setdomainname (const char *name, size_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/setegid.c b/misc/setegid.c
index 37a3b6a..a124c98 100644
--- a/misc/setegid.c
+++ b/misc/setegid.c
@@ -20,8 +20,7 @@
 
 /* Set the effective group ID of the calling process to GID.  */
 int
-setegid (gid)
-     __gid_t gid;
+setegid (__gid_t gid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/seteuid.c b/misc/seteuid.c
index af92bcd..ccd934c 100644
--- a/misc/seteuid.c
+++ b/misc/seteuid.c
@@ -20,8 +20,7 @@
 
 /* Set the effective user ID of the calling process to UID.  */
 int
-seteuid (uid)
-     __uid_t uid;
+seteuid (__uid_t uid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/sethostid.c b/misc/sethostid.c
index 96c750e..bacf172 100644
--- a/misc/sethostid.c
+++ b/misc/sethostid.c
@@ -21,8 +21,7 @@
 /* Set the current machine's Internet number to ID.
    This call is restricted to the super-user.  */
 int
-sethostid (id)
-     long int id;
+sethostid (long int id)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/sethostname.c b/misc/sethostname.c
index c6c1440..95270e9 100644
--- a/misc/sethostname.c
+++ b/misc/sethostname.c
@@ -21,9 +21,7 @@
 /* Set the name of the current host to NAME, which is LEN bytes long.
    This call is restricted to the super-user.  */
 int
-sethostname (name, len)
-     const char *name;
-     size_t len;
+sethostname (const char *name, size_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/setregid.c b/misc/setregid.c
index 692bff0..b3e1bbf 100644
--- a/misc/setregid.c
+++ b/misc/setregid.c
@@ -22,9 +22,7 @@
 /* Set the real group ID of the calling process to RGID,
    and the effective group ID of the calling process to EGID.  */
 int
-__setregid (effective_gid, real_gid)
-     gid_t effective_gid;
-     gid_t real_gid;
+__setregid (gid_t effective_gid, gid_t real_gid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/setreuid.c b/misc/setreuid.c
index a6290f0..0d8e059 100644
--- a/misc/setreuid.c
+++ b/misc/setreuid.c
@@ -22,9 +22,7 @@
 /* Set the real user ID of the calling process to RUID,
    and the effective user ID of the calling process to EUID.  */
 int
-__setreuid (effective_uid, real_uid)
-     uid_t effective_uid;
-     uid_t real_uid;
+__setreuid (uid_t effective_uid, uid_t real_uid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/sstk.c b/misc/sstk.c
index 437deb1..ba00698 100644
--- a/misc/sstk.c
+++ b/misc/sstk.c
@@ -23,8 +23,7 @@
 void *sstk (int increment) __THROW;
 
 void *
-sstk (increment)
-     int increment;
+sstk (int increment)
 {
   __set_errno (ENOSYS);
   return (void *) -1;
diff --git a/misc/stty.c b/misc/stty.c
index 0ce3e60..79e4f8d 100644
--- a/misc/stty.c
+++ b/misc/stty.c
@@ -21,9 +21,7 @@
 
 /* Set the terminal parameters associated with FD to *PARAMS.  */
 int
-stty (fd, params)
-     int fd;
-     const struct sgttyb *params;
+stty (int fd, const struct sgttyb *params)
 {
   if (params == NULL)
     {
diff --git a/misc/syscall.c b/misc/syscall.c
index 7590ad3..f823736 100644
--- a/misc/syscall.c
+++ b/misc/syscall.c
@@ -23,8 +23,7 @@
    This only makes sense in certain operating systems.  */
 
 long int
-syscall (callno)
-     long int callno;
+syscall (long int callno)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/syslog.c b/misc/syslog.c
index 034e2c8..e387bf8 100644
--- a/misc/syslog.c
+++ b/misc/syslog.c
@@ -452,8 +452,7 @@ closelog (void)
 
 /* setlogmask -- set the log mask level */
 int
-setlogmask(pmask)
-	int pmask;
+setlogmask (int pmask)
 {
 	int omask;
 
diff --git a/misc/truncate.c b/misc/truncate.c
index 750f955..45240e9 100644
--- a/misc/truncate.c
+++ b/misc/truncate.c
@@ -20,9 +20,7 @@
 
 /* Truncate PATH to LENGTH bytes.  */
 int
-__truncate (path, length)
-     const char *path;
-     off_t length;
+__truncate (const char *path, off_t length)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/truncate64.c b/misc/truncate64.c
index d1bb4ad..e8408d5 100644
--- a/misc/truncate64.c
+++ b/misc/truncate64.c
@@ -21,9 +21,7 @@
 
 /* Truncate PATH to LENGTH bytes.  */
 int
-truncate64 (path, length)
-     const char *path;
-     off64_t length;
+truncate64 (const char *path, off64_t length)
 {
   if ((off_t) length != length)
     {
diff --git a/misc/ualarm.c b/misc/ualarm.c
index c6b0972..43f0ca1 100644
--- a/misc/ualarm.c
+++ b/misc/ualarm.c
@@ -24,9 +24,7 @@
 
    Returns the number of microseconds remaining before the alarm.  */
 useconds_t
-ualarm (value, interval)
-     useconds_t value;
-     useconds_t interval;
+ualarm (useconds_t value, useconds_t interval)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/usleep.c b/misc/usleep.c
index a28b77c..494a8f7 100644
--- a/misc/usleep.c
+++ b/misc/usleep.c
@@ -20,8 +20,7 @@
 
 /* Sleep USECONDS microseconds, or until a previously set timer goes off.  */
 int
-usleep (useconds)
-     useconds_t useconds;
+usleep (useconds_t useconds)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/ustat.c b/misc/ustat.c
index 1e84062..87d5a30 100644
--- a/misc/ustat.c
+++ b/misc/ustat.c
@@ -21,9 +21,7 @@
 #include <sys/ustat.h>
 
 int
-ustat (dev, ust)
-     dev_t dev;
-     struct ustat * ust;
+ustat (dev_t dev, struct ustat *ust)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/misc/writev.c b/misc/writev.c
index 34e7841..0571522 100644
--- a/misc/writev.c
+++ b/misc/writev.c
@@ -25,10 +25,7 @@
    Operates just like `write' (see <unistd.h>) except that the data
    are taken from VECTOR instead of a contiguous buffer.  */
 ssize_t
-__writev (fd, vector, count)
-     int fd;
-     const struct iovec *vector;
-     int count;
+__writev (int fd, const struct iovec *vector, int count)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/nptl/cleanup_compat.c b/nptl/cleanup_compat.c
index d4e96ae..51de3e2 100644
--- a/nptl/cleanup_compat.c
+++ b/nptl/cleanup_compat.c
@@ -38,9 +38,7 @@ strong_alias (_pthread_cleanup_push, __pthread_cleanup_push)
 
 
 void
-_pthread_cleanup_pop (buffer, execute)
-     struct _pthread_cleanup_buffer *buffer;
-     int execute;
+_pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer, int execute)
 {
   struct pthread *self __attribute ((unused)) = THREAD_SELF;
 
diff --git a/nptl/old_pthread_cond_broadcast.c b/nptl/old_pthread_cond_broadcast.c
index 77d49e1..da3d112 100644
--- a/nptl/old_pthread_cond_broadcast.c
+++ b/nptl/old_pthread_cond_broadcast.c
@@ -25,8 +25,7 @@
 
 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
 int
-__pthread_cond_broadcast_2_0 (cond)
-     pthread_cond_2_0_t *cond;
+__pthread_cond_broadcast_2_0 (pthread_cond_2_0_t *cond)
 {
   if (cond->cond == NULL)
     {
diff --git a/nptl/old_pthread_cond_destroy.c b/nptl/old_pthread_cond_destroy.c
index 90b140e..49fb052 100644
--- a/nptl/old_pthread_cond_destroy.c
+++ b/nptl/old_pthread_cond_destroy.c
@@ -23,8 +23,7 @@
 
 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
 int
-__pthread_cond_destroy_2_0 (cond)
-     pthread_cond_2_0_t *cond;
+__pthread_cond_destroy_2_0 (pthread_cond_2_0_t *cond)
 {
   /* Free the memory which was eventually allocated.  */
   free (cond->cond);
diff --git a/nptl/old_pthread_cond_signal.c b/nptl/old_pthread_cond_signal.c
index 062fa71..87aa8d7 100644
--- a/nptl/old_pthread_cond_signal.c
+++ b/nptl/old_pthread_cond_signal.c
@@ -25,8 +25,7 @@
 
 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
 int
-__pthread_cond_signal_2_0 (cond)
-     pthread_cond_2_0_t *cond;
+__pthread_cond_signal_2_0 (pthread_cond_2_0_t *cond)
 {
   if (cond->cond == NULL)
     {
diff --git a/nptl/old_pthread_cond_wait.c b/nptl/old_pthread_cond_wait.c
index 418a865..9884756 100644
--- a/nptl/old_pthread_cond_wait.c
+++ b/nptl/old_pthread_cond_wait.c
@@ -25,9 +25,7 @@
 
 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_3_2)
 int
-__pthread_cond_wait_2_0 (cond, mutex)
-     pthread_cond_2_0_t *cond;
-     pthread_mutex_t *mutex;
+__pthread_cond_wait_2_0 (pthread_cond_2_0_t *cond, pthread_mutex_t *mutex)
 {
   if (cond->cond == NULL)
     {
diff --git a/nptl/pt-raise.c b/nptl/pt-raise.c
index c0f16e9..41f32c7 100644
--- a/nptl/pt-raise.c
+++ b/nptl/pt-raise.c
@@ -22,8 +22,7 @@
 
 
 int
-raise (sig)
-     int sig;
+raise (int sig)
 {
   /* This is what POSIX says must happen.  */
   return pthread_kill (pthread_self (), sig);
diff --git a/nptl/pthread_barrier_destroy.c b/nptl/pthread_barrier_destroy.c
index 985d718..3193c2e 100644
--- a/nptl/pthread_barrier_destroy.c
+++ b/nptl/pthread_barrier_destroy.c
@@ -22,8 +22,7 @@
 
 
 int
-pthread_barrier_destroy (barrier)
-     pthread_barrier_t *barrier;
+pthread_barrier_destroy (pthread_barrier_t *barrier)
 {
   struct pthread_barrier *ibarrier;
   int result = EBUSY;
diff --git a/nptl/pthread_barrier_wait.c b/nptl/pthread_barrier_wait.c
index 2b34e30..44b44a0 100644
--- a/nptl/pthread_barrier_wait.c
+++ b/nptl/pthread_barrier_wait.c
@@ -25,8 +25,7 @@
 
 /* Wait on barrier.  */
 int
-__pthread_barrier_wait (barrier)
-     pthread_barrier_t *barrier;
+__pthread_barrier_wait (pthread_barrier_t *barrier)
 {
   struct pthread_barrier *ibarrier = (struct pthread_barrier *) barrier;
   int result = 0;
diff --git a/nptl/pthread_barrierattr_destroy.c b/nptl/pthread_barrierattr_destroy.c
index e953fab..5c2f257 100644
--- a/nptl/pthread_barrierattr_destroy.c
+++ b/nptl/pthread_barrierattr_destroy.c
@@ -20,8 +20,7 @@
 
 
 int
-pthread_barrierattr_destroy (attr)
-     pthread_barrierattr_t *attr;
+pthread_barrierattr_destroy (pthread_barrierattr_t *attr)
 {
   /* Nothing to do.  */
 
diff --git a/nptl/pthread_barrierattr_init.c b/nptl/pthread_barrierattr_init.c
index 70a00b0..3ef164c 100644
--- a/nptl/pthread_barrierattr_init.c
+++ b/nptl/pthread_barrierattr_init.c
@@ -20,8 +20,7 @@
 
 
 int
-pthread_barrierattr_init (attr)
-     pthread_barrierattr_t *attr;
+pthread_barrierattr_init (pthread_barrierattr_t *attr)
 {
   ((struct pthread_barrierattr *) attr)->pshared = PTHREAD_PROCESS_PRIVATE;
 
diff --git a/nptl/pthread_barrierattr_setpshared.c b/nptl/pthread_barrierattr_setpshared.c
index eeaee5d..8a57baa 100644
--- a/nptl/pthread_barrierattr_setpshared.c
+++ b/nptl/pthread_barrierattr_setpshared.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_barrierattr_setpshared (attr, pshared)
-     pthread_barrierattr_t *attr;
-     int pshared;
+pthread_barrierattr_setpshared (pthread_barrierattr_t *attr, int pshared)
 {
   struct pthread_barrierattr *iattr;
 
diff --git a/nptl/pthread_cond_broadcast.c b/nptl/pthread_cond_broadcast.c
index 881d098..7f8c2dd 100644
--- a/nptl/pthread_cond_broadcast.c
+++ b/nptl/pthread_cond_broadcast.c
@@ -29,8 +29,7 @@
 
 
 int
-__pthread_cond_broadcast (cond)
-     pthread_cond_t *cond;
+__pthread_cond_broadcast (pthread_cond_t *cond)
 {
   LIBC_PROBE (cond_broadcast, 1, cond);
 
diff --git a/nptl/pthread_cond_destroy.c b/nptl/pthread_cond_destroy.c
index 410e52d..bf4cfce 100644
--- a/nptl/pthread_cond_destroy.c
+++ b/nptl/pthread_cond_destroy.c
@@ -23,8 +23,7 @@
 
 
 int
-__pthread_cond_destroy (cond)
-     pthread_cond_t *cond;
+__pthread_cond_destroy (pthread_cond_t *cond)
 {
   int pshared = (cond->__data.__mutex == (void *) ~0l)
 		? LLL_SHARED : LLL_PRIVATE;
diff --git a/nptl/pthread_cond_init.c b/nptl/pthread_cond_init.c
index ce954c7..fa62b66 100644
--- a/nptl/pthread_cond_init.c
+++ b/nptl/pthread_cond_init.c
@@ -22,9 +22,7 @@
 
 
 int
-__pthread_cond_init (cond, cond_attr)
-     pthread_cond_t *cond;
-     const pthread_condattr_t *cond_attr;
+__pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
 {
   struct pthread_condattr *icond_attr = (struct pthread_condattr *) cond_attr;
 
diff --git a/nptl/pthread_cond_signal.c b/nptl/pthread_cond_signal.c
index ba32f40..d01784f 100644
--- a/nptl/pthread_cond_signal.c
+++ b/nptl/pthread_cond_signal.c
@@ -29,8 +29,7 @@
 
 
 int
-__pthread_cond_signal (cond)
-     pthread_cond_t *cond;
+__pthread_cond_signal (pthread_cond_t *cond)
 {
   int pshared = (cond->__data.__mutex == (void *) ~0l)
 		? LLL_SHARED : LLL_PRIVATE;
diff --git a/nptl/pthread_condattr_destroy.c b/nptl/pthread_condattr_destroy.c
index 55621c1..d295637 100644
--- a/nptl/pthread_condattr_destroy.c
+++ b/nptl/pthread_condattr_destroy.c
@@ -20,8 +20,7 @@
 
 
 int
-__pthread_condattr_destroy (attr)
-     pthread_condattr_t *attr;
+__pthread_condattr_destroy (pthread_condattr_t *attr)
 {
   /* Nothing to be done.  */
   return 0;
diff --git a/nptl/pthread_condattr_getclock.c b/nptl/pthread_condattr_getclock.c
index 020d21a..dcce72a 100644
--- a/nptl/pthread_condattr_getclock.c
+++ b/nptl/pthread_condattr_getclock.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_condattr_getclock (attr, clock_id)
-     const pthread_condattr_t *attr;
-     clockid_t *clock_id;
+pthread_condattr_getclock (const pthread_condattr_t *attr, clockid_t *clock_id)
 {
   *clock_id = (((((const struct pthread_condattr *) attr)->value) >> 1)
 	       & ((1 << COND_NWAITERS_SHIFT) - 1));
diff --git a/nptl/pthread_condattr_getpshared.c b/nptl/pthread_condattr_getpshared.c
index c4d9917..dd1337b 100644
--- a/nptl/pthread_condattr_getpshared.c
+++ b/nptl/pthread_condattr_getpshared.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_condattr_getpshared (attr, pshared)
-     const pthread_condattr_t *attr;
-     int *pshared;
+pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
 {
   *pshared = ((const struct pthread_condattr *) attr)->value & 1;
 
diff --git a/nptl/pthread_condattr_init.c b/nptl/pthread_condattr_init.c
index 5ecc5f6..d004788 100644
--- a/nptl/pthread_condattr_init.c
+++ b/nptl/pthread_condattr_init.c
@@ -21,8 +21,7 @@
 
 
 int
-__pthread_condattr_init (attr)
-     pthread_condattr_t *attr;
+__pthread_condattr_init (pthread_condattr_t *attr)
 {
   memset (attr, '\0', sizeof (*attr));
 
diff --git a/nptl/pthread_condattr_setpshared.c b/nptl/pthread_condattr_setpshared.c
index a015403..bb92df9 100644
--- a/nptl/pthread_condattr_setpshared.c
+++ b/nptl/pthread_condattr_setpshared.c
@@ -21,9 +21,7 @@
 #include <futex-internal.h>
 
 int
-pthread_condattr_setpshared (attr, pshared)
-     pthread_condattr_t *attr;
-     int pshared;
+pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
 {
   int err = futex_supports_pshared (pshared);
   if (err != 0)
diff --git a/nptl/pthread_detach.c b/nptl/pthread_detach.c
index aa735f6..ef58126 100644
--- a/nptl/pthread_detach.c
+++ b/nptl/pthread_detach.c
@@ -22,8 +22,7 @@
 
 
 int
-pthread_detach (th)
-     pthread_t th;
+pthread_detach (pthread_t th)
 {
   struct pthread *pd = (struct pthread *) th;
 
diff --git a/nptl/pthread_equal.c b/nptl/pthread_equal.c
index 69f4c1b..5c174e2 100644
--- a/nptl/pthread_equal.c
+++ b/nptl/pthread_equal.c
@@ -20,9 +20,7 @@
 
 
 int
-__pthread_equal (thread1, thread2)
-     pthread_t thread1;
-     pthread_t thread2;
+__pthread_equal (pthread_t thread1, pthread_t thread2)
 {
   return thread1 == thread2;
 }
diff --git a/nptl/pthread_getcpuclockid.c b/nptl/pthread_getcpuclockid.c
index 33f9f7f..7308296 100644
--- a/nptl/pthread_getcpuclockid.c
+++ b/nptl/pthread_getcpuclockid.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_getcpuclockid (threadid, clockid)
-     pthread_t threadid;
-     clockid_t *clockid;
+pthread_getcpuclockid (pthread_t threadid, clockid_t *clockid)
 {
   struct pthread *pd = (struct pthread *) threadid;
 
diff --git a/nptl/pthread_getspecific.c b/nptl/pthread_getspecific.c
index 0bee354..537aab7 100644
--- a/nptl/pthread_getspecific.c
+++ b/nptl/pthread_getspecific.c
@@ -21,8 +21,7 @@
 
 
 void *
-__pthread_getspecific (key)
-     pthread_key_t key;
+__pthread_getspecific (pthread_key_t key)
 {
   struct pthread_key_data *data;
 
diff --git a/nptl/pthread_key_delete.c b/nptl/pthread_key_delete.c
index bd9b4a2..6de200c 100644
--- a/nptl/pthread_key_delete.c
+++ b/nptl/pthread_key_delete.c
@@ -22,8 +22,7 @@
 
 
 int
-pthread_key_delete (key)
-     pthread_key_t key;
+pthread_key_delete (pthread_key_t key)
 {
   int result = EINVAL;
 
diff --git a/nptl/pthread_mutex_consistent.c b/nptl/pthread_mutex_consistent.c
index b8dbe03..a67cca3 100644
--- a/nptl/pthread_mutex_consistent.c
+++ b/nptl/pthread_mutex_consistent.c
@@ -21,8 +21,7 @@
 
 
 int
-pthread_mutex_consistent (mutex)
-     pthread_mutex_t *mutex;
+pthread_mutex_consistent (pthread_mutex_t *mutex)
 {
   /* Test whether this is a robust mutex with a dead owner.  */
   if ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) == 0
diff --git a/nptl/pthread_mutex_destroy.c b/nptl/pthread_mutex_destroy.c
index f6089df..d2c1bb8 100644
--- a/nptl/pthread_mutex_destroy.c
+++ b/nptl/pthread_mutex_destroy.c
@@ -23,8 +23,7 @@
 
 
 int
-__pthread_mutex_destroy (mutex)
-     pthread_mutex_t *mutex;
+__pthread_mutex_destroy (pthread_mutex_t *mutex)
 {
   LIBC_PROBE (mutex_destroy, 1, mutex);
 
diff --git a/nptl/pthread_mutex_getprioceiling.c b/nptl/pthread_mutex_getprioceiling.c
index 43c35fb..7d6c5a1 100644
--- a/nptl/pthread_mutex_getprioceiling.c
+++ b/nptl/pthread_mutex_getprioceiling.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_mutex_getprioceiling (mutex, prioceiling)
-     const pthread_mutex_t *mutex;
-     int *prioceiling;
+pthread_mutex_getprioceiling (const pthread_mutex_t *mutex, int *prioceiling)
 {
   if (__builtin_expect ((mutex->__data.__kind
 			 & PTHREAD_MUTEX_PRIO_PROTECT_NP) == 0, 0))
diff --git a/nptl/pthread_mutexattr_destroy.c b/nptl/pthread_mutexattr_destroy.c
index 28ca5fb..f5fa6db 100644
--- a/nptl/pthread_mutexattr_destroy.c
+++ b/nptl/pthread_mutexattr_destroy.c
@@ -20,8 +20,7 @@
 
 
 int
-__pthread_mutexattr_destroy (attr)
-     pthread_mutexattr_t *attr;
+__pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
 {
   return 0;
 }
diff --git a/nptl/pthread_mutexattr_getprotocol.c b/nptl/pthread_mutexattr_getprotocol.c
index 9914829..0b38b80 100644
--- a/nptl/pthread_mutexattr_getprotocol.c
+++ b/nptl/pthread_mutexattr_getprotocol.c
@@ -21,9 +21,7 @@
 
 
 int
-pthread_mutexattr_getprotocol (attr, protocol)
-     const pthread_mutexattr_t *attr;
-     int *protocol;
+pthread_mutexattr_getprotocol (const pthread_mutexattr_t *attr, int *protocol)
 {
   const struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_mutexattr_getpshared.c b/nptl/pthread_mutexattr_getpshared.c
index 92840ef..0c1b4f1 100644
--- a/nptl/pthread_mutexattr_getpshared.c
+++ b/nptl/pthread_mutexattr_getpshared.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_mutexattr_getpshared (attr, pshared)
-     const pthread_mutexattr_t *attr;
-     int *pshared;
+pthread_mutexattr_getpshared (const pthread_mutexattr_t *attr, int *pshared)
 {
   const struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_mutexattr_getrobust.c b/nptl/pthread_mutexattr_getrobust.c
index 5115e1e..85713e4 100644
--- a/nptl/pthread_mutexattr_getrobust.c
+++ b/nptl/pthread_mutexattr_getrobust.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_mutexattr_getrobust (attr, robustness)
-     const pthread_mutexattr_t *attr;
-     int *robustness;
+pthread_mutexattr_getrobust (const pthread_mutexattr_t *attr, int *robustness)
 {
   const struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_mutexattr_gettype.c b/nptl/pthread_mutexattr_gettype.c
index 0bf2c82..7b910f5 100644
--- a/nptl/pthread_mutexattr_gettype.c
+++ b/nptl/pthread_mutexattr_gettype.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_mutexattr_gettype (attr, kind)
-     const pthread_mutexattr_t *attr;
-     int *kind;
+pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *kind)
 {
   const struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_mutexattr_init.c b/nptl/pthread_mutexattr_init.c
index 92206b0..28bbb34 100644
--- a/nptl/pthread_mutexattr_init.c
+++ b/nptl/pthread_mutexattr_init.c
@@ -21,8 +21,7 @@
 
 
 int
-__pthread_mutexattr_init (attr)
-     pthread_mutexattr_t *attr;
+__pthread_mutexattr_init (pthread_mutexattr_t *attr)
 {
   if (sizeof (struct pthread_mutexattr) != sizeof (pthread_mutexattr_t))
     memset (attr, '\0', sizeof (*attr));
diff --git a/nptl/pthread_mutexattr_setprioceiling.c b/nptl/pthread_mutexattr_setprioceiling.c
index fcd4190..6928e50 100644
--- a/nptl/pthread_mutexattr_setprioceiling.c
+++ b/nptl/pthread_mutexattr_setprioceiling.c
@@ -23,9 +23,7 @@
 
 
 int
-pthread_mutexattr_setprioceiling (attr, prioceiling)
-     pthread_mutexattr_t *attr;
-     int prioceiling;
+pthread_mutexattr_setprioceiling (pthread_mutexattr_t *attr, int prioceiling)
 {
   /* See __init_sched_fifo_prio.  */
   if (atomic_load_relaxed (&__sched_fifo_min_prio) == -1
diff --git a/nptl/pthread_mutexattr_setprotocol.c b/nptl/pthread_mutexattr_setprotocol.c
index b6bb92b..42542cc 100644
--- a/nptl/pthread_mutexattr_setprotocol.c
+++ b/nptl/pthread_mutexattr_setprotocol.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_mutexattr_setprotocol (attr, protocol)
-     pthread_mutexattr_t *attr;
-     int protocol;
+pthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int protocol)
 {
   if (protocol != PTHREAD_PRIO_NONE
       && protocol != PTHREAD_PRIO_INHERIT
diff --git a/nptl/pthread_mutexattr_setpshared.c b/nptl/pthread_mutexattr_setpshared.c
index 62fd168..ce9233f 100644
--- a/nptl/pthread_mutexattr_setpshared.c
+++ b/nptl/pthread_mutexattr_setpshared.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_mutexattr_setpshared (attr, pshared)
-     pthread_mutexattr_t *attr;
-     int pshared;
+pthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int pshared)
 {
   struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_mutexattr_setrobust.c b/nptl/pthread_mutexattr_setrobust.c
index 54d3624..7a89f2f 100644
--- a/nptl/pthread_mutexattr_setrobust.c
+++ b/nptl/pthread_mutexattr_setrobust.c
@@ -21,9 +21,7 @@
 
 
 int
-pthread_mutexattr_setrobust (attr, robustness)
-     pthread_mutexattr_t *attr;
-     int robustness;
+pthread_mutexattr_setrobust (pthread_mutexattr_t *attr, int robustness)
 {
   if (robustness != PTHREAD_MUTEX_STALLED_NP
       && __builtin_expect (robustness != PTHREAD_MUTEX_ROBUST_NP, 0))
diff --git a/nptl/pthread_mutexattr_settype.c b/nptl/pthread_mutexattr_settype.c
index c6bd5a6..993c5f0 100644
--- a/nptl/pthread_mutexattr_settype.c
+++ b/nptl/pthread_mutexattr_settype.c
@@ -21,9 +21,7 @@
 
 
 int
-__pthread_mutexattr_settype (attr, kind)
-     pthread_mutexattr_t *attr;
-     int kind;
+__pthread_mutexattr_settype (pthread_mutexattr_t *attr, int kind)
 {
   struct pthread_mutexattr *iattr;
 
diff --git a/nptl/pthread_rwlock_destroy.c b/nptl/pthread_rwlock_destroy.c
index 7faf0c3..ac90e71 100644
--- a/nptl/pthread_rwlock_destroy.c
+++ b/nptl/pthread_rwlock_destroy.c
@@ -21,8 +21,7 @@
 
 
 int
-__pthread_rwlock_destroy (rwlock)
-     pthread_rwlock_t *rwlock;
+__pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
 {
   LIBC_PROBE (rwlock_destroy, 1, rwlock);
 
diff --git a/nptl/pthread_rwlockattr_destroy.c b/nptl/pthread_rwlockattr_destroy.c
index 3e2e26d..67eaf5f 100644
--- a/nptl/pthread_rwlockattr_destroy.c
+++ b/nptl/pthread_rwlockattr_destroy.c
@@ -20,8 +20,7 @@
 
 
 int
-pthread_rwlockattr_destroy (attr)
-     pthread_rwlockattr_t *attr;
+pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
 {
   /* Nothing to do.  For now.  */
 
diff --git a/nptl/pthread_rwlockattr_getkind_np.c b/nptl/pthread_rwlockattr_getkind_np.c
index 972bd56..c87ee47 100644
--- a/nptl/pthread_rwlockattr_getkind_np.c
+++ b/nptl/pthread_rwlockattr_getkind_np.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_rwlockattr_getkind_np (attr, pref)
-     const pthread_rwlockattr_t *attr;
-     int *pref;
+pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
 {
   *pref = ((const struct pthread_rwlockattr *) attr)->lockkind;
 
diff --git a/nptl/pthread_rwlockattr_getpshared.c b/nptl/pthread_rwlockattr_getpshared.c
index 528dc84..6708f22 100644
--- a/nptl/pthread_rwlockattr_getpshared.c
+++ b/nptl/pthread_rwlockattr_getpshared.c
@@ -20,9 +20,7 @@
 
 
 int
-pthread_rwlockattr_getpshared (attr, pshared)
-     const pthread_rwlockattr_t *attr;
-     int *pshared;
+pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
 {
   *pshared = ((const struct pthread_rwlockattr *) attr)->pshared;
 
diff --git a/nptl/pthread_rwlockattr_init.c b/nptl/pthread_rwlockattr_init.c
index 33b060a..f5bf865 100644
--- a/nptl/pthread_rwlockattr_init.c
+++ b/nptl/pthread_rwlockattr_init.c
@@ -20,8 +20,7 @@
 
 
 int
-pthread_rwlockattr_init (attr)
-     pthread_rwlockattr_t *attr;
+pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
 {
   struct pthread_rwlockattr *iattr;
 
diff --git a/nptl/pthread_rwlockattr_setkind_np.c b/nptl/pthread_rwlockattr_setkind_np.c
index 4293c12..6ef8266 100644
--- a/nptl/pthread_rwlockattr_setkind_np.c
+++ b/nptl/pthread_rwlockattr_setkind_np.c
@@ -21,9 +21,7 @@
 
 
 int
-pthread_rwlockattr_setkind_np (attr, pref)
-     pthread_rwlockattr_t *attr;
-     int pref;
+pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
 {
   struct pthread_rwlockattr *iattr;
 
diff --git a/nptl/pthread_rwlockattr_setpshared.c b/nptl/pthread_rwlockattr_setpshared.c
index 0369209..a368b99 100644
--- a/nptl/pthread_rwlockattr_setpshared.c
+++ b/nptl/pthread_rwlockattr_setpshared.c
@@ -22,9 +22,7 @@
 
 
 int
-pthread_rwlockattr_setpshared (attr, pshared)
-     pthread_rwlockattr_t *attr;
-     int pshared;
+pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
 {
   struct pthread_rwlockattr *iattr;
 
diff --git a/nptl/pthread_setcancelstate.c b/nptl/pthread_setcancelstate.c
index c8bc8b8..b21c7d2 100644
--- a/nptl/pthread_setcancelstate.c
+++ b/nptl/pthread_setcancelstate.c
@@ -22,9 +22,7 @@
 
 
 int
-__pthread_setcancelstate (state, oldstate)
-     int state;
-     int *oldstate;
+__pthread_setcancelstate (int state, int *oldstate)
 {
   volatile struct pthread *self;
 
diff --git a/nptl/pthread_setcanceltype.c b/nptl/pthread_setcanceltype.c
index 11eff86..79c11d7 100644
--- a/nptl/pthread_setcanceltype.c
+++ b/nptl/pthread_setcanceltype.c
@@ -22,9 +22,7 @@
 
 
 int
-__pthread_setcanceltype (type, oldtype)
-     int type;
-     int *oldtype;
+__pthread_setcanceltype (int type, int *oldtype)
 {
   if (type < PTHREAD_CANCEL_DEFERRED || type > PTHREAD_CANCEL_ASYNCHRONOUS)
     return EINVAL;
diff --git a/nptl/pthread_setconcurrency.c b/nptl/pthread_setconcurrency.c
index 5b03af6..149c934 100644
--- a/nptl/pthread_setconcurrency.c
+++ b/nptl/pthread_setconcurrency.c
@@ -25,8 +25,7 @@ int __concurrency_level;
 
 
 int
-pthread_setconcurrency (level)
-     int level;
+pthread_setconcurrency (int level)
 {
   if (level < 0)
     return EINVAL;
diff --git a/nptl/pthread_setschedprio.c b/nptl/pthread_setschedprio.c
index b628822..e513b8f 100644
--- a/nptl/pthread_setschedprio.c
+++ b/nptl/pthread_setschedprio.c
@@ -25,9 +25,7 @@
 
 
 int
-pthread_setschedprio (threadid, prio)
-     pthread_t threadid;
-     int prio;
+pthread_setschedprio (pthread_t threadid, int prio)
 {
   struct pthread *pd = (struct pthread *) threadid;
 
diff --git a/nptl/pthread_setspecific.c b/nptl/pthread_setspecific.c
index a9cf26c..89dba71 100644
--- a/nptl/pthread_setspecific.c
+++ b/nptl/pthread_setspecific.c
@@ -22,9 +22,7 @@
 
 
 int
-__pthread_setspecific (key, value)
-     pthread_key_t key;
-     const void *value;
+__pthread_setspecific (pthread_key_t key, const void *value)
 {
   struct pthread *self;
   unsigned int idx1st;
diff --git a/nptl/pthread_spin_destroy.c b/nptl/pthread_spin_destroy.c
index 0d41f44..e777a8e 100644
--- a/nptl/pthread_spin_destroy.c
+++ b/nptl/pthread_spin_destroy.c
@@ -20,8 +20,7 @@
 
 
 int
-pthread_spin_destroy (lock)
-     pthread_spinlock_t *lock;
+pthread_spin_destroy (pthread_spinlock_t *lock)
 {
   /* Nothing to do.  */
   return 0;
diff --git a/nptl/pthread_tryjoin.c b/nptl/pthread_tryjoin.c
index 3305844..337654d 100644
--- a/nptl/pthread_tryjoin.c
+++ b/nptl/pthread_tryjoin.c
@@ -24,9 +24,7 @@
 
 
 int
-pthread_tryjoin_np (threadid, thread_return)
-     pthread_t threadid;
-     void **thread_return;
+pthread_tryjoin_np (pthread_t threadid, void **thread_return)
 {
   struct pthread *self;
   struct pthread *pd = (struct pthread *) threadid;
diff --git a/nptl/sem_close.c b/nptl/sem_close.c
index 7f1df14..c29efb8 100644
--- a/nptl/sem_close.c
+++ b/nptl/sem_close.c
@@ -40,8 +40,7 @@ walker (const void *inodep, const VISIT which, const int depth)
 
 
 int
-sem_close (sem)
-     sem_t *sem;
+sem_close (sem_t *sem)
 {
   int result = 0;
 
diff --git a/nptl/sem_destroy.c b/nptl/sem_destroy.c
index c74bbd0..08840fe 100644
--- a/nptl/sem_destroy.c
+++ b/nptl/sem_destroy.c
@@ -22,8 +22,7 @@
 
 
 int
-__new_sem_destroy (sem)
-     sem_t *sem;
+__new_sem_destroy (sem_t *sem)
 {
   /* XXX Check for valid parameter.  */
 
diff --git a/nptl/sem_init.c b/nptl/sem_init.c
index bd1b592..22cd61e 100644
--- a/nptl/sem_init.c
+++ b/nptl/sem_init.c
@@ -64,10 +64,7 @@ versioned_symbol (libpthread, __new_sem_init, sem_init, GLIBC_2_1);
 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
 int
 attribute_compat_text_section
-__old_sem_init (sem, pshared, value)
-     sem_t *sem;
-     int pshared;
-     unsigned int value;
+__old_sem_init (sem_t *sem, int pshared, unsigned int value)
 {
   /* Parameter sanity check.  */
   if (__glibc_unlikely (value > SEM_VALUE_MAX))
diff --git a/nptl/sigaction.c b/nptl/sigaction.c
index 2858da5..ca3a4e7 100644
--- a/nptl/sigaction.c
+++ b/nptl/sigaction.c
@@ -29,10 +29,7 @@
 
 
 int
-__sigaction (sig, act, oact)
-     int sig;
-     const struct sigaction *act;
-     struct sigaction *oact;
+__sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
 {
   if (__glibc_unlikely (sig == SIGCANCEL || sig == SIGSETXID))
     {
diff --git a/nptl/unregister-atfork.c b/nptl/unregister-atfork.c
index 6d08ed7..43c5457 100644
--- a/nptl/unregister-atfork.c
+++ b/nptl/unregister-atfork.c
@@ -24,8 +24,7 @@
 
 
 void
-__unregister_atfork (dso_handle)
-     void *dso_handle;
+__unregister_atfork (void *dso_handle)
 {
   /* Check whether there is any entry in the list which we have to
      remove.  It is likely that this is not the case so don't bother
diff --git a/posix/_exit.c b/posix/_exit.c
index f4d76a1..c8cf1ef 100644
--- a/posix/_exit.c
+++ b/posix/_exit.c
@@ -22,8 +22,7 @@
    terminate program execution, using the low-order 8 bits of the
    given integer as status.  */
 void
-_exit (status)
-     int status;
+_exit (int status)
 {
   status &= 0xff;
   abort ();
diff --git a/posix/alarm.c b/posix/alarm.c
index 1ecfc4f..33e5c27 100644
--- a/posix/alarm.c
+++ b/posix/alarm.c
@@ -26,8 +26,7 @@
    to 0 and check its value after calling `alarm', and this might tell you.
    The signal may come late due to processor scheduling.  */
 unsigned int
-alarm (seconds)
-     unsigned int seconds;
+alarm (unsigned int seconds)
 {
   __set_errno (ENOSYS);
   return 0;
diff --git a/posix/confstr.c b/posix/confstr.c
index 7271c5c..56f49b9 100644
--- a/posix/confstr.c
+++ b/posix/confstr.c
@@ -29,10 +29,7 @@
    of BUF with the value corresponding to NAME and zero-terminate BUF.
    Return the number of bytes required to hold NAME's entire value.  */
 size_t
-confstr (name, buf, len)
-     int name;
-     char *buf;
-     size_t len;
+confstr (int name, char *buf, size_t len)
 {
   const char *string = "";
   size_t string_len = 1;
diff --git a/posix/fpathconf.c b/posix/fpathconf.c
index c4f1cfe..cf6e510 100644
--- a/posix/fpathconf.c
+++ b/posix/fpathconf.c
@@ -22,9 +22,7 @@
 
 /* Get file-specific information about descriptor FD.  */
 long int
-__fpathconf (fd, name)
-     int fd;
-     int name;
+__fpathconf (int fd, int name)
 {
   if (fd < 0)
     {
diff --git a/posix/getgroups.c b/posix/getgroups.c
index d828812..49dc5b3 100644
--- a/posix/getgroups.c
+++ b/posix/getgroups.c
@@ -26,9 +26,7 @@
    the calling process is in.  Otherwise, fill in the group IDs
    of its supplementary groups in LIST and return the number written.  */
 int
-__getgroups (size, list)
-     int size;
-     gid_t *list;
+__getgroups (int size, gid_t *list)
 {
 #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
   /* The system has no supplementary groups.  */
diff --git a/posix/getpgid.c b/posix/getpgid.c
index 05f72c3..8de62cb 100644
--- a/posix/getpgid.c
+++ b/posix/getpgid.c
@@ -20,8 +20,7 @@
 
 /* Get the process group ID of process PID.  */
 pid_t
-__getpgid (pid)
-     pid_t pid;
+__getpgid (pid_t pid)
 {
   return pid;
 }
diff --git a/posix/group_member.c b/posix/group_member.c
index 032b1ce..fce7d441c 100644
--- a/posix/group_member.c
+++ b/posix/group_member.c
@@ -26,8 +26,7 @@
 #endif
 
 int
-__group_member (gid)
-     gid_t gid;
+__group_member (gid_t gid)
 {
   int n, size;
   gid_t *groups;
diff --git a/posix/pathconf.c b/posix/pathconf.c
index 2343d8d..37cc406 100644
--- a/posix/pathconf.c
+++ b/posix/pathconf.c
@@ -22,9 +22,7 @@
 
 /* Get file-specific information about PATH.  */
 long int
-__pathconf (path, name)
-     const char *path;
-     int name;
+__pathconf (const char *path, int name)
 {
   if (path == NULL)
     {
diff --git a/posix/sched_getaffinity.c b/posix/sched_getaffinity.c
index 2d8f838..9e059d4 100644
--- a/posix/sched_getaffinity.c
+++ b/posix/sched_getaffinity.c
@@ -22,10 +22,7 @@
 
 /* Retrieve the CPU affinity mask for a particular process.  */
 int
-sched_getaffinity (pid, cpusetsize, cpuset)
-     pid_t pid;
-     size_t cpusetsize;
-     cpu_set_t *cpuset;
+sched_getaffinity (pid_t pid, size_t cpusetsize, cpu_set_t *cpuset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/posix/sched_setaffinity.c b/posix/sched_setaffinity.c
index 579fc39..c07bbcf 100644
--- a/posix/sched_setaffinity.c
+++ b/posix/sched_setaffinity.c
@@ -22,10 +22,7 @@
 
 /* Retrieve the CPU affinity mask for a particular process.  */
 int
-sched_setaffinity (pid, cpusetsize, cpuset)
-     pid_t pid;
-     size_t cpusetsize;
-     const cpu_set_t *cpuset;
+sched_setaffinity (pid_t pid, size_t cpusetsize, const cpu_set_t *cpuset)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/posix/setgid.c b/posix/setgid.c
index 4a37cc7..42f3ca2 100644
--- a/posix/setgid.c
+++ b/posix/setgid.c
@@ -24,8 +24,7 @@
    and effective group IDs, and the saved set-group-ID to GID;
    if not, the effective group ID is set to GID.  */
 int
-__setgid (gid)
-     gid_t gid;
+__setgid (gid_t gid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/posix/setpgid.c b/posix/setpgid.c
index 7289148..a01af84 100644
--- a/posix/setpgid.c
+++ b/posix/setpgid.c
@@ -22,9 +22,7 @@
    If PID is zero, the current process's process group ID is set.
    If PGID is zero, the process ID of the process is used.  */
 int
-__setpgid (pid, pgid)
-     int pid;
-     int pgid;
+__setpgid (int pid, int pgid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/posix/setuid.c b/posix/setuid.c
index 794eb02..4a53cbd 100644
--- a/posix/setuid.c
+++ b/posix/setuid.c
@@ -24,8 +24,7 @@
    and effective user IDs, and the saved set-user-ID to UID;
    if not, the effective user ID is set to UID.  */
 int
-__setuid (uid)
-     uid_t uid;
+__setuid (uid_t uid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/posix/sleep.c b/posix/sleep.c
index 0ae79c1..b5a7077 100644
--- a/posix/sleep.c
+++ b/posix/sleep.c
@@ -28,8 +28,7 @@
    signal afterwards is undefined.  There is no return value to indicate
    error, but if `sleep' returns SECONDS, it probably didn't work.  */
 unsigned int
-__sleep (seconds)
-     unsigned int seconds;
+__sleep (unsigned int seconds)
 {
   __set_errno (ENOSYS);
   return seconds;
diff --git a/posix/sysconf.c b/posix/sysconf.c
index 0ad15c2..31910e0 100644
--- a/posix/sysconf.c
+++ b/posix/sysconf.c
@@ -28,8 +28,7 @@
 
 /* Get the value of the system variable NAME.  */
 long int
-__sysconf (name)
-     int name;
+__sysconf (int name)
 {
   switch (name)
     {
diff --git a/posix/times.c b/posix/times.c
index 48ee9cd..fb6a28a 100644
--- a/posix/times.c
+++ b/posix/times.c
@@ -24,8 +24,7 @@
    Return the elapsed real time, or (clock_t) -1 for errors.
    All times are in CLK_TCKths of a second.  */
 clock_t
-__times (buffer)
-     struct tms *buffer;
+__times (struct tms *buffer)
 {
   if (buffer == NULL)
     {
diff --git a/posix/uname.c b/posix/uname.c
index 072e868..22591b3 100644
--- a/posix/uname.c
+++ b/posix/uname.c
@@ -26,8 +26,7 @@
 
 /* Put information about the system in NAME.  */
 int
-__uname (name)
-     struct utsname *name;
+__uname (struct utsname *name)
 {
   int save;
 
diff --git a/posix/waitid.c b/posix/waitid.c
index a82462f..f72bca9 100644
--- a/posix/waitid.c
+++ b/posix/waitid.c
@@ -22,11 +22,7 @@
 #include <sys/wait.h>
 
 int
-__waitid (idtype, id, infop, options)
-     idtype_t idtype;
-     id_t id;
-     siginfo_t *infop;
-     int options;
+__waitid (idtype_t idtype, id_t id, siginfo_t *infop, int options)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/pwd/getpw.c b/pwd/getpw.c
index 88fa873..f2dbe28 100644
--- a/pwd/getpw.c
+++ b/pwd/getpw.c
@@ -29,9 +29,7 @@
 int __getpw (__uid_t uid, char *buf);
 
 int
-__getpw (uid, buf)
-     __uid_t uid;
-     char *buf;
+__getpw (__uid_t uid, char *buf)
 {
   size_t buflen;
   char *tmpbuf;
diff --git a/resolv/base64.c b/resolv/base64.c
index 519e5d2..fedc086 100644
--- a/resolv/base64.c
+++ b/resolv/base64.c
@@ -191,10 +191,7 @@ libresolv_hidden_def (b64_ntop)
  */
 
 int
-b64_pton(src, target, targsize)
-	char const *src;
-	u_char *target;
-	size_t targsize;
+b64_pton (char const *src, u_char *target, size_t targsize)
 {
 	int tarindex, state, ch;
 	char *pos;
diff --git a/resolv/gai_sigqueue.c b/resolv/gai_sigqueue.c
index e2c7878..b7edc84 100644
--- a/resolv/gai_sigqueue.c
+++ b/resolv/gai_sigqueue.c
@@ -22,10 +22,7 @@
 #include <gai_misc.h>
 
 int
-__gai_sigqueue (sig, val, caller_pid)
-     int sig;
-     const union sigval val;
-     pid_t caller_pid;
+__gai_sigqueue (int sig, const union sigval val, pid_t caller_pid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/resolv/gethnamaddr.c b/resolv/gethnamaddr.c
index 7fd0e49..3a8e9b1 100644
--- a/resolv/gethnamaddr.c
+++ b/resolv/gethnamaddr.c
@@ -147,9 +147,7 @@ extern int h_errno;
 
 #ifdef DEBUG
 static void
-Dprintf(msg, num)
-	char *msg;
-	int num;
+Dprintf (char *msg, int num)
 {
 	if (_res.options & RES_DEBUG) {
 		int save = errno;
@@ -486,8 +484,7 @@ extern struct hostent *gethostbyname2(const char *name, int af);
 libresolv_hidden_proto (gethostbyname2)
 
 struct hostent *
-gethostbyname(name)
-	const char *name;
+gethostbyname (const char *name)
 {
 	struct hostent *hp;
 
@@ -504,9 +501,7 @@ gethostbyname(name)
 }
 
 struct hostent *
-gethostbyname2(name, af)
-	const char *name;
-	int af;
+gethostbyname2 (const char *name, int af)
 {
 	union
 	{
@@ -637,10 +632,7 @@ gethostbyname2(name, af)
 libresolv_hidden_def (gethostbyname2)
 
 struct hostent *
-gethostbyaddr(addr, len, af)
-	const void *addr;
-	socklen_t len;
-	int af;
+gethostbyaddr (const void *addr, socklen_t len, int af)
 {
 	const u_char *uaddr = (const u_char *)addr;
 	static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
@@ -783,8 +775,7 @@ gethostbyaddr(addr, len, af)
 }
 
 void
-_sethtent(f)
-	int f;
+_sethtent (int f)
 {
 	if (!hostf)
 		hostf = fopen(_PATH_HOSTS, "rce" );
@@ -870,8 +861,7 @@ _gethtent (void)
 libresolv_hidden_def (_gethtent)
 
 struct hostent *
-_gethtbyname(name)
-	const char *name;
+_gethtbyname (const char *name)
 {
 	struct hostent *hp;
 
@@ -884,9 +874,7 @@ _gethtbyname(name)
 }
 
 struct hostent *
-_gethtbyname2(name, af)
-	const char *name;
-	int af;
+_gethtbyname2 (const char *name, int af)
 {
 	struct hostent *p;
 	char **cp;
@@ -908,10 +896,7 @@ _gethtbyname2(name, af)
 libresolv_hidden_def (_gethtbyname2)
 
 struct hostent *
-_gethtbyaddr(addr, len, af)
-	const char *addr;
-	size_t len;
-	int af;
+_gethtbyaddr (const char *addr, size_t len, int af)
 {
 	struct hostent *p;
 
@@ -925,9 +910,7 @@ _gethtbyaddr(addr, len, af)
 libresolv_hidden_def (_gethtbyaddr)
 
 static void
-map_v4v6_address(src, dst)
-	const char *src;
-	char *dst;
+map_v4v6_address (const char *src, char *dst)
 {
 	u_char *p = (u_char *)dst;
 	char tmp[INADDRSZ];
@@ -945,10 +928,7 @@ map_v4v6_address(src, dst)
 }
 
 static void
-map_v4v6_hostent(hp, bpp, lenp)
-	struct hostent *hp;
-	char **bpp;
-	int *lenp;
+map_v4v6_hostent (struct hostent *hp, char **bpp, int *lenp)
 {
 	char **ap;
 
@@ -975,9 +955,7 @@ map_v4v6_hostent(hp, bpp, lenp)
 
 #ifdef RESOLVSORT
 extern void
-addrsort(ap, num)
-	char **ap;
-	int num;
+addrsort (char **ap, int num)
 {
 	int i, j;
 	char **p;
@@ -1021,8 +999,7 @@ addrsort(ap, num)
 #if defined(BSD43_BSD43_NFS) || defined(sun)
 /* some libc's out there are bound internally to these names (UMIPS) */
 void
-ht_sethostent(stayopen)
-	int stayopen;
+ht_sethostent (int stayopen)
 {
 	_sethtent(stayopen);
 }
@@ -1034,17 +1011,13 @@ ht_endhostent (void)
 }
 
 struct hostent *
-ht_gethostbyname(name)
-	char *name;
+ht_gethostbyname (char *name)
 {
 	return (_gethtbyname(name));
 }
 
 struct hostent *
-ht_gethostbyaddr(addr, len, af)
-	const char *addr;
-	size_t len;
-	int af;
+ht_gethostbyaddr (const char *addr, size_t len, int af)
 {
 	return (_gethtbyaddr(addr, len, af));
 }
diff --git a/resolv/inet_net_ntop.c b/resolv/inet_net_ntop.c
index e50c6a0..2d57ae3 100644
--- a/resolv/inet_net_ntop.c
+++ b/resolv/inet_net_ntop.c
@@ -49,12 +49,7 @@ static char *	inet_net_ntop_ipv4 (const u_char *src, int bits,
  *	Paul Vixie (ISC), July 1996
  */
 char *
-inet_net_ntop(af, src, bits, dst, size)
-	int af;
-	const void *src;
-	int bits;
-	char *dst;
-	size_t size;
+inet_net_ntop (int af, const void *src, int bits, char *dst, size_t size)
 {
 	switch (af) {
 	case AF_INET:
@@ -79,11 +74,7 @@ inet_net_ntop(af, src, bits, dst, size)
  *	Paul Vixie (ISC), July 1996
  */
 static char *
-inet_net_ntop_ipv4(src, bits, dst, size)
-	const u_char *src;
-	int bits;
-	char *dst;
-	size_t size;
+inet_net_ntop_ipv4 (const u_char *src, int bits, char *dst, size_t size)
 {
 	char *odst = dst;
 	char *t;
diff --git a/resolv/inet_neta.c b/resolv/inet_neta.c
index 349e6bd..b9f256b 100644
--- a/resolv/inet_neta.c
+++ b/resolv/inet_neta.c
@@ -46,10 +46,7 @@ static const char rcsid[] = "$BINDId: inet_neta.c,v 1.6 1999/01/08 19:23:45 vixi
  *	Paul Vixie (ISC), July 1996
  */
 char *
-inet_neta(src, dst, size)
-	u_int32_t src;
-	char *dst;
-	size_t size;
+inet_neta (u_int32_t src, char *dst, size_t size)
 {
 	char *odst = dst;
 	char *tp;
diff --git a/resolv/inet_ntop.c b/resolv/inet_ntop.c
index 6e89f2d..32338c5 100644
--- a/resolv/inet_ntop.c
+++ b/resolv/inet_ntop.c
@@ -56,11 +56,7 @@ static const char *inet_ntop6 (const u_char *src, char *dst, socklen_t size)
  *	Paul Vixie, 1996.
  */
 const char *
-inet_ntop(af, src, dst, size)
-	int af;
-	const void *src;
-	char *dst;
-	socklen_t size;
+inet_ntop (int af, const void *src, char *dst, socklen_t size)
 {
 	switch (af) {
 	case AF_INET:
@@ -88,10 +84,7 @@ libc_hidden_def (inet_ntop)
  */
 static const char *
 internal_function
-inet_ntop4(src, dst, size)
-	const u_char *src;
-	char *dst;
-	socklen_t size;
+inet_ntop4 (const u_char *src, char *dst, socklen_t size)
 {
 	static const char fmt[] = "%u.%u.%u.%u";
 	char tmp[sizeof "255.255.255.255"];
@@ -111,10 +104,7 @@ inet_ntop4(src, dst, size)
  */
 static const char *
 internal_function
-inet_ntop6(src, dst, size)
-	const u_char *src;
-	char *dst;
-	socklen_t size;
+inet_ntop6 (const u_char *src, char *dst, socklen_t size)
 {
 	/*
 	 * Note that int32_t and int16_t need only be "at least" large enough
diff --git a/resolv/inet_pton.c b/resolv/inet_pton.c
index 3d88195..0d18e9a 100644
--- a/resolv/inet_pton.c
+++ b/resolv/inet_pton.c
@@ -49,10 +49,7 @@ static int inet_pton6 (const char *src, u_char *dst) internal_function;
  *	Paul Vixie, 1996.
  */
 int
-__inet_pton(af, src, dst)
-	int af;
-	const char *src;
-	void *dst;
+__inet_pton (int af, const char *src, void *dst)
 {
 	switch (af) {
 	case AF_INET:
@@ -82,9 +79,7 @@ libc_hidden_weak (inet_pton)
  */
 static int
 internal_function
-inet_pton4(src, dst)
-	const char *src;
-	u_char *dst;
+inet_pton4 (const char *src, u_char *dst)
 {
 	int saw_digit, octets, ch;
 	u_char tmp[NS_INADDRSZ], *tp;
@@ -136,9 +131,7 @@ inet_pton4(src, dst)
  */
 static int
 internal_function
-inet_pton6(src, dst)
-	const char *src;
-	u_char *dst;
+inet_pton6 (const char *src, u_char *dst)
 {
 	static const char xdigits[] = "0123456789abcdef";
 	u_char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
diff --git a/resolv/res_debug.c b/resolv/res_debug.c
index 7843439..6e76ea3 100644
--- a/resolv/res_debug.c
+++ b/resolv/res_debug.c
@@ -790,9 +790,7 @@ latlon2ul (const char **latlonstrptr, int *which)
 /* converts a zone file representation in a string to an RDATA on-the-wire
  * representation. */
 int
-loc_aton(ascii, binary)
-	const char *ascii;
-	u_char *binary;
+loc_aton (const char *ascii, u_char *binary)
 {
 	const char *cp, *maxcp;
 	u_char *bcp;
@@ -901,9 +899,7 @@ loc_aton(ascii, binary)
 
 /* takes an on-the-wire LOC RR and formats it in a human readable format. */
 const char *
-loc_ntoa(binary, ascii)
-	const u_char *binary;
-	char *ascii;
+loc_ntoa (const u_char *binary, char *ascii)
 {
 	static const char error[] = "?";
 	static char tmpbuf[sizeof
diff --git a/resource/getpriority.c b/resource/getpriority.c
index 6df7294..105b77e 100644
--- a/resource/getpriority.c
+++ b/resource/getpriority.c
@@ -23,9 +23,7 @@
    or user (as specified by WHO) is used.  A lower priority number means higher
    priority.  Priorities range from PRIO_MIN to PRIO_MAX.  */
 int
-__getpriority (which, who)
-     enum __priority_which which;
-     id_t who;
+__getpriority (enum __priority_which which, id_t who)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/resource/getrusage.c b/resource/getrusage.c
index ebda1d2..a403402 100644
--- a/resource/getrusage.c
+++ b/resource/getrusage.c
@@ -21,9 +21,7 @@
 /* Return resource usage information on process indicated by WHO
    and put it in *USAGE.  Returns 0 for success, -1 for failure.  */
 int
-__getrusage (who, usage)
-     enum __rusage_who who;
-     struct rusage *usage;
+__getrusage (enum __rusage_who who, struct rusage *usage)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/resource/nice.c b/resource/nice.c
index 208fcc0..7f49037 100644
--- a/resource/nice.c
+++ b/resource/nice.c
@@ -21,8 +21,7 @@
 /* Increment the scheduling priority of the calling process by INCR.
    The superuser may use a negative INCR to decrement the priority.  */
 int
-nice (incr)
-     int incr;
+nice (int incr)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/resource/setpriority.c b/resource/setpriority.c
index 91521bd..e9def1e 100644
--- a/resource/setpriority.c
+++ b/resource/setpriority.c
@@ -21,10 +21,7 @@
 /* Set the priority of all processes specified by WHICH and WHO
    to PRIO.  Returns 0 on success, -1 on errors.  */
 int
-__setpriority (which, who, prio)
-     enum __priority_which which;
-     id_t who;
-     int prio;
+__setpriority (enum __priority_which which, id_t who, int prio)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/resource/setrlimit64.c b/resource/setrlimit64.c
index 217ad22..7c7a126 100644
--- a/resource/setrlimit64.c
+++ b/resource/setrlimit64.c
@@ -23,9 +23,7 @@
    Only the super-user can increase hard limits.
    Return 0 if successful, -1 if not (and sets errno).  */
 int
-setrlimit64 (resource, rlimits)
-     enum __rlimit_resource resource;
-     const struct rlimit64 *rlimits;
+setrlimit64 (enum __rlimit_resource resource, const struct rlimit64 *rlimits)
 {
   struct rlimit rlimits32;
 
diff --git a/resource/vlimit.c b/resource/vlimit.c
index 14cfee0..0ae4220 100644
--- a/resource/vlimit.c
+++ b/resource/vlimit.c
@@ -26,9 +26,7 @@
 /* Set the soft limit for RESOURCE to be VALUE.
    Returns 0 for success, -1 for failure.  */
 int
-vlimit (resource, value)
-     enum __vlimit_resource resource;
-     int value;
+vlimit (enum __vlimit_resource resource, int value)
 {
   if (resource >= LIM_CPU && resource <= LIM_MAXRSS)
     {
diff --git a/resource/vtimes.c b/resource/vtimes.c
index a8816b0..7d2c34b 100644
--- a/resource/vtimes.c
+++ b/resource/vtimes.c
@@ -53,9 +53,7 @@ vtimes_one (struct vtimes *vt, enum __rusage_who who)
    *CURRENT.  If CHILD is not NULL, write statistics for all terminated child
    processes into *CHILD.  Returns 0 for success, -1 for failure.  */
 int
-vtimes (current, child)
-     struct vtimes *current;
-     struct vtimes *child;
+vtimes (struct vtimes *current, struct vtimes *child)
 {
   if (vtimes_one (current, RUSAGE_SELF) < 0
       || vtimes_one (child, RUSAGE_CHILDREN) < 0)
diff --git a/rt/aio_error.c b/rt/aio_error.c
index c546cab..da2caee 100644
--- a/rt/aio_error.c
+++ b/rt/aio_error.c
@@ -30,8 +30,7 @@
 
 
 int
-aio_error (aiocbp)
-     const struct aiocb *aiocbp;
+aio_error (const struct aiocb *aiocbp)
 {
   return aiocbp->__error_code;
 }
diff --git a/rt/aio_return.c b/rt/aio_return.c
index 61fee9f..89b1916 100644
--- a/rt/aio_return.c
+++ b/rt/aio_return.c
@@ -30,8 +30,7 @@
 
 
 ssize_t
-aio_return (aiocbp)
-     struct aiocb *aiocbp;
+aio_return (struct aiocb *aiocbp)
 {
   return aiocbp->__return_value;
 }
diff --git a/rt/aio_sigqueue.c b/rt/aio_sigqueue.c
index 5481be0..3721886 100644
--- a/rt/aio_sigqueue.c
+++ b/rt/aio_sigqueue.c
@@ -22,10 +22,7 @@
 #include <aio_misc.h>
 
 int
-__aio_sigqueue (sig, val, caller_pid)
-     int sig;
-     const union sigval val;
-     pid_t caller_pid;
+__aio_sigqueue (int sig, const union sigval val, pid_t caller_pid)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/kill.c b/signal/kill.c
index 6aa8cc7..976d94c 100644
--- a/signal/kill.c
+++ b/signal/kill.c
@@ -23,9 +23,7 @@
    send SIG to all processes in the current process's process group.
    If PID is < -1, send SIG to all processes in process group - PID.  */
 int
-__kill (pid, sig)
-     int pid;
-     int sig;
+__kill (int pid, int sig)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/killpg.c b/signal/killpg.c
index e4b7cf5..9696e0c 100644
--- a/signal/killpg.c
+++ b/signal/killpg.c
@@ -23,9 +23,7 @@
    If PGRP is zero, send SIG to all processes in
    the current process's process group.  */
 int
-killpg (pgrp, sig)
-     __pid_t pgrp;
-     int sig;
+killpg (__pid_t pgrp, int sig)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/raise.c b/signal/raise.c
index d917af4..1205267 100644
--- a/signal/raise.c
+++ b/signal/raise.c
@@ -20,8 +20,7 @@
 
 /* Raise the signal SIG.  */
 int
-raise (sig)
-     int sig;
+raise (int sig)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigaction.c b/signal/sigaction.c
index f73944e..ba17ba9 100644
--- a/signal/sigaction.c
+++ b/signal/sigaction.c
@@ -22,10 +22,7 @@
 /* If ACT is not NULL, change the action for SIG to *ACT.
    If OACT is not NULL, put the old action for SIG in *OACT.  */
 int
-__sigaction (sig, act, oact)
-     int sig;
-     const struct sigaction *act;
-     struct sigaction *oact;
+__sigaction (int sig, const struct sigaction *act, struct sigaction *oact)
 {
   if (sig <= 0 || sig >= NSIG)
     {
diff --git a/signal/sigaddset.c b/signal/sigaddset.c
index 9f65da2..7af0876 100644
--- a/signal/sigaddset.c
+++ b/signal/sigaddset.c
@@ -19,9 +19,7 @@
 
 /* Add SIGNO to SET.  */
 int
-sigaddset (set, signo)
-     sigset_t *set;
-     int signo;
+sigaddset (sigset_t *set, int signo)
 {
   if (set == NULL || signo <= 0 || signo >= NSIG)
     {
diff --git a/signal/sigaltstack.c b/signal/sigaltstack.c
index aaaf108..6713e6c 100644
--- a/signal/sigaltstack.c
+++ b/signal/sigaltstack.c
@@ -21,9 +21,7 @@
 /* Run signals handlers on the stack specified by SS (if not NULL).
    If OSS is not NULL, it is filled in with the old signal stack status.  */
 int
-sigaltstack (ss, oss)
-     const struct sigaltstack *ss;
-     struct sigaltstack *oss;
+sigaltstack (const struct sigaltstack *ss, struct sigaltstack *oss)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigandset.c b/signal/sigandset.c
index f804ab7..35ebec6 100644
--- a/signal/sigandset.c
+++ b/signal/sigandset.c
@@ -22,10 +22,7 @@
 
 /* Combine sets LEFT and RIGHT by logical AND and place result in DEST.  */
 int
-sigandset (dest, left, right)
-     sigset_t *dest;
-     const sigset_t *left;
-     const sigset_t *right;
+sigandset (sigset_t *dest, const sigset_t *left, const sigset_t *right)
 {
   if (dest == NULL || left == NULL || right == NULL)
     {
diff --git a/signal/sigblock.c b/signal/sigblock.c
index aff495b..10375ea 100644
--- a/signal/sigblock.c
+++ b/signal/sigblock.c
@@ -20,8 +20,7 @@
 
 /* Block signals in MASK, returning the old mask.  */
 int
-__sigblock (mask)
-     int mask;
+__sigblock (int mask)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigdelset.c b/signal/sigdelset.c
index 3546f2f..2130351 100644
--- a/signal/sigdelset.c
+++ b/signal/sigdelset.c
@@ -19,9 +19,7 @@
 
 /* Add SIGNO to SET.  */
 int
-sigdelset (set, signo)
-     sigset_t *set;
-     int signo;
+sigdelset (sigset_t *set, int signo)
 {
   if (set == NULL || signo <= 0 || signo >= NSIG)
     {
diff --git a/signal/sigempty.c b/signal/sigempty.c
index 0e5b423..fb1b5ad 100644
--- a/signal/sigempty.c
+++ b/signal/sigempty.c
@@ -21,8 +21,7 @@
 
 /* Clear all signals from SET.  */
 int
-sigemptyset (set)
-     sigset_t *set;
+sigemptyset (sigset_t *set)
 {
   if (set == NULL)
     {
diff --git a/signal/sigfillset.c b/signal/sigfillset.c
index cf55a11..ec8dec9 100644
--- a/signal/sigfillset.c
+++ b/signal/sigfillset.c
@@ -21,8 +21,7 @@
 
 /* Set all signals in SET.  */
 int
-sigfillset (set)
-     sigset_t *set;
+sigfillset (sigset_t *set)
 {
   if (set == NULL)
     {
diff --git a/signal/sighold.c b/signal/sighold.c
index 3dcf330..4fd796a 100644
--- a/signal/sighold.c
+++ b/signal/sighold.c
@@ -22,8 +22,7 @@
 #include <signal.h>
 
 int
-sighold (sig)
-     int sig;
+sighold (int sig)
 {
   sigset_t set;
 
diff --git a/signal/sigignore.c b/signal/sigignore.c
index 67af463..9727fd1 100644
--- a/signal/sigignore.c
+++ b/signal/sigignore.c
@@ -21,8 +21,7 @@
 
 /* Set the disposition for SIG to SIG_IGN.  */
 int
-sigignore (sig)
-     int sig;
+sigignore (int sig)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigintr.c b/signal/sigintr.c
index 8f274cb..b7122d7 100644
--- a/signal/sigintr.c
+++ b/signal/sigintr.c
@@ -22,9 +22,7 @@
    (causing them to fail with EINTR); if INTERRUPT is zero, make system
    calls be restarted after signal SIG.  */
 int
-siginterrupt (sig, interrupt)
-     int sig;
-     int interrupt;
+siginterrupt (int sig, int interrupt)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigisempty.c b/signal/sigisempty.c
index 3c60d7e..48223f9 100644
--- a/signal/sigisempty.c
+++ b/signal/sigisempty.c
@@ -22,8 +22,7 @@
 
 /* Test whether SET is empty.  */
 int
-sigisemptyset (set)
-     const sigset_t *set;
+sigisemptyset (const sigset_t *set)
 {
   if (set == NULL)
     {
diff --git a/signal/sigismem.c b/signal/sigismem.c
index 7195229..4f45ed0 100644
--- a/signal/sigismem.c
+++ b/signal/sigismem.c
@@ -19,9 +19,7 @@
 
 /* Return 1 if SIGNO is in SET, 0 if not.  */
 int
-sigismember (set, signo)
-     const sigset_t *set;
-     int signo;
+sigismember (const sigset_t *set, int signo)
 {
   if (set == NULL || signo <= 0 || signo >= NSIG)
     {
diff --git a/signal/signal.c b/signal/signal.c
index a249e74..cfc4347 100644
--- a/signal/signal.c
+++ b/signal/signal.c
@@ -22,9 +22,7 @@
 /* Set the handler for the signal SIG to HANDLER,
    returning the old handler, or SIG_ERR on error.  */
 __sighandler_t
-signal (sig, handler)
-     int sig;
-     __sighandler_t handler;
+signal (int sig, __sighandler_t handler)
 {
   __set_errno (ENOSYS);
   return SIG_ERR;
diff --git a/signal/sigorset.c b/signal/sigorset.c
index f49d978..e49ad32 100644
--- a/signal/sigorset.c
+++ b/signal/sigorset.c
@@ -22,10 +22,7 @@
 
 /* Combine sets LEFT and RIGHT by logical OR and place result in DEST.  */
 int
-sigorset (dest, left, right)
-     sigset_t *dest;
-     const sigset_t *left;
-     const sigset_t *right;
+sigorset (sigset_t *dest, const sigset_t *left, const sigset_t *right)
 {
   if (dest == NULL || left == NULL || right == NULL)
     {
diff --git a/signal/sigpause.c b/signal/sigpause.c
index 390329c..64d069d 100644
--- a/signal/sigpause.c
+++ b/signal/sigpause.c
@@ -21,9 +21,7 @@
 #undef sigpause
 
 int
-__sigpause (sig_or_mask, is_sig)
-     int sig_or_mask;
-     int is_sig;
+__sigpause (int sig_or_mask, int is_sig)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigpending.c b/signal/sigpending.c
index 104f6a3..679b028 100644
--- a/signal/sigpending.c
+++ b/signal/sigpending.c
@@ -22,8 +22,7 @@
 
 /* Store in SET all signals that are blocked and pending.  */
 int
-sigpending (set)
-     sigset_t *set;
+sigpending (sigset_t *set)
 {
   if (set == NULL)
     {
diff --git a/signal/sigprocmask.c b/signal/sigprocmask.c
index 33fb241..e3e3c9b 100644
--- a/signal/sigprocmask.c
+++ b/signal/sigprocmask.c
@@ -23,10 +23,7 @@
    according to HOW, which may be SIG_BLOCK, SIG_UNBLOCK or SIG_SETMASK.
    If OSET is not NULL, store the old set of blocked signals in *OSET.  */
 int
-__sigprocmask (how, set, oset)
-     int how;
-     const sigset_t *set;
-     sigset_t *oset;
+__sigprocmask (int how, const sigset_t *set, sigset_t *oset)
 {
   switch (how)
     {
diff --git a/signal/sigrelse.c b/signal/sigrelse.c
index 56c535c..27ad1a9 100644
--- a/signal/sigrelse.c
+++ b/signal/sigrelse.c
@@ -22,8 +22,7 @@
 #include <signal.h>
 
 int
-sigrelse (sig)
-     int sig;
+sigrelse (int sig)
 {
   sigset_t set;
 
diff --git a/signal/sigreturn.c b/signal/sigreturn.c
index 88f223f..f283137 100644
--- a/signal/sigreturn.c
+++ b/signal/sigreturn.c
@@ -19,8 +19,7 @@
 #include <errno.h>
 
 int
-__sigreturn (context)
-     struct sigcontext *context;
+__sigreturn (struct sigcontext *context)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigset.c b/signal/sigset.c
index 37c549e..4f66be4 100644
--- a/signal/sigset.c
+++ b/signal/sigset.c
@@ -21,9 +21,7 @@
 
 /* Set the disposition for SIG.  */
 __sighandler_t
-sigset (sig, disp)
-     int sig;
-     __sighandler_t disp;
+sigset (int sig, __sighandler_t disp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigsetmask.c b/signal/sigsetmask.c
index fc27bd4..3d8b485 100644
--- a/signal/sigsetmask.c
+++ b/signal/sigsetmask.c
@@ -19,8 +19,7 @@
 #include <signal.h>
 
 int
-__sigsetmask (mask)
-     int mask;
+__sigsetmask (int mask)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigstack.c b/signal/sigstack.c
index 4704a56..81fe214 100644
--- a/signal/sigstack.c
+++ b/signal/sigstack.c
@@ -21,9 +21,7 @@
 /* Run signals handlers on the stack specified by SS (if not NULL).
    If OSS is not NULL, it is filled in with the old signal stack status.  */
 int
-sigstack (ss, oss)
-     struct sigstack *ss;
-     struct sigstack *oss;
+sigstack (struct sigstack *ss, struct sigstack *oss)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigsuspend.c b/signal/sigsuspend.c
index cb4ece8..987104e 100644
--- a/signal/sigsuspend.c
+++ b/signal/sigsuspend.c
@@ -22,8 +22,7 @@
 /* Change the set of blocked signals to SET,
    wait until a signal arrives, and restore the set of blocked signals.  */
 int
-__sigsuspend (set)
-     const sigset_t *set;
+__sigsuspend (const sigset_t *set)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/signal/sigvec.c b/signal/sigvec.c
index 1f9395e..83da1e3 100644
--- a/signal/sigvec.c
+++ b/signal/sigvec.c
@@ -179,8 +179,7 @@ compat_symbol (libc, __sigvec, sigvec, GLIBC_2_0);
 
 # ifndef SA_RESETHAND
 static void
-sigvec_wrapper_handler (sig)
-     int sig;
+sigvec_wrapper_handler (int sig)
 {
   struct sigvec_wrapper_data *data;
   struct sigaction act;
diff --git a/signal/sysv_signal.c b/signal/sysv_signal.c
index 0312696..8482120 100644
--- a/signal/sysv_signal.c
+++ b/signal/sysv_signal.c
@@ -21,9 +21,7 @@
 /* Set the handler for the signal SIG to HANDLER,
    returning the old handler, or SIG_ERR on error.  */
 __sighandler_t
-__sysv_signal (sig, handler)
-     int sig;
-     __sighandler_t handler;
+__sysv_signal (int sig, __sighandler_t handler)
 {
   /* Check signal extents to protect __sigismember.  */
   if (handler == SIG_ERR || sig < 1 || sig >= NSIG)
diff --git a/socket/accept.c b/socket/accept.c
index 619bee5..76765aa 100644
--- a/socket/accept.c
+++ b/socket/accept.c
@@ -24,10 +24,7 @@
    peer and *ADDR_LEN to the address's actual length, and return the
    new socket's descriptor, or -1 for errors.  */
 int
-accept (fd, addr, addr_len)
-     int fd;
-     __SOCKADDR_ARG addr;
-     socklen_t *addr_len;
+accept (int fd, __SOCKADDR_ARG addr, socklen_t *addr_len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/accept4.c b/socket/accept4.c
index e1a6d05..b6c1731 100644
--- a/socket/accept4.c
+++ b/socket/accept4.c
@@ -25,11 +25,7 @@
    new socket's descriptor, or -1 for errors.  The operation can be influenced
    by the FLAGS parameter.  */
 int
-__libc_accept4 (fd, addr, addr_len, flags)
-     int fd;
-     __SOCKADDR_ARG addr;
-     socklen_t *addr_len;
-     int flags;
+__libc_accept4 (int fd, __SOCKADDR_ARG addr, socklen_t *addr_len, int flags)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/bind.c b/socket/bind.c
index 4dea286..15ff31f 100644
--- a/socket/bind.c
+++ b/socket/bind.c
@@ -20,10 +20,7 @@
 
 /* Give the socket FD the local address ADDR (which is LEN bytes long).  */
 int
-__bind (fd, addr, len)
-     int fd;
-     __CONST_SOCKADDR_ARG addr;
-     socklen_t len;
+__bind (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/connect.c b/socket/connect.c
index 45cee74..e02b869 100644
--- a/socket/connect.c
+++ b/socket/connect.c
@@ -23,10 +23,7 @@
    and the only address from which to accept transmissions.
    Return 0 on success, -1 for errors.  */
 int
-__connect (fd, addr, len)
-     int fd;
-     __CONST_SOCKADDR_ARG addr;
-     socklen_t len;
+__connect (int fd, __CONST_SOCKADDR_ARG addr, socklen_t len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/getpeername.c b/socket/getpeername.c
index d3425bb..43adc68 100644
--- a/socket/getpeername.c
+++ b/socket/getpeername.c
@@ -21,10 +21,7 @@
 /* Put the address of the peer connected to socket FD into *ADDR
    (which is *LEN bytes long), and its actual length into *LEN.  */
 int
-getpeername (fd, addr, len)
-     int fd;
-     __SOCKADDR_ARG addr;
-     socklen_t *len;
+getpeername (int fd, __SOCKADDR_ARG addr, socklen_t *len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/getsockname.c b/socket/getsockname.c
index 47e1838..4d6fac9 100644
--- a/socket/getsockname.c
+++ b/socket/getsockname.c
@@ -20,10 +20,7 @@
 
 /* Put the local address of FD into *ADDR and its length in *LEN.  */
 int
-__getsockname (fd, addr, len)
-     int fd;
-     __SOCKADDR_ARG addr;
-     socklen_t *len;
+__getsockname (int fd, __SOCKADDR_ARG addr, socklen_t *len)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/getsockopt.c b/socket/getsockopt.c
index 73fb15e..7b0f3b3 100644
--- a/socket/getsockopt.c
+++ b/socket/getsockopt.c
@@ -22,12 +22,7 @@
    into OPTVAL (which is *OPTLEN bytes long), and set *OPTLEN to the value's
    actual length.  Returns 0 on success, -1 for errors.  */
 int
-getsockopt (fd, level, optname, optval, optlen)
-     int fd;
-     int level;
-     int optname;
-     void *optval;
-     socklen_t *optlen;
+getsockopt (int fd, int level, int optname, void *optval, socklen_t *optlen)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/listen.c b/socket/listen.c
index 2bbdfdc..aa4d307 100644
--- a/socket/listen.c
+++ b/socket/listen.c
@@ -22,9 +22,7 @@
    N connection requests will be queued before further requests are refused.
    Returns 0 on success, -1 for errors.  */
 int
-__listen (fd, n)
-     int fd;
-     int n;
+__listen (int fd, int n)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/recv.c b/socket/recv.c
index 63a9fcb..89cdf5b 100644
--- a/socket/recv.c
+++ b/socket/recv.c
@@ -21,11 +21,7 @@
 /* Read N bytes into BUF from socket FD.
    Returns the number read or -1 for errors.  */
 ssize_t
-__recv (fd, buf, n, flags)
-     int fd;
-     void *buf;
-     size_t n;
-     int flags;
+__recv (int fd, void *buf, size_t n, int flags)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/recvmsg.c b/socket/recvmsg.c
index d34a435..7dcbdc3 100644
--- a/socket/recvmsg.c
+++ b/socket/recvmsg.c
@@ -21,10 +21,7 @@
 /* Receive a message as described by MESSAGE from socket FD.
    Returns the number of bytes read or -1 for errors.  */
 ssize_t
-__recvmsg (fd, message, flags)
-     int fd;
-     struct msghdr *message;
-     int flags;
+__recvmsg (int fd, struct msghdr *message, int flags)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/send.c b/socket/send.c
index 4ecb332..cbe3b85 100644
--- a/socket/send.c
+++ b/socket/send.c
@@ -20,11 +20,7 @@
 
 /* Send N bytes of BUF to socket FD.  Returns the number sent or -1.  */
 ssize_t
-__send (fd, buf, n, flags)
-     int fd;
-     const __ptr_t buf;
-     size_t n;
-     int flags;
+__send (int fd, const __ptr_t buf, size_t n, int flags)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/sendmsg.c b/socket/sendmsg.c
index 586f598..e9e3752 100644
--- a/socket/sendmsg.c
+++ b/socket/sendmsg.c
@@ -21,10 +21,7 @@
 /* Send a message described MESSAGE on socket FD.
    Returns the number of bytes sent, or -1 for errors.  */
 ssize_t
-__sendmsg (fd, message, flags)
-     int fd;
-     const struct msghdr *message;
-     int flags;
+__sendmsg (int fd, const struct msghdr *message, int flags)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/shutdown.c b/socket/shutdown.c
index ea5f7b3..912846e 100644
--- a/socket/shutdown.c
+++ b/socket/shutdown.c
@@ -25,9 +25,7 @@
      2 = No more receptions or transmissions.
    Returns 0 on success, -1 for errors.  */
 int
-shutdown (fd, how)
-     int fd;
-     int how;
+shutdown (int fd, int how)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/sockatmark.c b/socket/sockatmark.c
index 6ff6d01..a00d311 100644
--- a/socket/sockatmark.c
+++ b/socket/sockatmark.c
@@ -20,8 +20,7 @@
 
 /* Determine wheter socket is at a out-of-band mark.  */
 int
-sockatmark (fd)
-     int fd;
+sockatmark (int fd)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/socket/socket.c b/socket/socket.c
index 9fe8fd9..6f879ea 100644
--- a/socket/socket.c
+++ b/socket/socket.c
@@ -22,10 +22,7 @@
    protocol PROTOCOL.  If PROTOCOL is zero, one is chosen automatically.
    Returns a file descriptor for the new socket, or -1 for errors.  */
 int
-__socket (domain, type, protocol)
-     int domain;
-     int type;
-     int protocol;
+__socket (int domain, int type, int protocol)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdio-common/ctermid.c b/stdio-common/ctermid.c
index 454402d..319704f 100644
--- a/stdio-common/ctermid.c
+++ b/stdio-common/ctermid.c
@@ -23,8 +23,7 @@
    If S is not NULL, the name is copied into it (it should be at
    least L_ctermid bytes long), otherwise a static buffer is used.  */
 char *
-ctermid (s)
-     char *s;
+ctermid (char *s)
 {
   __set_errno (ENOSYS);
   return NULL;
diff --git a/stdio-common/cuserid.c b/stdio-common/cuserid.c
index 7ab5bb8..3b5a755 100644
--- a/stdio-common/cuserid.c
+++ b/stdio-common/cuserid.c
@@ -22,8 +22,7 @@
    If S is not NULL, it points to a buffer of at least L_cuserid bytes
    into which the name is copied; otherwise, a static buffer is used.  */
 char *
-cuserid (s)
-     char *s;
+cuserid (char *s)
 {
   __set_errno (ENOSYS);
   return NULL;
diff --git a/stdio-common/printf-prs.c b/stdio-common/printf-prs.c
index d66fd15..8d26a36 100644
--- a/stdio-common/printf-prs.c
+++ b/stdio-common/printf-prs.c
@@ -56,10 +56,7 @@
 
 
 size_t
-parse_printf_format (fmt, n, argtypes)
-      const char *fmt;
-      size_t n;
-      int *argtypes;
+parse_printf_format (const char *fmt, size_t n, int *argtypes)
 {
   size_t nargs;			/* Number of arguments.  */
   size_t max_ref_arg;		/* Highest index used in a positional arg.  */
diff --git a/stdio-common/remove.c b/stdio-common/remove.c
index c1815b8..b365b12 100644
--- a/stdio-common/remove.c
+++ b/stdio-common/remove.c
@@ -20,8 +20,7 @@
 #include <stdio.h>
 
 int
-remove (file)
-     const char *file;
+remove (const char *file)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdio-common/rename.c b/stdio-common/rename.c
index b4e521d..f56f19d 100644
--- a/stdio-common/rename.c
+++ b/stdio-common/rename.c
@@ -21,9 +21,7 @@
 
 /* Rename the file OLD to NEW.  */
 int
-rename (old, new)
-     const char *old;
-     const char *new;
+rename (const char *old, const char *new)
 {
   if (old == NULL || new == NULL)
     {
diff --git a/stdio-common/renameat.c b/stdio-common/renameat.c
index f191fc3..bbe9d3a 100644
--- a/stdio-common/renameat.c
+++ b/stdio-common/renameat.c
@@ -22,11 +22,7 @@
 
 /* Rename the file OLD relative to OLDFD to NEW relative to NEWFD.  */
 int
-renameat (oldfd, old, newfd, new)
-     int oldfd;
-     const char *old;
-     int newfd;
-     const char *new;
+renameat (int oldfd, const char *old, int newfd, const char *new)
 {
   if ((oldfd < 0 && oldfd != AT_FDCWD) || (newfd < 0 && newfd != AT_FDCWD))
     {
diff --git a/stdio-common/tempname.c b/stdio-common/tempname.c
index 32a91b0..4aef3bc 100644
--- a/stdio-common/tempname.c
+++ b/stdio-common/tempname.c
@@ -46,11 +46,7 @@ stub_warning (__path_search)
  */
 
 int
-__gen_tempname (tmpl, suffixlen, flags, kind)
-     char *tmpl;
-     int suffixlen;
-     int flags;
-     int kind;
+__gen_tempname (char *tmpl, int suffixlen, int flags, int kind)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdio-common/xbug.c b/stdio-common/xbug.c
index 64ba314..06f74af 100644
--- a/stdio-common/xbug.c
+++ b/stdio-common/xbug.c
@@ -14,18 +14,16 @@ void ReadFile (Buffer *buffer, FILE *input);
 
 #define INIT_BUFFER_SIZE 10000
 
-void InitBuffer(b)
-     Buffer *b;
+void
+InitBuffer (Buffer *b)
 {
   b->room = INIT_BUFFER_SIZE;
   b->used = 0;
   b->buff = (char *)malloc(INIT_BUFFER_SIZE*sizeof(char));
 }
 
-void AppendToBuffer(b, str, len)
-     Buffer *b;
-     const char *str;
-     int len;
+void
+AppendToBuffer (Buffer *b, const char *str, int len)
 {
   while (b->used + len > b->room) {
     b->buff = (char *)realloc(b->buff, 2*b->room*(sizeof(char)));
@@ -35,9 +33,8 @@ void AppendToBuffer(b, str, len)
   b->used += len;
 }
 
-void ReadFile(buffer, input)
-     Buffer *buffer;
-     FILE *input;
+void
+ReadFile (Buffer *buffer, FILE *input)
 {
   char       buf[BUFSIZ + 1];
   int        bytes;
diff --git a/stdlib/a64l.c b/stdlib/a64l.c
index 156a4a0..5a88ff9 100644
--- a/stdlib/a64l.c
+++ b/stdlib/a64l.c
@@ -36,8 +36,7 @@ static const char a64l_table[TABLE_SIZE] =
 
 
 long int
-a64l (string)
-     const char *string;
+a64l (const char *string)
 {
   const char *ptr = string;
   unsigned long int result = 0ul;
diff --git a/stdlib/drand48_r.c b/stdlib/drand48_r.c
index 014af96..7e1772d 100644
--- a/stdlib/drand48_r.c
+++ b/stdlib/drand48_r.c
@@ -21,9 +21,7 @@
 #include <stdlib.h>
 
 int
-drand48_r (buffer, result)
-     struct drand48_data *buffer;
-     double *result;
+drand48_r (struct drand48_data *buffer, double *result)
 {
   return __erand48_r (buffer->__x, buffer, result);
 }
diff --git a/stdlib/getcontext.c b/stdlib/getcontext.c
index c72e2e2..d36226c 100644
--- a/stdlib/getcontext.c
+++ b/stdlib/getcontext.c
@@ -19,8 +19,7 @@
 #include <ucontext.h>
 
 int
-getcontext (ucp)
-     ucontext_t *ucp;
+getcontext (ucontext_t *ucp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdlib/getenv.c b/stdlib/getenv.c
index f0842fd..2e40053 100644
--- a/stdlib/getenv.c
+++ b/stdlib/getenv.c
@@ -30,8 +30,7 @@
    two characters which we can access.  By doing this we can avoid using the
    `strncmp' most of the time.  */
 char *
-getenv (name)
-     const char *name;
+getenv (const char *name)
 {
   size_t len = strlen (name);
   char **ep;
diff --git a/stdlib/l64a.c b/stdlib/l64a.c
index 379e1f8..bed8cd2 100644
--- a/stdlib/l64a.c
+++ b/stdlib/l64a.c
@@ -32,8 +32,7 @@ static const char conv_table[64] =
 };
 
 char *
-l64a (n)
-     long int n;
+l64a (long int n)
 {
   unsigned long int m = (unsigned long int) n;
   static char result[7];
diff --git a/stdlib/llabs.c b/stdlib/llabs.c
index 8f301d1..9c24183 100644
--- a/stdlib/llabs.c
+++ b/stdlib/llabs.c
@@ -23,8 +23,7 @@
 
 /* Return the absolute value of I.  */
 long long int
-llabs (i)
-     long long int i;
+llabs (long long int i)
 {
   return i < 0 ? -i : i;
 }
diff --git a/stdlib/lldiv.c b/stdlib/lldiv.c
index 4a8a870..979abfe 100644
--- a/stdlib/lldiv.c
+++ b/stdlib/lldiv.c
@@ -21,9 +21,7 @@
 
 /* Return the `lldiv_t' representation of NUMER over DENOM.  */
 lldiv_t
-lldiv (numer, denom)
-     long long int numer;
-     long long int denom;
+lldiv (long long int numer, long long int denom)
 {
   lldiv_t result;
 
diff --git a/stdlib/lrand48_r.c b/stdlib/lrand48_r.c
index 8d554c7..1e5eaa2 100644
--- a/stdlib/lrand48_r.c
+++ b/stdlib/lrand48_r.c
@@ -19,9 +19,7 @@
 #include <stdlib.h>
 
 int
-lrand48_r (buffer, result)
-     struct drand48_data *buffer;
-     long int *result;
+lrand48_r (struct drand48_data *buffer, long int *result)
 {
   /* Be generous for the arguments, detect some errors.  */
   if (buffer == NULL)
diff --git a/stdlib/mrand48_r.c b/stdlib/mrand48_r.c
index f0f885c..a601926 100644
--- a/stdlib/mrand48_r.c
+++ b/stdlib/mrand48_r.c
@@ -19,9 +19,7 @@
 #include <stdlib.h>
 
 int
-mrand48_r (buffer, result)
-     struct drand48_data *buffer;
-     long int *result;
+mrand48_r (struct drand48_data *buffer, long int *result)
 {
   /* Be generous for the arguments, detect some errors.  */
   if (buffer == NULL)
diff --git a/stdlib/putenv.c b/stdlib/putenv.c
index 829bea2..57d3432 100644
--- a/stdlib/putenv.c
+++ b/stdlib/putenv.c
@@ -49,8 +49,7 @@ extern char *alloca ();
 
 /* Put STRING, which is of the form "NAME=VALUE", in the environment.  */
 int
-putenv (string)
-     char *string;
+putenv (char *string)
 {
   const char *const name_end = strchr (string, '=');
 
diff --git a/stdlib/random.c b/stdlib/random.c
index 0c9e02e..137d2ba 100644
--- a/stdlib/random.c
+++ b/stdlib/random.c
@@ -205,8 +205,7 @@ __libc_lock_define_initialized (static, lock)
    introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
    for default usage relies on values produced by this routine.  */
 void
-__srandom (x)
-     unsigned int x;
+__srandom (unsigned int x)
 {
   __libc_lock_lock (lock);
   (void) __srandom_r (x, &unsafe_state);
@@ -228,10 +227,7 @@ weak_alias (__srandom, srand)
    setstate so that it doesn't matter when initstate is called.
    Returns a pointer to the old state.  */
 char *
-__initstate (seed, arg_state, n)
-     unsigned int seed;
-     char *arg_state;
-     size_t n;
+__initstate (unsigned int seed, char *arg_state, size_t n)
 {
   int32_t *ostate;
   int ret;
@@ -258,8 +254,7 @@ weak_alias (__initstate, initstate)
    same state as the current state
    Returns a pointer to the old state information.  */
 char *
-__setstate (arg_state)
-     char *arg_state;
+__setstate (char *arg_state)
 {
   int32_t *ostate;
 
diff --git a/stdlib/random_r.c b/stdlib/random_r.c
index c4cd9a3..059f7af 100644
--- a/stdlib/random_r.c
+++ b/stdlib/random_r.c
@@ -158,9 +158,7 @@ static const struct random_poly_info random_poly_info =
    introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
    for default usage relies on values produced by this routine.  */
 int
-__srandom_r (seed, buf)
-     unsigned int seed;
-     struct random_data *buf;
+__srandom_r (unsigned int seed, struct random_data *buf)
 {
   int type;
   int32_t *state;
@@ -297,9 +295,7 @@ weak_alias (__initstate_r, initstate_r)
    same state as the current state
    Returns 0 on success, non-zero on failure.  */
 int
-__setstate_r (arg_state, buf)
-     char *arg_state;
-     struct random_data *buf;
+__setstate_r (char *arg_state, struct random_data *buf)
 {
   int32_t *new_state = 1 + (int32_t *) arg_state;
   int type;
@@ -357,9 +353,7 @@ weak_alias (__setstate_r, setstate_r)
    pointer if the front one has wrapped.  Returns a 31-bit random number.  */
 
 int
-__random_r (buf, result)
-     struct random_data *buf;
-     int32_t *result;
+__random_r (struct random_data *buf, int32_t *result)
 {
   int32_t *state;
 
diff --git a/stdlib/secure-getenv.c b/stdlib/secure-getenv.c
index 1b0e7d3..5c146f0 100644
--- a/stdlib/secure-getenv.c
+++ b/stdlib/secure-getenv.c
@@ -24,8 +24,7 @@
    what values to accept from the environment.  This special version
    checks for SUID or SGID first before doing any work.  */
 char *
-__libc_secure_getenv (name)
-     const char *name;
+__libc_secure_getenv (const char *name)
 {
   return __libc_enable_secure ? NULL : getenv (name);
 }
diff --git a/stdlib/setcontext.c b/stdlib/setcontext.c
index bb97710..b38571e 100644
--- a/stdlib/setcontext.c
+++ b/stdlib/setcontext.c
@@ -19,8 +19,7 @@
 #include <ucontext.h>
 
 int
-setcontext (ucp)
-     const ucontext_t *ucp;
+setcontext (const ucontext_t *ucp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdlib/setenv.c b/stdlib/setenv.c
index dad7e71..d39eed3 100644
--- a/stdlib/setenv.c
+++ b/stdlib/setenv.c
@@ -255,10 +255,7 @@ __add_to_environ (name, value, combined, replace)
 }
 
 int
-setenv (name, value, replace)
-     const char *name;
-     const char *value;
-     int replace;
+setenv (const char *name, const char *value, int replace)
 {
   if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
     {
@@ -270,8 +267,7 @@ setenv (name, value, replace)
 }
 
 int
-unsetenv (name)
-     const char *name;
+unsetenv (const char *name)
 {
   size_t len;
   char **ep;
diff --git a/stdlib/srand48.c b/stdlib/srand48.c
index 8be470b..0f11ff1 100644
--- a/stdlib/srand48.c
+++ b/stdlib/srand48.c
@@ -20,8 +20,7 @@
 
 
 void
-srand48 (seedval)
-     long seedval;
+srand48 (long seedval)
 {
   (void) __srand48_r (seedval, &__libc_drand48_data);
 }
diff --git a/stdlib/srand48_r.c b/stdlib/srand48_r.c
index 03a9699..ef534c1 100644
--- a/stdlib/srand48_r.c
+++ b/stdlib/srand48_r.c
@@ -20,9 +20,7 @@
 #include <limits.h>
 
 int
-__srand48_r (seedval, buffer)
-     long int seedval;
-     struct drand48_data *buffer;
+__srand48_r (long int seedval, struct drand48_data *buffer)
 {
   /* The standards say we only have 32 bits.  */
   if (sizeof (long int) > 4)
diff --git a/stdlib/swapcontext.c b/stdlib/swapcontext.c
index 988e4aa..94dc92c 100644
--- a/stdlib/swapcontext.c
+++ b/stdlib/swapcontext.c
@@ -19,9 +19,7 @@
 #include <ucontext.h>
 
 int
-swapcontext (oucp, ucp)
-     ucontext_t *oucp;
-     const ucontext_t *ucp;
+swapcontext (ucontext_t *oucp, const ucontext_t *ucp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/stdlib/system.c b/stdlib/system.c
index f3dbe50..c4a4a90 100644
--- a/stdlib/system.c
+++ b/stdlib/system.c
@@ -21,8 +21,7 @@
 
 /* Execute LINE as a shell command.  */
 int
-__libc_system (line)
-     const char *line;
+__libc_system (const char *line)
 {
   if (line == NULL)
     return 0;			/* This indicates no command processor.  */
diff --git a/stdlib/tst-strtod.c b/stdlib/tst-strtod.c
index b985990..848e107 100644
--- a/stdlib/tst-strtod.c
+++ b/stdlib/tst-strtod.c
@@ -182,9 +182,7 @@ do_test (void)
 }
 
 static void
-expand (dst, c)
-     char *dst;
-     int c;
+expand (char *dst, int c)
 {
   if (isprint (c))
     {
diff --git a/stdlib/tst-strtol.c b/stdlib/tst-strtol.c
index 448102a..5b80622 100644
--- a/stdlib/tst-strtol.c
+++ b/stdlib/tst-strtol.c
@@ -611,9 +611,7 @@ do_test (void)
 }
 
 static void
-expand (dst, c)
-     char *dst;
-     int c;
+expand (char *dst, int c)
 {
   if (isprint (c))
     {
diff --git a/stdlib/tst-strtoll.c b/stdlib/tst-strtoll.c
index 93f1a56..de39ee3 100644
--- a/stdlib/tst-strtoll.c
+++ b/stdlib/tst-strtoll.c
@@ -386,9 +386,7 @@ do_test (void)
 }
 
 static void
-expand (dst, c)
-     char *dst;
-     int c;
+expand (char *dst, int c)
 {
   if (isprint (c))
     {
diff --git a/streams/fattach.c b/streams/fattach.c
index 6a282d8..8e1edfc 100644
--- a/streams/fattach.c
+++ b/streams/fattach.c
@@ -19,9 +19,7 @@
 #include <stropts.h>
 
 int
-fattach (fildes, path)
-     int fildes;
-     const char *path;
+fattach (int fildes, const char *path)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/streams/fdetach.c b/streams/fdetach.c
index 09706de..44d9d93 100644
--- a/streams/fdetach.c
+++ b/streams/fdetach.c
@@ -19,8 +19,7 @@
 #include <stropts.h>
 
 int
-fdetach (path)
-     const char *path;
+fdetach (const char *path)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/streams/getmsg.c b/streams/getmsg.c
index 5ca595a..12fbb7a 100644
--- a/streams/getmsg.c
+++ b/streams/getmsg.c
@@ -19,11 +19,7 @@
 #include <stropts.h>
 
 int
-getmsg (fildes, ctlptr, dataptr, flagsp)
-     int fildes;
-     struct strbuf *ctlptr;
-     struct strbuf *dataptr;
-     int *flagsp;
+getmsg (int fildes, struct strbuf *ctlptr, struct strbuf *dataptr, int *flagsp)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/streams/isastream.c b/streams/isastream.c
index f8d2b20..5ed976a 100644
--- a/streams/isastream.c
+++ b/streams/isastream.c
@@ -20,8 +20,7 @@
 #include <stropts.h>
 
 int
-isastream (fildes)
-     int fildes;
+isastream (int fildes)
 {
   /* In general we do not have a STREAMS implementation and therefore
      return 0.  But for invalid file descriptors we have to return an
diff --git a/string/ffs.c b/string/ffs.c
index a30deeb..28f7fc4 100644
--- a/string/ffs.c
+++ b/string/ffs.c
@@ -24,8 +24,7 @@
 
 /* Find the first bit set in I.  */
 int
-__ffs (i)
-     int i;
+__ffs (int i)
 {
   static const unsigned char table[] =
     {
diff --git a/string/ffsll.c b/string/ffsll.c
index 2c89171..6bcfe12 100644
--- a/string/ffsll.c
+++ b/string/ffsll.c
@@ -24,8 +24,7 @@
 
 /* Find the first bit set in I.  */
 int
-ffsll (i)
-     long long int i;
+ffsll (long long int i)
 {
   unsigned long long int x = i & -i;
 
diff --git a/string/memcmp.c b/string/memcmp.c
index 41e0586..429c9c8 100644
--- a/string/memcmp.c
+++ b/string/memcmp.c
@@ -118,10 +118,7 @@ static int memcmp_common_alignment (long, long, size_t) __THROW;
    objects (not LEN bytes!).  Both SRCP1 and SRCP2 should be aligned for
    memory operations on `op_t's.  */
 static int
-memcmp_common_alignment (srcp1, srcp2, len)
-     long int srcp1;
-     long int srcp2;
-     size_t len;
+memcmp_common_alignment (long int srcp1, long int srcp2, size_t len)
 {
   op_t a0, a1;
   op_t b0, b1;
@@ -205,10 +202,7 @@ static int memcmp_not_common_alignment (long, long, size_t) __THROW;
    `op_t' objects (not LEN bytes!).  SRCP2 should be aligned for memory
    operations on `op_t', but SRCP1 *should be unaligned*.  */
 static int
-memcmp_not_common_alignment (srcp1, srcp2, len)
-     long int srcp1;
-     long int srcp2;
-     size_t len;
+memcmp_not_common_alignment (long int srcp1, long int srcp2, size_t len)
 {
   op_t a0, a1, a2, a3;
   op_t b0, b1, b2, b3;
@@ -308,10 +302,7 @@ memcmp_not_common_alignment (srcp1, srcp2, len)
 }
 
 int
-MEMCMP (s1, s2, len)
-     const __ptr_t s1;
-     const __ptr_t s2;
-     size_t len;
+MEMCMP (const __ptr_t s1, const __ptr_t s2, size_t len)
 {
   op_t a0;
   op_t b0;
diff --git a/string/memcpy.c b/string/memcpy.c
index 4a58508..edf7796 100644
--- a/string/memcpy.c
+++ b/string/memcpy.c
@@ -24,10 +24,7 @@
 #undef memcpy
 
 void *
-memcpy (dstpp, srcpp, len)
-     void *dstpp;
-     const void *srcpp;
-     size_t len;
+memcpy (void *dstpp, const void *srcpp, size_t len)
 {
   unsigned long int dstp = (long int) dstpp;
   unsigned long int srcp = (long int) srcpp;
diff --git a/string/memmove.c b/string/memmove.c
index 5748256..ecb36a9 100644
--- a/string/memmove.c
+++ b/string/memmove.c
@@ -41,10 +41,7 @@
 
 rettype
 inhibit_loop_to_libcall
-MEMMOVE (a1, a2, len)
-     a1const void *a1;
-     a2const void *a2;
-     size_t len;
+MEMMOVE (a1const void *a1, a2const void *a2, size_t len)
 {
   unsigned long int dstp = (long int) dest;
   unsigned long int srcp = (long int) src;
diff --git a/string/memset.c b/string/memset.c
index 18faf06..5bdf05b 100644
--- a/string/memset.c
+++ b/string/memset.c
@@ -22,10 +22,7 @@
 
 void *
 inhibit_loop_to_libcall
-memset (dstpp, c, len)
-     void *dstpp;
-     int c;
-     size_t len;
+memset (void *dstpp, int c, size_t len)
 {
   long int dstp = (long int) dstpp;
 
diff --git a/string/rawmemchr.c b/string/rawmemchr.c
index 228ca9d..b18c8ad 100644
--- a/string/rawmemchr.c
+++ b/string/rawmemchr.c
@@ -53,9 +53,7 @@
 
 /* Find the first occurrence of C in S.  */
 __ptr_t
-RAWMEMCHR (s, c_in)
-     const __ptr_t s;
-     int c_in;
+RAWMEMCHR (const __ptr_t s, int c_in)
 {
   const unsigned char *char_ptr;
   const unsigned long int *longword_ptr;
diff --git a/string/strchrnul.c b/string/strchrnul.c
index daf0b3f..e084f5d 100644
--- a/string/strchrnul.c
+++ b/string/strchrnul.c
@@ -33,9 +33,7 @@
 
 /* Find the first occurrence of C in S or the final NUL byte.  */
 char *
-STRCHRNUL (s, c_in)
-     const char *s;
-     int c_in;
+STRCHRNUL (const char *s, int c_in)
 {
   const unsigned char *char_ptr;
   const unsigned long int *longword_ptr;
diff --git a/string/strerror.c b/string/strerror.c
index 824d09f..922ebb7 100644
--- a/string/strerror.c
+++ b/string/strerror.c
@@ -26,8 +26,7 @@
 libc_freeres_ptr (static char *buf);
 
 char *
-strerror (errnum)
-     int errnum;
+strerror (int errnum)
 {
   char *ret = __strerror_r (errnum, NULL, 0);
   int saved_errno;
diff --git a/string/strndup.c b/string/strndup.c
index 15b19f7..a15a006 100644
--- a/string/strndup.c
+++ b/string/strndup.c
@@ -37,9 +37,7 @@ char *malloc ();
 #endif
 
 char *
-__strndup (s, n)
-     const char *s;
-     size_t n;
+__strndup (const char *s, size_t n)
 {
   size_t len = __strnlen (s, n);
   char *new = (char *) malloc (len + 1);
diff --git a/string/strverscmp.c b/string/strverscmp.c
index 38bf5e2..0c15e52 100644
--- a/string/strverscmp.c
+++ b/string/strverscmp.c
@@ -39,9 +39,7 @@
 */
 
 int
-__strverscmp (s1, s2)
-     const char *s1;
-     const char *s2;
+__strverscmp (const char *s1, const char *s2)
 {
   const unsigned char *p1 = (const unsigned char *) s1;
   const unsigned char *p2 = (const unsigned char *) s2;
diff --git a/sunrpc/clnt_raw.c b/sunrpc/clnt_raw.c
index 4004c6b..6653ee4 100644
--- a/sunrpc/clnt_raw.c
+++ b/sunrpc/clnt_raw.c
@@ -223,10 +223,7 @@ clntraw_geterr (CLIENT *cl, struct rpc_err *err)
 
 
 static bool_t
-clntraw_freeres (cl, xdr_res, res_ptr)
-     CLIENT *cl;
-     xdrproc_t xdr_res;
-     caddr_t res_ptr;
+clntraw_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
 {
   struct clntraw_private_s *clp = clntraw_private;
   XDR *xdrs = &clp->xdr_stream;
diff --git a/sunrpc/clnt_tcp.c b/sunrpc/clnt_tcp.c
index f4ba0ef..534b310 100644
--- a/sunrpc/clnt_tcp.c
+++ b/sunrpc/clnt_tcp.c
@@ -332,9 +332,7 @@ call_again:
 }
 
 static void
-clnttcp_geterr (h, errp)
-     CLIENT *h;
-     struct rpc_err *errp;
+clnttcp_geterr (CLIENT *h, struct rpc_err *errp)
 {
   struct ct_data *ct =
   (struct ct_data *) h->cl_private;
@@ -343,10 +341,7 @@ clnttcp_geterr (h, errp)
 }
 
 static bool_t
-clnttcp_freeres (cl, xdr_res, res_ptr)
-     CLIENT *cl;
-     xdrproc_t xdr_res;
-     caddr_t res_ptr;
+clnttcp_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
 {
   struct ct_data *ct = (struct ct_data *) cl->cl_private;
   XDR *xdrs = &(ct->ct_xdrs);
diff --git a/sunrpc/clnt_unix.c b/sunrpc/clnt_unix.c
index 32d88b9..ac3465e 100644
--- a/sunrpc/clnt_unix.c
+++ b/sunrpc/clnt_unix.c
@@ -317,10 +317,7 @@ clntunix_geterr (CLIENT *h, struct rpc_err *errp)
 }
 
 static bool_t
-clntunix_freeres (cl, xdr_res, res_ptr)
-     CLIENT *cl;
-     xdrproc_t xdr_res;
-     caddr_t res_ptr;
+clntunix_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
 {
   struct ct_data *ct = (struct ct_data *) cl->cl_private;
   XDR *xdrs = &(ct->ct_xdrs);
diff --git a/sunrpc/pmap_prot.c b/sunrpc/pmap_prot.c
index 8df41dc..0919d09 100644
--- a/sunrpc/pmap_prot.c
+++ b/sunrpc/pmap_prot.c
@@ -38,9 +38,7 @@
 
 
 bool_t
-xdr_pmap (xdrs, regs)
-     XDR *xdrs;
-     struct pmap *regs;
+xdr_pmap (XDR *xdrs, struct pmap *regs)
 {
 
   if (xdr_u_long (xdrs, &regs->pm_prog) &&
diff --git a/sunrpc/pmap_prot2.c b/sunrpc/pmap_prot2.c
index 57b0800..01f158d 100644
--- a/sunrpc/pmap_prot2.c
+++ b/sunrpc/pmap_prot2.c
@@ -76,9 +76,7 @@
  * this sounds like a job for xdr_reference!
  */
 bool_t
-xdr_pmaplist (xdrs, rp)
-     XDR *xdrs;
-     struct pmaplist **rp;
+xdr_pmaplist (XDR *xdrs, struct pmaplist **rp)
 {
   /*
    * more_elements is pre-computed in case the direction is
diff --git a/sunrpc/pmap_rmt.c b/sunrpc/pmap_rmt.c
index fd8de85..c0adc5b 100644
--- a/sunrpc/pmap_rmt.c
+++ b/sunrpc/pmap_rmt.c
@@ -144,9 +144,7 @@ libc_hidden_nolink_sunrpc (xdr_rmtcall_args, GLIBC_2_0)
  * written for XDR_DECODE direction only
  */
 bool_t
-xdr_rmtcallres (xdrs, crp)
-     XDR *xdrs;
-     struct rmtcallres *crp;
+xdr_rmtcallres (XDR *xdrs, struct rmtcallres *crp)
 {
   caddr_t port_ptr;
 
diff --git a/sunrpc/rpc_prot.c b/sunrpc/rpc_prot.c
index dc24f36..f47c6be 100644
--- a/sunrpc/rpc_prot.c
+++ b/sunrpc/rpc_prot.c
@@ -130,9 +130,7 @@ static const struct xdr_discrim reply_dscrm[3] =
  * XDR a reply message
  */
 bool_t
-xdr_replymsg (xdrs, rmsg)
-     XDR *xdrs;
-     struct rpc_msg *rmsg;
+xdr_replymsg (XDR *xdrs, struct rpc_msg *rmsg)
 {
   if (xdr_u_long (xdrs, &(rmsg->rm_xid)) &&
       xdr_enum (xdrs, (enum_t *) & (rmsg->rm_direction)) &&
@@ -151,9 +149,7 @@ libc_hidden_nolink_sunrpc (xdr_replymsg, GLIBC_2_0)
  * The rm_xid is not really static, but the user can easily munge on the fly.
  */
 bool_t
-xdr_callhdr (xdrs, cmsg)
-     XDR *xdrs;
-     struct rpc_msg *cmsg;
+xdr_callhdr (XDR *xdrs, struct rpc_msg *cmsg)
 {
 
   cmsg->rm_direction = CALL;
diff --git a/sunrpc/rpcinfo.c b/sunrpc/rpcinfo.c
index e490a7e..2b55eb4 100644
--- a/sunrpc/rpcinfo.c
+++ b/sunrpc/rpcinfo.c
@@ -201,10 +201,7 @@ main (int argc, char **argv)
 }
 
 static void
-udpping (portnum, argc, argv)
-     u_short portnum;
-     int argc;
-     char **argv;
+udpping (u_short portnum, int argc, char **argv)
 {
   struct timeval to;
   struct sockaddr_in addr;
@@ -356,10 +353,7 @@ udpping (portnum, argc, argv)
 }
 
 static void
-tcpping (portnum, argc, argv)
-     u_short portnum;
-     int argc;
-     char **argv;
+tcpping (u_short portnum, int argc, char **argv)
 {
   struct timeval to;
   struct sockaddr_in addr;
@@ -505,10 +499,7 @@ tcpping (portnum, argc, argv)
  * a good error message.
  */
 static int
-pstatus (client, prognum, vers)
-     register CLIENT *client;
-     u_long prognum;
-     u_long vers;
+pstatus (register CLIENT *client, u_long prognum, u_long vers)
 {
   struct rpc_err rpcerr;
 
@@ -527,9 +518,7 @@ pstatus (client, prognum, vers)
 }
 
 static void
-pmapdump (argc, argv)
-     int argc;
-     char **argv;
+pmapdump (int argc, char **argv)
 {
   struct sockaddr_in server_addr;
   register struct hostent *hp;
@@ -624,9 +613,7 @@ reply_proc (res, who)
 }
 
 static void
-brdcst (argc, argv)
-     int argc;
-     char **argv;
+brdcst (int argc, char **argv)
 {
   enum clnt_stat rpc_stat;
   u_long prognum, vers;
@@ -651,9 +638,7 @@ brdcst (argc, argv)
 }
 
 static void
-deletereg (argc, argv)
-     int argc;
-     char **argv;
+deletereg (int argc, char **argv)
 {
   u_long prog_num, version_num;
 
@@ -700,8 +685,7 @@ print_version (void)
 }
 
 static u_long
-getprognum (arg)
-     char *arg;
+getprognum (char *arg)
 {
   register struct rpcent *rpc;
   register u_long prognum;
@@ -725,8 +709,7 @@ getprognum (arg)
 }
 
 static u_long
-getvers (arg)
-     char *arg;
+getvers (char *arg)
 {
   register u_long vers;
 
@@ -735,9 +718,7 @@ getvers (arg)
 }
 
 static void
-get_inet_address (addr, host)
-     struct sockaddr_in *addr;
-     char *host;
+get_inet_address (struct sockaddr_in *addr, char *host)
 {
   register struct hostent *hp;
 
diff --git a/sunrpc/svc_raw.c b/sunrpc/svc_raw.c
index 7d88557..99bfdfe 100644
--- a/sunrpc/svc_raw.c
+++ b/sunrpc/svc_raw.c
@@ -97,9 +97,7 @@ svcraw_stat (SVCXPRT *xprt)
 }
 
 static bool_t
-svcraw_recv (xprt, msg)
-     SVCXPRT *xprt;
-     struct rpc_msg *msg;
+svcraw_recv (SVCXPRT *xprt, struct rpc_msg *msg)
 {
   struct svcraw_private_s *srp = svcraw_private;
   XDR *xdrs;
diff --git a/sunrpc/svc_udp.c b/sunrpc/svc_udp.c
index f4beea6..2097f92 100644
--- a/sunrpc/svc_udp.c
+++ b/sunrpc/svc_udp.c
@@ -205,8 +205,7 @@ libc_hidden_nolink_sunrpc (svcudp_bufcreate, GLIBC_2_0)
 #endif
 
 SVCXPRT *
-svcudp_create (sock)
-     int sock;
+svcudp_create (int sock)
 {
   return svcudp_bufcreate (sock, UDPMSGSIZE, UDPMSGSIZE);
 }
@@ -217,17 +216,14 @@ libc_hidden_nolink_sunrpc (svcudp_create, GLIBC_2_0)
 #endif
 
 static enum xprt_stat
-svcudp_stat (xprt)
-     SVCXPRT *xprt;
+svcudp_stat (SVCXPRT *xprt)
 {
 
   return XPRT_IDLE;
 }
 
 static bool_t
-svcudp_recv (xprt, msg)
-     SVCXPRT *xprt;
-     struct rpc_msg *msg;
+svcudp_recv (SVCXPRT *xprt, struct rpc_msg *msg)
 {
   struct svcudp_data *su = su_data (xprt);
   XDR *xdrs = &(su->su_xdrs);
@@ -329,9 +325,7 @@ again:
 }
 
 static bool_t
-svcudp_reply (xprt, msg)
-     SVCXPRT *xprt;
-     struct rpc_msg *msg;
+svcudp_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 {
   struct svcudp_data *su = su_data (xprt);
   XDR *xdrs = &(su->su_xdrs);
@@ -375,20 +369,14 @@ svcudp_reply (xprt, msg)
 }
 
 static bool_t
-svcudp_getargs (xprt, xdr_args, args_ptr)
-     SVCXPRT *xprt;
-     xdrproc_t xdr_args;
-     caddr_t args_ptr;
+svcudp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 {
 
   return (*xdr_args) (&(su_data (xprt)->su_xdrs), args_ptr);
 }
 
 static bool_t
-svcudp_freeargs (xprt, xdr_args, args_ptr)
-     SVCXPRT *xprt;
-     xdrproc_t xdr_args;
-     caddr_t args_ptr;
+svcudp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 {
   XDR *xdrs = &(su_data (xprt)->su_xdrs);
 
@@ -397,8 +385,7 @@ svcudp_freeargs (xprt, xdr_args, args_ptr)
 }
 
 static void
-svcudp_destroy (xprt)
-     SVCXPRT *xprt;
+svcudp_destroy (SVCXPRT *xprt)
 {
   struct svcudp_data *su = su_data (xprt);
 
diff --git a/sunrpc/xdr.c b/sunrpc/xdr.c
index fade667..5fd6463 100644
--- a/sunrpc/xdr.c
+++ b/sunrpc/xdr.c
@@ -590,11 +590,7 @@ libc_hidden_nolink_sunrpc (xdr_opaque, GLIBC_2_0)
  * If *cpp is NULL maxsize bytes are allocated
  */
 bool_t
-xdr_bytes (xdrs, cpp, sizep, maxsize)
-     XDR *xdrs;
-     char **cpp;
-     u_int *sizep;
-     u_int maxsize;
+xdr_bytes (XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize)
 {
   char *sp = *cpp;	/* sp is the actual string pointer */
   u_int nodesize;
@@ -656,9 +652,7 @@ libc_hidden_nolink_sunrpc (xdr_bytes, GLIBC_2_0)
  * Implemented here due to commonality of the object.
  */
 bool_t
-xdr_netobj (xdrs, np)
-     XDR *xdrs;
-     struct netobj *np;
+xdr_netobj (XDR *xdrs, struct netobj *np)
 {
 
   return xdr_bytes (xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ);
@@ -733,10 +727,7 @@ libc_hidden_nolink_sunrpc (xdr_union, GLIBC_2_0)
  * of the string as specified by a protocol.
  */
 bool_t
-xdr_string (xdrs, cpp, maxsize)
-     XDR *xdrs;
-     char **cpp;
-     u_int maxsize;
+xdr_string (XDR *xdrs, char **cpp, u_int maxsize)
 {
   char *sp = *cpp;	/* sp is the actual string pointer */
   /* Initialize to silence the compiler.  It is not really needed because SIZE
@@ -817,9 +808,7 @@ libc_hidden_nolink_sunrpc (xdr_string, GLIBC_2_0)
  * routines like clnt_call
  */
 bool_t
-xdr_wrapstring (xdrs, cpp)
-     XDR *xdrs;
-     char **cpp;
+xdr_wrapstring (XDR *xdrs, char **cpp)
 {
   if (xdr_string (xdrs, cpp, LASTUNSIGNED))
     {
diff --git a/sunrpc/xdr_float.c b/sunrpc/xdr_float.c
index 78e8f3b..4ce8ae7 100644
--- a/sunrpc/xdr_float.c
+++ b/sunrpc/xdr_float.c
@@ -80,9 +80,7 @@ static struct sgl_limits {
 #endif /* vax */
 
 bool_t
-xdr_float(xdrs, fp)
-     XDR *xdrs;
-     float *fp;
+xdr_float (XDR *xdrs, float *fp)
 {
 #ifdef vax
 	struct ieee_single is;
@@ -201,9 +199,7 @@ static struct dbl_limits {
 
 
 bool_t
-xdr_double(xdrs, dp)
-     XDR *xdrs;
-     double *dp;
+xdr_double (XDR *xdrs, double *dp)
 {
 #ifdef vax
 	struct	ieee_double id;
diff --git a/sunrpc/xdr_mem.c b/sunrpc/xdr_mem.c
index ba7661a..8b98589 100644
--- a/sunrpc/xdr_mem.c
+++ b/sunrpc/xdr_mem.c
@@ -172,9 +172,7 @@ xdrmem_getpos (const XDR *xdrs)
  * xdrs modified
  */
 static bool_t
-xdrmem_setpos (xdrs, pos)
-     XDR *xdrs;
-     u_int pos;
+xdrmem_setpos (XDR *xdrs, u_int pos)
 {
   caddr_t newaddr = xdrs->x_base + pos;
   caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
diff --git a/sunrpc/xdr_ref.c b/sunrpc/xdr_ref.c
index 8fb4584..a7d9264 100644
--- a/sunrpc/xdr_ref.c
+++ b/sunrpc/xdr_ref.c
@@ -113,11 +113,7 @@ libc_hidden_nolink_sunrpc (xdr_reference, GLIBC_2_0)
  *
  */
 bool_t
-xdr_pointer (xdrs, objpp, obj_size, xdr_obj)
-     XDR *xdrs;
-     char **objpp;
-     u_int obj_size;
-     xdrproc_t xdr_obj;
+xdr_pointer (XDR *xdrs, char **objpp, u_int obj_size, xdrproc_t xdr_obj)
 {
 
   bool_t more_data;
diff --git a/sysvipc/ftok.c b/sysvipc/ftok.c
index 6297459..38fc465 100644
--- a/sysvipc/ftok.c
+++ b/sysvipc/ftok.c
@@ -20,9 +20,7 @@
 #include <sys/stat.h>
 
 key_t
-ftok (pathname, proj_id)
-     const char *pathname;
-     int proj_id;
+ftok (const char *pathname, int proj_id)
 {
   struct stat64 st;
   key_t key;
diff --git a/sysvipc/msgctl.c b/sysvipc/msgctl.c
index c532bd9..e97664a 100644
--- a/sysvipc/msgctl.c
+++ b/sysvipc/msgctl.c
@@ -23,10 +23,7 @@
    objects.  */
 
 int
-msgctl (msqid, cmd, buf)
-     int msqid;
-     int cmd;
-     struct msqid_ds *buf;
+msgctl (int msqid, int cmd, struct msqid_ds *buf)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/msgget.c b/sysvipc/msgget.c
index 0d68701..a1f0ebe 100644
--- a/sysvipc/msgget.c
+++ b/sysvipc/msgget.c
@@ -23,9 +23,7 @@
    parameter describes how to proceed with clashing of key values.  */
 
 int
-msgget (key, msgflg)
-     key_t key;
-     int msgflg;
+msgget (key_t key, int msgflg)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/msgrcv.c b/sysvipc/msgrcv.c
index 1a78f9e..00b869b 100644
--- a/sysvipc/msgrcv.c
+++ b/sysvipc/msgrcv.c
@@ -26,12 +26,7 @@
    in buffer overflow or queue underflow.  */
 
 ssize_t
-msgrcv (msqid, msgp, msgsz, msgtyp, msgflg)
-     int msqid;
-     void *msgp;
-     size_t msgsz;
-     long msgtyp;
-     int msgflg;
+msgrcv (int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/msgsnd.c b/sysvipc/msgsnd.c
index 49eba4b..140b459 100644
--- a/sysvipc/msgsnd.c
+++ b/sysvipc/msgsnd.c
@@ -26,11 +26,7 @@
    when the limit of the message queue length is reached.  */
 
 int
-msgsnd (msqid, msgp, msgsz, msgflg)
-     int msqid;
-     const void *msgp;
-     size_t msgsz;
-     int msgflg;
+msgsnd (int msqid, const void *msgp, size_t msgsz, int msgflg)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/semget.c b/sysvipc/semget.c
index be850cd..e863ec6 100644
--- a/sysvipc/semget.c
+++ b/sysvipc/semget.c
@@ -23,10 +23,7 @@
    KEY.  */
 
 int
-semget (key, nsems, semflg)
-     key_t key;
-     int nsems;
-     int semflg;
+semget (key_t key, int nsems, int semflg)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/semop.c b/sysvipc/semop.c
index 1f03797..da6cc43 100644
--- a/sysvipc/semop.c
+++ b/sysvipc/semop.c
@@ -22,10 +22,7 @@
 /* Perform user-defined atomical operation of array of semaphores.  */
 
 int
-semop (semid, sops, nsops)
-     int semid;
-     struct sembuf *sops;
-     size_t nsops;
+semop (int semid, struct sembuf *sops, size_t nsops)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/shmat.c b/sysvipc/shmat.c
index 30fb015..13b16cd 100644
--- a/sysvipc/shmat.c
+++ b/sysvipc/shmat.c
@@ -24,10 +24,7 @@
    and where the segment is attached.  */
 
 void *
-shmat (shmid, shmaddr, shmflg)
-     int shmid;
-     const void *shmaddr;
-     int shmflg;
+shmat (int shmid, const void *shmaddr, int shmflg)
 {
   __set_errno (ENOSYS);
   return (void *) -1;
diff --git a/sysvipc/shmctl.c b/sysvipc/shmctl.c
index 2c4f198..e56515a 100644
--- a/sysvipc/shmctl.c
+++ b/sysvipc/shmctl.c
@@ -22,10 +22,7 @@
 /* Provide operations to control over shared memory segments.  */
 
 int
-shmctl (shmid, cmd, buf)
-     int shmid;
-     int cmd;
-     struct shmid_ds *buf;
+shmctl (int shmid, int cmd, struct shmid_ds *buf)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/shmdt.c b/sysvipc/shmdt.c
index 660a69b..174d674 100644
--- a/sysvipc/shmdt.c
+++ b/sysvipc/shmdt.c
@@ -23,8 +23,7 @@
    from the caller's data segment.  */
 
 int
-shmdt (shmaddr)
-     const void *shmaddr;
+shmdt (const void *shmaddr)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/sysvipc/shmget.c b/sysvipc/shmget.c
index 973c0c7..a84f8af 100644
--- a/sysvipc/shmget.c
+++ b/sysvipc/shmget.c
@@ -23,10 +23,7 @@
    which is associated with KEY.  */
 
 int
-shmget (key, size, shmflg)
-     key_t key;
-     size_t size;
-     int shmflg;
+shmget (key_t key, size_t size, int shmflg)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/termios/cfmakeraw.c b/termios/cfmakeraw.c
index 035a6d6..0f955a3 100644
--- a/termios/cfmakeraw.c
+++ b/termios/cfmakeraw.c
@@ -19,8 +19,7 @@
 
 /* Set *T to indicate raw mode.  */
 void
-cfmakeraw (t)
-     struct termios *t;
+cfmakeraw (struct termios *t)
 {
   t->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
   t->c_oflag &= ~OPOST;
diff --git a/termios/speed.c b/termios/speed.c
index a6380a9..b3d81c2 100644
--- a/termios/speed.c
+++ b/termios/speed.c
@@ -22,25 +22,21 @@
 
 /* Return the output baud rate stored in *TERMIOS_P.  */
 speed_t
-cfgetospeed (termios_p)
-     const struct termios *termios_p;
+cfgetospeed (const struct termios *termios_p)
 {
   return termios_p->__ospeed;
 }
 
 /* Return the input baud rate stored in *TERMIOS_P.  */
 speed_t
-cfgetispeed (termios_p)
-     const struct termios *termios_p;
+cfgetispeed (const struct termios *termios_p)
 {
   return termios_p->__ispeed;
 }
 
 /* Set the output baud rate stored in *TERMIOS_P to SPEED.  */
 int
-cfsetospeed (termios_p, speed)
-     struct termios *termios_p;
-     speed_t speed;
+cfsetospeed (struct termios *termios_p, speed_t speed)
 {
   if (termios_p == NULL)
     {
@@ -55,9 +51,7 @@ libc_hidden_def (cfsetospeed)
 
 /* Set the input baud rate stored in *TERMIOS_P to SPEED.  */
 int
-cfsetispeed (termios_p, speed)
-     struct termios *termios_p;
-     speed_t speed;
+cfsetispeed (struct termios *termios_p, speed_t speed)
 {
   if (termios_p == NULL)
     {
diff --git a/termios/tcflow.c b/termios/tcflow.c
index a86fe8b..c505b7d 100644
--- a/termios/tcflow.c
+++ b/termios/tcflow.c
@@ -20,9 +20,7 @@
 
 /* Suspend or restart transmission on FD.  */
 int
-tcflow (fd, action)
-     int fd;
-     int action;
+tcflow (int fd, int action)
 {
   if (fd < 0)
     {
diff --git a/termios/tcflush.c b/termios/tcflush.c
index db3c945..4bb085b 100644
--- a/termios/tcflush.c
+++ b/termios/tcflush.c
@@ -20,9 +20,7 @@
 
 /* Flush pending data on FD.  */
 int
-tcflush (fd, queue_selector)
-     int fd;
-     int queue_selector;
+tcflush (int fd, int queue_selector)
 {
   switch (queue_selector)
     {
diff --git a/termios/tcgetattr.c b/termios/tcgetattr.c
index badbb59..b512e68 100644
--- a/termios/tcgetattr.c
+++ b/termios/tcgetattr.c
@@ -21,9 +21,7 @@
 
 /* Put the state of FD into *TERMIOS_P.  */
 int
-__tcgetattr (fd, termios_p)
-     int fd;
-     struct termios *termios_p;
+__tcgetattr (int fd, struct termios *termios_p)
 {
   if (fd < 0)
     {
diff --git a/termios/tcgetpgrp.c b/termios/tcgetpgrp.c
index b1a0547..7101974 100644
--- a/termios/tcgetpgrp.c
+++ b/termios/tcgetpgrp.c
@@ -21,8 +21,7 @@
 
 /* Return the foreground process group ID of FD.  */
 pid_t
-tcgetpgrp (fd)
-     int fd;
+tcgetpgrp (int fd)
 {
   if (fd < 0)
     {
diff --git a/termios/tcgetsid.c b/termios/tcgetsid.c
index fcf4d7f..59e2a7c 100644
--- a/termios/tcgetsid.c
+++ b/termios/tcgetsid.c
@@ -23,8 +23,7 @@
 
 /* Return the session ID of FD.  */
 pid_t
-tcgetsid (fd)
-     int fd;
+tcgetsid (int fd)
 {
   pid_t pgrp;
   pid_t sid;
diff --git a/termios/tcsendbrk.c b/termios/tcsendbrk.c
index abd4d11..ff8b4dd 100644
--- a/termios/tcsendbrk.c
+++ b/termios/tcsendbrk.c
@@ -20,9 +20,7 @@
 
 /* Send zero bits on FD.  */
 int
-tcsendbreak (fd, duration)
-     int fd;
-     int duration;
+tcsendbreak (int fd, int duration)
 {
   if (fd < 0)
     {
diff --git a/termios/tcsetpgrp.c b/termios/tcsetpgrp.c
index e6205c5..cec1e98 100644
--- a/termios/tcsetpgrp.c
+++ b/termios/tcsetpgrp.c
@@ -21,9 +21,7 @@
 
 /* Set the foreground process group ID of FD set PGRP_ID.  */
 int
-tcsetpgrp (fd, pgrp_id)
-     int fd;
-     pid_t pgrp_id;
+tcsetpgrp (int fd, pid_t pgrp_id)
 {
   if (fd < 0)
     {
diff --git a/time/adjtime.c b/time/adjtime.c
index 052931d..436ff04 100644
--- a/time/adjtime.c
+++ b/time/adjtime.c
@@ -23,9 +23,7 @@
    of time adjustment remaining to be done from the last `__adjtime' call.
    This call is restricted to the super-user.  */
 int
-__adjtime (delta, olddelta)
-     const struct timeval *delta;
-     struct timeval *olddelta;
+__adjtime (const struct timeval *delta, struct timeval *olddelta)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/time/dysize.c b/time/dysize.c
index 95b6095..f1b5a08 100644
--- a/time/dysize.c
+++ b/time/dysize.c
@@ -18,8 +18,7 @@
 #include <time.h>
 
 int
-dysize (year)
-     int year;
+dysize (int year)
 {
   return __isleap (year) ? 366 : 365;
 }
diff --git a/time/ftime.c b/time/ftime.c
index 6074672..5f71da8 100644
--- a/time/ftime.c
+++ b/time/ftime.c
@@ -20,8 +20,7 @@
 #include <sys/timeb.h>
 
 int
-ftime (timebuf)
-     struct timeb *timebuf;
+ftime (struct timeb *timebuf)
 {
   int save = errno;
   struct tm tp;
diff --git a/time/getitimer.c b/time/getitimer.c
index e9d2920..c138414 100644
--- a/time/getitimer.c
+++ b/time/getitimer.c
@@ -22,9 +22,7 @@
 /* Set *VALUE to the current setting of timer WHICH.
    Return 0 on success, -1 on errors.  */
 int
-__getitimer (which, value)
-     enum __itimer_which which;
-     struct itimerval *value;
+__getitimer (enum __itimer_which which, struct itimerval *value)
 {
   if (value == NULL)
     {
diff --git a/time/gettimeofday.c b/time/gettimeofday.c
index 399eb60..f120f55 100644
--- a/time/gettimeofday.c
+++ b/time/gettimeofday.c
@@ -22,9 +22,7 @@
    putting it into *TV and *TZ.  If TZ is NULL, *TZ is not filled.
    Returns 0 on success, -1 on errors.  */
 int
-__gettimeofday (tv, tz)
-     struct timeval *tv;
-     struct timezone *tz;
+__gettimeofday (struct timeval *tv, struct timezone *tz)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/time/gmtime.c b/time/gmtime.c
index 60ac207..ae18c8c 100644
--- a/time/gmtime.c
+++ b/time/gmtime.c
@@ -21,9 +21,7 @@
 /* Return the `struct tm' representation of *T in UTC,
    using *TP to store the result.  */
 struct tm *
-__gmtime_r (t, tp)
-     const time_t *t;
-     struct tm *tp;
+__gmtime_r (const time_t *t, struct tm *tp)
 {
   return __tz_convert (t, 0, tp);
 }
@@ -33,8 +31,7 @@ weak_alias (__gmtime_r, gmtime_r)
 
 /* Return the `struct tm' representation of *T in UTC.	*/
 struct tm *
-gmtime (t)
-     const time_t *t;
+gmtime (const time_t *t)
 {
   return __tz_convert (t, 0, &_tmbuf);
 }
diff --git a/time/localtime.c b/time/localtime.c
index 38f3123..14b6854 100644
--- a/time/localtime.c
+++ b/time/localtime.c
@@ -25,9 +25,7 @@ struct tm _tmbuf;
 /* Return the `struct tm' representation of *T in local time,
    using *TP to store the result.  */
 struct tm *
-__localtime_r (t, tp)
-     const time_t *t;
-     struct tm *tp;
+__localtime_r (const time_t *t, struct tm *tp)
 {
   return __tz_convert (t, 1, tp);
 }
@@ -36,8 +34,7 @@ weak_alias (__localtime_r, localtime_r)
 
 /* Return the `struct tm' representation of *T in local time.  */
 struct tm *
-localtime (t)
-     const time_t *t;
+localtime (const time_t *t)
 {
   return __tz_convert (t, 1, &_tmbuf);
 }
diff --git a/time/offtime.c b/time/offtime.c
index a437266..8aaabb2 100644
--- a/time/offtime.c
+++ b/time/offtime.c
@@ -26,10 +26,7 @@
    and store year, yday, mon, mday, wday, hour, min, sec into *TP.
    Return nonzero if successful.  */
 int
-__offtime (t, offset, tp)
-     const time_t *t;
-     long int offset;
-     struct tm *tp;
+__offtime (const time_t *t, long int offset, struct tm *tp)
 {
   time_t days, rem, y;
   const unsigned short int *ip;
diff --git a/time/settimeofday.c b/time/settimeofday.c
index 513e194..d6a632a 100644
--- a/time/settimeofday.c
+++ b/time/settimeofday.c
@@ -21,9 +21,7 @@
 /* Set the current time of day and timezone information.
    This call is restricted to the super-user.  */
 int
-__settimeofday (tv, tz)
-     const struct timeval *tv;
-     const struct timezone *tz;
+__settimeofday (const struct timeval *tv, const struct timezone *tz)
 {
   __set_errno (ENOSYS);
   return -1;
diff --git a/time/stime.c b/time/stime.c
index b86b152..4d65333 100644
--- a/time/stime.c
+++ b/time/stime.c
@@ -22,8 +22,7 @@
 /* Set the system clock to *WHEN.  */
 
 int
-stime (when)
-     const time_t *when;
+stime (const time_t *when)
 {
   if (when == NULL)
     {
diff --git a/time/strftime_l.c b/time/strftime_l.c
index 4eb647c..26829cf 100644
--- a/time/strftime_l.c
+++ b/time/strftime_l.c
@@ -366,9 +366,7 @@ memcpy_uppcase (dest, src, len LOCALE_PARAM)
 # define tm_diff ftime_tm_diff
 static int tm_diff (const struct tm *, const struct tm *) __THROW;
 static int
-tm_diff (a, b)
-     const struct tm *a;
-     const struct tm *b;
+tm_diff (const struct tm *a, const struct tm *b)
 {
   /* Compute intervening leap days correctly even if year is negative.
      Take care to avoid int overflow in leap day calculations,
@@ -403,9 +401,7 @@ static int iso_week_days (int, int) __THROW;
 __inline__
 #endif
 static int
-iso_week_days (yday, wday)
-     int yday;
-     int wday;
+iso_week_days (int yday, int wday)
 {
   /* Add enough to the first operand of % to make it nonnegative.  */
   int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
diff --git a/time/strptime.c b/time/strptime.c
index fb98c62..04e8135 100644
--- a/time/strptime.c
+++ b/time/strptime.c
@@ -27,10 +27,7 @@
 
 
 char *
-strptime (buf, format, tm)
-     const char *buf;
-     const char *format;
-     struct tm *tm;
+strptime (const char *buf, const char *format, struct tm *tm)
 {
   return __strptime_internal (buf, format, tm, NULL, _NL_CURRENT_LOCALE);
 }
diff --git a/time/time.c b/time/time.c
index ee313e3..78f5e0d 100644
--- a/time/time.c
+++ b/time/time.c
@@ -20,8 +20,7 @@
 
 /* Return the time now, and store it in *TIMER if not NULL.  */
 time_t
-time (timer)
-     time_t *timer;
+time (time_t *timer)
 {
   __set_errno (ENOSYS);
 
diff --git a/time/timespec_get.c b/time/timespec_get.c
index 28772d5..a1d169e 100644
--- a/time/timespec_get.c
+++ b/time/timespec_get.c
@@ -20,9 +20,7 @@
 
 /* Set TS to calendar time based in time base BASE.  */
 int
-timespec_get (ts, base)
-     struct timespec *ts;
-     int base;
+timespec_get (struct timespec *ts, int base)
 {
   switch (base)
     {
diff --git a/time/tzset.c b/time/tzset.c
index 01b76b4..ee255f4 100644
--- a/time/tzset.c
+++ b/time/tzset.c
@@ -394,9 +394,7 @@ __tzset_parse_tz (const char *tz)
 /* Interpret the TZ envariable.  */
 static void
 internal_function
-tzset_internal (always, explicit)
-     int always;
-     int explicit;
+tzset_internal (int always, int explicit)
 {
   static int is_initialized;
   const char *tz;
@@ -466,9 +464,7 @@ tzset_internal (always, explicit)
    put it in RULE->change, saving YEAR in RULE->computed_for.  */
 static void
 internal_function
-compute_change (rule, year)
-     tz_rule *rule;
-     int year;
+compute_change (tz_rule *rule, int year)
 {
   time_t t;
 
@@ -557,10 +553,7 @@ compute_change (rule, year)
    `__timezone', and `__daylight' accordingly.  */
 void
 internal_function
-__tz_compute (timer, tm, use_localtime)
-     time_t timer;
-     struct tm *tm;
-     int use_localtime;
+__tz_compute (time_t timer, struct tm *tm, int use_localtime)
 {
   compute_change (&tz_rules[0], 1900 + tm->tm_year);
   compute_change (&tz_rules[1], 1900 + tm->tm_year);
diff --git a/wcsmbs/btowc.c b/wcsmbs/btowc.c
index 9bb03f3..fe27f34 100644
--- a/wcsmbs/btowc.c
+++ b/wcsmbs/btowc.c
@@ -29,8 +29,7 @@
 
 
 wint_t
-__btowc (c)
-     int c;
+__btowc (int c)
 {
   const struct gconv_fcts *fcts;
 
diff --git a/wcsmbs/mbrlen.c b/wcsmbs/mbrlen.c
index 25f6f45..8464266 100644
--- a/wcsmbs/mbrlen.c
+++ b/wcsmbs/mbrlen.c
@@ -24,10 +24,7 @@ static mbstate_t internal;
 
 
 size_t
-__mbrlen (s, n, ps)
-     const char *s;
-     size_t n;
-     mbstate_t *ps;
+__mbrlen (const char *s, size_t n, mbstate_t *ps)
 {
   return __mbrtowc (NULL, s, n, ps ?: &internal);
 }
diff --git a/wcsmbs/mbsinit.c b/wcsmbs/mbsinit.c
index 4e33734..79323b5 100644
--- a/wcsmbs/mbsinit.c
+++ b/wcsmbs/mbsinit.c
@@ -31,8 +31,7 @@
    value collected so far.  Especially, we don't have different shift
    states.  */
 int
-__mbsinit (ps)
-     const mbstate_t *ps;
+__mbsinit (const mbstate_t *ps)
 {
   return ps == NULL || ps->__count == 0;
 }
diff --git a/wcsmbs/mbsrtowcs.c b/wcsmbs/mbsrtowcs.c
index 7e468b6..e256638 100644
--- a/wcsmbs/mbsrtowcs.c
+++ b/wcsmbs/mbsrtowcs.c
@@ -24,11 +24,7 @@
 static mbstate_t state;
 
 size_t
-__mbsrtowcs (dst, src, len, ps)
-     wchar_t *dst;
-     const char **src;
-     size_t len;
-     mbstate_t *ps;
+__mbsrtowcs (wchar_t *dst, const char **src, size_t len, mbstate_t *ps)
 {
   return __mbsrtowcs_l (dst, src, len, ps ?: &state, _NL_CURRENT_LOCALE);
 }
diff --git a/wcsmbs/wcpcpy.c b/wcsmbs/wcpcpy.c
index 0c8ded3..a4bcfc5 100644
--- a/wcsmbs/wcpcpy.c
+++ b/wcsmbs/wcpcpy.c
@@ -27,9 +27,7 @@
 /* Copy SRC to DEST, returning the address of the terminating L'\0' in
    DEST.  */
 wchar_t *
-__wcpcpy (dest, src)
-     wchar_t *dest;
-     const wchar_t *src;
+__wcpcpy (wchar_t *dest, const wchar_t *src)
 {
   wchar_t *wcp = (wchar_t *) dest - 1;
   wint_t c;
diff --git a/wcsmbs/wcpncpy.c b/wcsmbs/wcpncpy.c
index e19e44c..2f14090 100644
--- a/wcsmbs/wcpncpy.c
+++ b/wcsmbs/wcpncpy.c
@@ -25,10 +25,7 @@
 /* Copy no more than N wide-characters of SRC to DEST, returning the
    address of the last character written into DEST.  */
 wchar_t *
-__wcpncpy (dest, src, n)
-     wchar_t *dest;
-     const wchar_t *src;
-     size_t n;
+__wcpncpy (wchar_t *dest, const wchar_t *src, size_t n)
 {
   wint_t c;
   wchar_t *const s = dest;
diff --git a/wcsmbs/wcscat.c b/wcsmbs/wcscat.c
index b0f0873..129f7da 100644
--- a/wcsmbs/wcscat.c
+++ b/wcsmbs/wcscat.c
@@ -24,9 +24,7 @@
 
 /* Append SRC on the end of DEST.  */
 wchar_t *
-__wcscat (dest, src)
-     wchar_t *dest;
-     const wchar_t *src;
+__wcscat (wchar_t *dest, const wchar_t *src)
 {
   wchar_t *s1 = dest;
   const wchar_t *s2 = src;
diff --git a/wcsmbs/wcschrnul.c b/wcsmbs/wcschrnul.c
index 97ef3b9..418725f 100644
--- a/wcsmbs/wcschrnul.c
+++ b/wcsmbs/wcschrnul.c
@@ -23,9 +23,7 @@
 
 /* Find the first occurrence of WC in WCS.  */
 wchar_t *
-__wcschrnul (wcs, wc)
-     const wchar_t *wcs;
-     const wchar_t wc;
+__wcschrnul (const wchar_t *wcs, const wchar_t wc)
 {
   while (*wcs != L'\0')
     if (*wcs == wc)
diff --git a/wcsmbs/wcscmp.c b/wcsmbs/wcscmp.c
index fcfe0c5..897ac35 100644
--- a/wcsmbs/wcscmp.c
+++ b/wcsmbs/wcscmp.c
@@ -26,9 +26,7 @@
    greater than zero if S1 is lexicographically less than,
    equal to or greater than S2.	 */
 int
-WCSCMP (s1, s2)
-     const wchar_t *s1;
-     const wchar_t *s2;
+WCSCMP (const wchar_t *s1, const wchar_t *s2)
 {
   wchar_t c1, c2;
 
diff --git a/wcsmbs/wcscpy.c b/wcsmbs/wcscpy.c
index 56e8fc1..aa3a313 100644
--- a/wcsmbs/wcscpy.c
+++ b/wcsmbs/wcscpy.c
@@ -26,9 +26,7 @@
 
 /* Copy SRC to DEST.  */
 wchar_t *
-WCSCPY (dest, src)
-     wchar_t *dest;
-     const wchar_t *src;
+WCSCPY (wchar_t *dest, const wchar_t *src)
 {
   wint_t c;
   wchar_t *wcp;
diff --git a/wcsmbs/wcscspn.c b/wcsmbs/wcscspn.c
index d735f8c..fb21a41 100644
--- a/wcsmbs/wcscspn.c
+++ b/wcsmbs/wcscspn.c
@@ -25,9 +25,7 @@
 /* Return the length of the maximum initial segment
    of WCS which contains only wide-characters not in REJECT.  */
 size_t
-wcscspn (wcs, reject)
-     const wchar_t *wcs;
-     const wchar_t *reject;
+wcscspn (const wchar_t *wcs, const wchar_t *reject)
 {
   size_t count = 0;
 
diff --git a/wcsmbs/wcsdup.c b/wcsmbs/wcsdup.c
index 58c2c52..eb806e3 100644
--- a/wcsmbs/wcsdup.c
+++ b/wcsmbs/wcsdup.c
@@ -23,8 +23,7 @@
 
 /* Duplicate S, returning an identical malloc'd string.	 */
 wchar_t *
-wcsdup (s)
-     const wchar_t *s;
+wcsdup (const wchar_t *s)
 {
   size_t len = (__wcslen (s) + 1) * sizeof (wchar_t);
   void *new = malloc (len);
diff --git a/wcsmbs/wcslen.c b/wcsmbs/wcslen.c
index e076721..94eda2b 100644
--- a/wcsmbs/wcslen.c
+++ b/wcsmbs/wcslen.c
@@ -24,8 +24,7 @@
 #endif
 
 size_t
-__wcslen (s)
-     const wchar_t *s;
+__wcslen (const wchar_t *s)
 {
   size_t len = 0;
 
diff --git a/wcsmbs/wcsncat.c b/wcsmbs/wcsncat.c
index 78fe765..3ab8853 100644
--- a/wcsmbs/wcsncat.c
+++ b/wcsmbs/wcsncat.c
@@ -24,10 +24,7 @@
 
 /* Append no more than N wide-character of SRC onto DEST.  */
 wchar_t *
-WCSNCAT (dest, src, n)
-     wchar_t *dest;
-     const wchar_t *src;
-     size_t n;
+WCSNCAT (wchar_t *dest, const wchar_t *src, size_t n)
 {
   wchar_t c;
   wchar_t * const s = dest;
diff --git a/wcsmbs/wcsncmp.c b/wcsmbs/wcsncmp.c
index 4de2ca8..73f054b 100644
--- a/wcsmbs/wcsncmp.c
+++ b/wcsmbs/wcsncmp.c
@@ -27,10 +27,7 @@
    if S1 is lexicographically less than, equal to or
    greater than S2.  */
 int
-WCSNCMP (s1, s2, n)
-     const wchar_t *s1;
-     const wchar_t *s2;
-     size_t n;
+WCSNCMP (const wchar_t *s1, const wchar_t *s2, size_t n)
 {
   wchar_t c1 = L'\0';
   wchar_t c2 = L'\0';
diff --git a/wcsmbs/wcsncpy.c b/wcsmbs/wcsncpy.c
index 5ee5ee6..306c52b 100644
--- a/wcsmbs/wcsncpy.c
+++ b/wcsmbs/wcsncpy.c
@@ -24,10 +24,7 @@
 
 /* Copy no more than N wide-characters of SRC to DEST.	*/
 wchar_t *
-__wcsncpy (dest, src, n)
-     wchar_t *dest;
-     const wchar_t *src;
-     size_t n;
+__wcsncpy (wchar_t *dest, const wchar_t *src, size_t n)
 {
   wint_t c;
   wchar_t *const s = dest;
diff --git a/wcsmbs/wcsnlen.c b/wcsmbs/wcsnlen.c
index e928ab6..2d8380f 100644
--- a/wcsmbs/wcsnlen.c
+++ b/wcsmbs/wcsnlen.c
@@ -24,9 +24,7 @@
 
 /* Return length of string S at most maxlen.  */
 size_t
-__wcsnlen (s, maxlen)
-     const wchar_t *s;
-     size_t maxlen;
+__wcsnlen (const wchar_t *s, size_t maxlen)
 {
   size_t len = 0;
 
diff --git a/wcsmbs/wcspbrk.c b/wcsmbs/wcspbrk.c
index 9bb43d6..81391b7 100644
--- a/wcsmbs/wcspbrk.c
+++ b/wcsmbs/wcspbrk.c
@@ -24,9 +24,7 @@
 
 /* Find the first occurrence in WCS of any wide-character in ACCEPT.  */
 wchar_t *
-wcspbrk (wcs, accept)
-     const wchar_t *wcs;
-     const wchar_t *accept;
+wcspbrk (const wchar_t *wcs, const wchar_t *accept)
 {
   while (*wcs != L'\0')
     if (wcschr (accept, *wcs) == NULL)
diff --git a/wcsmbs/wcsrchr.c b/wcsmbs/wcsrchr.c
index 72b04fb..32033be 100644
--- a/wcsmbs/wcsrchr.c
+++ b/wcsmbs/wcsrchr.c
@@ -24,9 +24,7 @@
 
 /* Find the last occurrence of WC in WCS.  */
 wchar_t *
-WCSRCHR (wcs, wc)
-     const wchar_t *wcs;
-     const wchar_t wc;
+WCSRCHR (const wchar_t *wcs, const wchar_t wc)
 {
   const wchar_t *retval = NULL;
 
diff --git a/wcsmbs/wcsspn.c b/wcsmbs/wcsspn.c
index 7a3cdf7..332b6a6 100644
--- a/wcsmbs/wcsspn.c
+++ b/wcsmbs/wcsspn.c
@@ -25,9 +25,7 @@
 /* Return the length of the maximum initial segment
    of WCS which contains only wide-characters in ACCEPT.  */
 size_t
-wcsspn (wcs, accept)
-     const wchar_t *wcs;
-     const wchar_t *accept;
+wcsspn (const wchar_t *wcs, const wchar_t *accept)
 {
   const wchar_t *p;
   const wchar_t *a;
diff --git a/wcsmbs/wcsstr.c b/wcsmbs/wcsstr.c
index a62c29e..4fbc7ea 100644
--- a/wcsmbs/wcsstr.c
+++ b/wcsmbs/wcsstr.c
@@ -29,9 +29,7 @@
 #include <wchar.h>
 
 wchar_t *
-wcsstr (haystack, needle)
-     const wchar_t *haystack;
-     const wchar_t *needle;
+wcsstr (const wchar_t *haystack, const wchar_t *needle)
 {
   wchar_t b, c;
 
diff --git a/wcsmbs/wcstok.c b/wcsmbs/wcstok.c
index 7361017..47a7fd8 100644
--- a/wcsmbs/wcstok.c
+++ b/wcsmbs/wcstok.c
@@ -23,10 +23,7 @@
 /* Parse WCS into tokens separated by characters in DELIM.  If WCS is
    NULL, the last string wcstok() was called with is used.  */
 wchar_t *
-wcstok (wcs, delim, save_ptr)
-     wchar_t *wcs;
-     const wchar_t *delim;
-     wchar_t **save_ptr;
+wcstok (wchar_t *wcs, const wchar_t *delim, wchar_t **save_ptr)
 {
   wchar_t *result;
 
diff --git a/wcsmbs/wctob.c b/wcsmbs/wctob.c
index 035f045..08d6a42 100644
--- a/wcsmbs/wctob.c
+++ b/wcsmbs/wctob.c
@@ -27,8 +27,7 @@
 
 
 int
-wctob (c)
-     wint_t c;
+wctob (wint_t c)
 {
   unsigned char buf[MB_LEN_MAX];
   struct __gconv_step_data data;
diff --git a/wcsmbs/wmemchr.c b/wcsmbs/wmemchr.c
index 9e8d57b..364a95d 100644
--- a/wcsmbs/wmemchr.c
+++ b/wcsmbs/wmemchr.c
@@ -23,10 +23,7 @@
 #endif
 
 wchar_t *
-__wmemchr (s, c, n)
-     const wchar_t *s;
-     wchar_t c;
-     size_t n;
+__wmemchr (const wchar_t *s, wchar_t c, size_t n)
 {
   /* For performance reasons unfold the loop four times.  */
   while (n >= 4)
diff --git a/wcsmbs/wmemcmp.c b/wcsmbs/wmemcmp.c
index 5aa934c..76a1ccc 100644
--- a/wcsmbs/wmemcmp.c
+++ b/wcsmbs/wmemcmp.c
@@ -23,10 +23,7 @@
 #endif
 
 int
-WMEMCMP (s1, s2, n)
-     const wchar_t *s1;
-     const wchar_t *s2;
-     size_t n;
+WMEMCMP (const wchar_t *s1, const wchar_t *s2, size_t n)
 {
   wchar_t c1;
   wchar_t c2;
diff --git a/wcsmbs/wmemcpy.c b/wcsmbs/wmemcpy.c
index 0b75be7..c6f6401 100644
--- a/wcsmbs/wmemcpy.c
+++ b/wcsmbs/wmemcpy.c
@@ -21,10 +21,7 @@
 
 
 wchar_t *
-__wmemcpy (s1, s2, n)
-     wchar_t *s1;
-     const wchar_t *s2;
-     size_t n;
+__wmemcpy (wchar_t *s1, const wchar_t *s2, size_t n)
 {
   return (wchar_t *) memcpy ((char *) s1, (char *) s2, n * sizeof (wchar_t));
 }
diff --git a/wcsmbs/wmemmove.c b/wcsmbs/wmemmove.c
index 68878fa..8a8d920 100644
--- a/wcsmbs/wmemmove.c
+++ b/wcsmbs/wmemmove.c
@@ -21,10 +21,7 @@
 
 
 wchar_t *
-__wmemmove (s1, s2, n)
-     wchar_t *s1;
-     const wchar_t *s2;
-     size_t n;
+__wmemmove (wchar_t *s1, const wchar_t *s2, size_t n)
 {
   return (wchar_t *) memmove ((char *) s1, (char *) s2, n * sizeof (wchar_t));
 }
diff --git a/wcsmbs/wmempcpy.c b/wcsmbs/wmempcpy.c
index 9639c5f..dd09cd6 100644
--- a/wcsmbs/wmempcpy.c
+++ b/wcsmbs/wmempcpy.c
@@ -21,10 +21,7 @@
 
 
 wchar_t *
-__wmempcpy (s1, s2, n)
-     wchar_t *s1;
-     const wchar_t *s2;
-     size_t n;
+__wmempcpy (wchar_t *s1, const wchar_t *s2, size_t n)
 {
   return (wchar_t *) __mempcpy ((char *) s1, (char *) s2,
 				n * sizeof (wchar_t));
diff --git a/wcsmbs/wmemset.c b/wcsmbs/wmemset.c
index 1eb6b2b..f5a9b08 100644
--- a/wcsmbs/wmemset.c
+++ b/wcsmbs/wmemset.c
@@ -23,10 +23,7 @@
 #endif
 
 wchar_t *
-__wmemset (s, c, n)
-     wchar_t *s;
-     wchar_t c;
-     size_t n;
+__wmemset (wchar_t *s, wchar_t c, size_t n)
 {
   wchar_t *wp = s;
 
diff --git a/wctype/wcfuncs.c b/wctype/wcfuncs.c
index e7c0308..6037ca6 100644
--- a/wctype/wcfuncs.c
+++ b/wctype/wcfuncs.c
@@ -71,8 +71,7 @@ libc_hidden_weak (iswxdigit)
 
 #undef towlower
 wint_t
-__towlower (wc)
-     wint_t wc;
+__towlower (wint_t wc)
 {
   size_t i = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_OFFSET) + __TOW_tolower;
   const char *desc = _NL_CURRENT (LC_CTYPE, i);
@@ -84,8 +83,7 @@ libc_hidden_weak (towlower)
 
 #undef towupper
 wint_t
-__towupper (wc)
-     wint_t wc;
+__towupper (wint_t wc)
 {
   size_t i = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_OFFSET) + __TOW_toupper;
   const char *desc = _NL_CURRENT (LC_CTYPE, i);