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.
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");
good_bye();
}
void
-get8(cp)
-char *cp;
+get8 (char *cp)
{
int i,j,t;
}
}
void
-put8(cp)
-char *cp;
+put8 (char *cp)
{
int i,j,t;
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. */
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);
}
#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;
}
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;
*/
void
-_ufc_clearmem(start, cnt)
- char *start;
- int cnt;
+_ufc_clearmem (char *start, int cnt)
{
while(cnt--)
*start++ = '\0';
*/
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;
#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;
#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;
*/
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;
}
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;
*/
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;
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);
}
*/
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;
weak_alias (__setkey_r, setkey_r)
void
-setkey(__key)
- const char *__key;
+setkey (const char *__key)
{
__setkey_r(__key, &_ufc_foobar);
}
/* 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;
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);
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;
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
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;
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. */
/* 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;
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;
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. */
/* 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);
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;
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. */
#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);
#endif
int
-__backtrace (array, size)
- void **array;
- int size;
+__backtrace (void **array, int size)
{
struct layout *current;
void *top_frame;
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;
#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;
#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;
#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 ();
#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 ();
#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 ();
#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 ();
/* 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;
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;
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 ();
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. */
#include <errno.h>
int
-dirfd (dirp)
- DIR *dirp;
+dirfd (DIR *dirp)
{
__set_errno (ENOSYS);
return -1;
#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;
#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;
/* Rewind DIRP to the beginning of the directory. */
void
-__rewinddir (dirp)
- DIR *dirp;
+__rewinddir (DIR *dirp)
{
__set_errno (ENOSYS);
/* No way to indicate failure. */
/* Seek to position POS in DIRP. */
void
-seekdir (dirp, pos)
- DIR *dirp;
- long int pos;
+seekdir (DIR *dirp, long int pos)
{
if (dirp == NULL)
{
/* Return the current position of DIRP. */
long int
-telldir (dirp)
- DIR *dirp;
+telldir (DIR *dirp)
{
if (dirp == NULL)
{
}
static int
-makesymlinks (file)
- const char *file;
+makesymlinks (const char *file)
{
#ifndef PATH_MAX
#define PATH_MAX 4095
}
static int
-makesymlink (src, dest)
- const char *src;
- const char *dest;
+makesymlink (const char *src, const char *dest)
{
struct stat stats;
const char *error;
* all the data structures are ready.
*/
void
-__moncontrol (mode)
- int mode;
+__moncontrol (int mode)
{
struct gmonparam *p = &_gmonparam;
void
-__monstartup (lowpc, highpc)
- u_long lowpc;
- u_long highpc;
+__monstartup (u_long lowpc, u_long highpc)
{
int o;
char *cp;
static void
internal_function
-write_hist (fd)
- int fd;
+write_hist (int fd)
{
u_char tag = GMON_TAG_TIME_HIST;
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;
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;
/* 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;
* 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);
* 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;
* 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);
}
int
-rresvport_af(alport, family)
- int *alport;
- sa_family_t family;
+rresvport_af (int *alport, sa_family_t family)
{
union {
struct sockaddr generic;
libc_hidden_def (rresvport_af)
int
-rresvport(alport)
- int *alport;
+rresvport (int *alport)
{
return rresvport_af(alport, AF_INET);
}
/* 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)
{
/* Change the current directory to PATH. */
int
-__chdir (path)
- const char *path;
+__chdir (const char *path)
{
if (path == NULL)
{
/* 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)
{
/* 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)
{
/* Close the file descriptor FD. */
int
-__close (fd)
- int fd;
+__close (int fd)
{
if (fd < 0)
{
/* 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);
}
/* 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);
}
/* 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;
/* 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)
{
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)
{
#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)
{
#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)
/* 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)
{
#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)
{
/* 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)
{
/* 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)
{
/* Perform file control operations on FD. */
int
-__fcntl (fd, cmd)
- int fd;
- int cmd;
+__fcntl (int fd, int cmd)
{
if (fd < 0)
{
/* 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;
static void
internal_function
-fts_load(sp, p)
- FTS *sp;
- FTSENT *p;
+fts_load (FTS *sp, FTSENT *p)
{
int len;
char *cp;
}
int
-fts_close(sp)
- FTS *sp;
+fts_close (FTS *sp)
{
FTSENT *freep, *p;
int saved_errno;
? p->fts_pathlen - 1 : p->fts_pathlen)
FTSENT *
-fts_read(sp)
- FTS *sp;
+fts_read (FTS *sp)
{
FTSENT *p, *tmp;
int instr;
*/
/* 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) {
}
FTSENT *
-fts_children(sp, instr)
- FTS *sp;
- int instr;
+fts_children (FTS *sp, int instr)
{
FTSENT *p;
int fd;
*/
static FTSENT *
internal_function
-fts_build(sp, type)
- FTS *sp;
- int type;
+fts_build (FTS *sp, int type)
{
struct dirent *dp;
FTSENT *p, *head;
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;
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;
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;
static void
internal_function
-fts_lfree(head)
- FTSENT *head;
+fts_lfree (FTSENT *head)
{
FTSENT *p;
*/
static int
internal_function
-fts_palloc(sp, more)
- FTS *sp;
- size_t more;
+fts_palloc (FTS *sp, size_t more)
{
char *p;
*/
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;
static size_t
internal_function
-fts_maxarglen(argv)
- char * const *argv;
+fts_maxarglen (char * const *argv)
{
size_t len, max;
*/
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;
char *
-getwd (buf)
- char *buf;
+getwd (char *buf)
{
#ifndef PATH_MAX
#define PATH_MAX 1024
/* Return 1 if FD is a terminal, 0 if not. */
int
-__isatty (fd)
- int fd;
+__isatty (int fd)
{
__set_errno (ENOSYS);
return -1;
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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)
{
/* 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;
/* 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;
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;
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)
{
/* Remove the directory PATH. */
int
-__rmdir (path)
- const char *path;
+__rmdir (const char *path)
{
if (path == NULL)
{
/* 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)
{
/* 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)
{
/* 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;
/* 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;
/* 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;
/* Remove the link named NAME. */
int
-__unlink (name)
- const char *name;
+__unlink (const char *name)
{
if (name == NULL)
{
/* 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)
{
/* 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)
{
#include "stdio.h"
void
-clearerr (fp)
- FILE *fp;
+clearerr (FILE *fp)
{
CHECK_FILE (fp, /*nothing*/);
_IO_flockfile (fp);
#include "stdio.h"
void
-clearerr_unlocked (fp)
- FILE *fp;
+clearerr_unlocked (FILE *fp)
{
CHECK_FILE (fp, /*nothing*/);
_IO_clearerr (fp);
#include "stdio.h"
int
-_IO_feof (fp)
- _IO_FILE* fp;
+_IO_feof (_IO_FILE *fp)
{
int result;
CHECK_FILE (fp, EOF);
#undef feof_unlocked
int
-feof_unlocked (fp)
- _IO_FILE* fp;
+feof_unlocked (_IO_FILE *fp)
{
CHECK_FILE (fp, EOF);
return _IO_feof_unlocked (fp);
#include "stdio.h"
int
-_IO_ferror (fp)
- _IO_FILE* fp;
+_IO_ferror (_IO_FILE *fp)
{
int result;
CHECK_FILE (fp, EOF);
#undef ferror_unlocked
int
-ferror_unlocked (fp)
- _IO_FILE* fp;
+ferror_unlocked (_IO_FILE *fp)
{
CHECK_FILE (fp, EOF);
return _IO_ferror_unlocked (fp);
*/
int
-_IO_file_doallocate (fp)
- _IO_FILE *fp;
+_IO_file_doallocate (_IO_FILE *fp)
{
_IO_size_t size;
char *p;
#include <stdio.h>
int
-__fileno (fp)
- _IO_FILE* fp;
+__fileno (_IO_FILE *fp)
{
CHECK_FILE (fp, EOF);
#include "stdio.h"
int
-fputc (c, fp)
- int c;
- _IO_FILE *fp;
+fputc (int c, _IO_FILE *fp)
{
int result;
CHECK_FILE (fp, EOF);
#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);
#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);
#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)
#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);
#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);
#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);
#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);
#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);
off_t
-__ftello (fp)
- _IO_FILE *fp;
+__ftello (_IO_FILE *fp)
{
_IO_off64_t pos;
CHECK_FILE (fp, -1L);
#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);
#include <wchar.h>
int
-fwide (fp, mode)
- _IO_FILE *fp;
- int mode;
+fwide (_IO_FILE *fp, int mode)
{
int result;
#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)
{
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)
{
_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;
/* 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;
/* 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;
}
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)
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. */
#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;
#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)
}
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)
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)
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);
libc_hidden_def (_IO_setb)
void
-_IO_doallocbuf (fp)
- _IO_FILE *fp;
+_IO_doallocbuf (_IO_FILE *fp)
{
if (fp->_IO_buf_base)
return;
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)
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;
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);
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;
#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;
}
_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;
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;
}
int
-_IO_default_sync (fp)
- _IO_FILE *fp;
+_IO_default_sync (_IO_FILE *fp)
{
return 0;
}
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))
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;
libc_hidden_def (_IO_sputbackc)
int
-_IO_sungetc (fp)
- _IO_FILE *fp;
+_IO_sungetc (_IO_FILE *fp)
{
int result;
/* 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;
}
#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;
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)
#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,
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))
}
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;
#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)
}
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;
}
void
-_IO_unsave_markers (fp)
- _IO_FILE *fp;
+_IO_unsave_markers (_IO_FILE *fp)
{
struct _IO_marker *mark = fp->_markers;
if (mark)
#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--;
#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)
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)
{
}
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;
}
#undef _IO_getc
int
-_IO_getc (fp)
- FILE *fp;
+_IO_getc (FILE *fp)
{
int result;
CHECK_FILE (fp, EOF);
#undef _IO_getwc
wint_t
-_IO_getwc (fp)
- FILE *fp;
+_IO_getwc (FILE *fp)
{
wint_t result;
CHECK_FILE (fp, WEOF);
#endif
int
-_IO_new_fclose (fp)
- _IO_FILE *fp;
+_IO_new_fclose (_IO_FILE *fp)
{
int status;
#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
#include <stdio.h>
int
-_IO_fflush (fp)
- _IO_FILE *fp;
+_IO_fflush (_IO_FILE *fp)
{
if (fp == NULL)
return _IO_flush_all ();
#include <stdio.h>
int
-__fflush_unlocked (fp)
- _IO_FILE *fp;
+__fflush_unlocked (_IO_FILE *fp)
{
if (fp == NULL)
return _IO_flush_all ();
#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;
#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;
#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;
#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;
#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;
#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;
#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);
}
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;
}
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;
}
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;
}
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;
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. */
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);
#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;
#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;
#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;
#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;
#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;
#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;
#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);
#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);
/* 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);
#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;
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;
#include "libioP.h"
#include <limits.h>
-char*
-_IO_gets (buf)
- char *buf;
+char *
+_IO_gets (char *buf)
{
_IO_size_t count;
int ch;
{'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;
#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;
}
_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
{
}
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;
#include <limits.h>
int
-_IO_puts (str)
- const char *str;
+_IO_puts (const char *str)
{
int result = EOF;
_IO_size_t len = strlen (str);
#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)
{
_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;
#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.
_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;
#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);
#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);
#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);
#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);
#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;
#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;
};
_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;
/* 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. */
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
{
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;
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;
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
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))
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))
{
_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;
_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;
_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;
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;
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)
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
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 */
{
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;
_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;
_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)
_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;
int
attribute_compat_text_section
-_IO_old_fclose (fp)
- _IO_FILE *fp;
+_IO_old_fclose (_IO_FILE *fp)
{
int status;
_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;
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);
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);
_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
{
#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);
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);
_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;
_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
{
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;
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,
#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,
#undef _IO_peekc
int
-_IO_peekc_locked (fp)
- _IO_FILE *fp;
+_IO_peekc_locked (_IO_FILE *fp)
{
int result;
CHECK_FILE (fp, EOF);
#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);
#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);
#undef putchar
int
-putchar (c)
- int c;
+putchar (int c)
{
int result;
_IO_acquire_lock (_IO_stdout);
#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);
#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);
#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);
#include <wchar.h>
wint_t
-putwchar (wc)
- wchar_t wc;
+putwchar (wchar_t wc)
{
wint_t result;
_IO_acquire_lock (_IO_stdout);
#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);
#include <stdio.h>
void
-rewind (fp)
- _IO_FILE *fp;
+rewind (_IO_FILE *fp)
{
CHECK_FILE (fp, );
_IO_acquire_lock (fp);
#include "stdio.h"
void
-setbuf (fp, buf)
- _IO_FILE *fp;
- char *buf;
+setbuf (_IO_FILE *fp, char *buf)
{
_IO_setbuffer (fp, buf, _IO_BUFSIZ);
}
#undef setlinebuf
void
-setlinebuf (stream)
- _IO_FILE *stream;
+setlinebuf (_IO_FILE *stream)
{
_IO_setvbuf (stream, NULL, 1, 0);
}
#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. */
#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);
}
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
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
*/
int
-_IO_wfile_doallocate (fp)
- _IO_FILE *fp;
+_IO_wfile_doallocate (_IO_FILE *fp)
{
_IO_size_t size;
wchar_t *p;
/* 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;
/* 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;
/* 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;
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);
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)
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))
wint_t
-_IO_wdefault_uflow (fp)
- _IO_FILE *fp;
+_IO_wdefault_uflow (_IO_FILE *fp)
{
wint_t wch;
wch = _IO_UNDERFLOW (fp);
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);
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;
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;
_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;
_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;
void
-_IO_wdoallocbuf (fp)
- _IO_FILE *fp;
+_IO_wdoallocbuf (_IO_FILE *fp)
{
if (fp->_wide_data->_IO_buf_base)
return;
int
-_IO_wdefault_doallocate (fp)
- _IO_FILE *fp;
+_IO_wdefault_doallocate (_IO_FILE *fp)
{
wchar_t *buf;
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)
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. */
#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;
}
wint_t
-_IO_sputbackwc (fp, c)
- _IO_FILE *fp;
- wint_t c;
+_IO_sputbackwc (_IO_FILE *fp, wint_t c)
{
wint_t result;
libc_hidden_def (_IO_sputbackwc)
wint_t
-_IO_sungetwc (fp)
- _IO_FILE *fp;
+_IO_sungetwc (_IO_FILE *fp)
{
wint_t result;
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)
}
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))
/* 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)
}
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;
}
void
-_IO_unsave_wmarkers (fp)
- _IO_FILE *fp;
+_IO_unsave_wmarkers (_IO_FILE *fp)
{
struct _IO_marker *mark = fp->_markers;
if (mark)
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
{
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;
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;
/* 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);
}
/* 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);
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);
int
-delete_hash (htab)
- hash_table *htab;
+delete_hash (hash_table *htab)
{
free (htab->table);
obstack_free (&htab->mem_pool, NULL);
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;
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));
unsigned long int
-next_prime (seed)
- unsigned long int seed;
+next_prime (unsigned long int seed)
{
/* Make it definitely odd. */
seed |= 1;
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;
int xmalloc_exit_failure = EXIT_FAILURE;
static VOID *
-fixup_null_alloc (n)
- size_t n;
+fixup_null_alloc (size_t n)
{
VOID *p;
/* Allocate N bytes of memory dynamically, with error checking. */
VOID *
-xmalloc (n)
- size_t n;
+xmalloc (size_t n)
{
VOID *p;
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);
/* Return a newly allocated copy of STRING. */
char *
-xstrdup (string)
- char *string;
+xstrdup (char *string)
{
return strcpy (xmalloc (strlen (string) + 1), string);
}
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;
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;
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;
/* 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;
#include <utmp.h>
int
-login_tty(fd)
- int fd;
+login_tty (int fd)
{
(void) setsid();
#ifdef TIOCSCTTY
/* Set the login name returned by `getlogin'. */
int
-setlogin (name)
- const char *name;
+setlogin (const char *name)
{
__set_errno (ENOSYS);
return -1;
*/
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;
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:
}
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);
# 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--)
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;
/* 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;
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)
{
/* 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;
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)
{
struct fstab *
-getfsspec (name)
- const char *name;
+getfsspec (const char *name)
{
struct fstab_state *state;
struct mntent *m;
struct fstab *
-getfsfile (name)
- const char *name;
+getfsfile (const char *name)
{
struct fstab_state *state;
struct mntent *m;
/* Make all changes done to FD actually appear on disk. */
int
-fsync (fd)
- int fd;
+fsync (int fd)
{
__set_errno (ENOSYS);
return -1;
/* 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;
/* 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)
{
/* 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;
#else
int
-getdomainname (name, len)
- char *name;
- size_t len;
+getdomainname (char *name, size_t len)
{
__set_errno (ENOSYS);
return -1;
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;
}
char *
-getpass (prompt)
- const char *prompt;
+getpass (const char *prompt)
{
FILE *in, *out;
struct termios s, t;
*/
static char *
internal_function
-skip(p)
- char *p;
+skip (char *p)
{
char *t;
int c, q;
static char *
internal_function
-value(p)
- char *p;
+value (char *p)
{
return ((p = index(p, '=')) ? ++p : NULL);
/* 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)
{
/* Define the non-reentrant function using the reentrant counterparts. */
ENTRY *
-hsearch (item, action)
- ENTRY item;
- ACTION action;
+hsearch (ENTRY item, ACTION action)
{
ENTRY *result;
int
-hcreate (nel)
- size_t nel;
+hcreate (size_t nel)
{
return __hcreate_r (nel, &htab);
}
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)
/* 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)
/* 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;
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;
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);
}
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);
}
"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)
{
"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)
{
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);
}
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);
}
"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)
{
"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)
{
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. */
'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;
'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;
<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;
<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;
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;
#include <errno.h>
int
-revoke (file)
- const char *file;
+revoke (const char *file)
{
__set_errno (ENOSYS);
return -1;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
void *sstk (int increment) __THROW;
void *
-sstk (increment)
- int increment;
+sstk (int increment)
{
__set_errno (ENOSYS);
return (void *) -1;
/* 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)
{
This only makes sense in certain operating systems. */
long int
-syscall (callno)
- long int callno;
+syscall (long int callno)
{
__set_errno (ENOSYS);
return -1;
/* setlogmask -- set the log mask level */
int
-setlogmask(pmask)
- int pmask;
+setlogmask (int pmask)
{
int omask;
/* 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;
/* 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)
{
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;
/* 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;
#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;
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;
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;
#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)
{
#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);
#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)
{
#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)
{
int
-raise (sig)
- int sig;
+raise (int sig)
{
/* This is what POSIX says must happen. */
return pthread_kill (pthread_self (), sig);
int
-pthread_barrier_destroy (barrier)
- pthread_barrier_t *barrier;
+pthread_barrier_destroy (pthread_barrier_t *barrier)
{
struct pthread_barrier *ibarrier;
int result = EBUSY;
/* 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;
int
-pthread_barrierattr_destroy (attr)
- pthread_barrierattr_t *attr;
+pthread_barrierattr_destroy (pthread_barrierattr_t *attr)
{
/* Nothing to do. */
int
-pthread_barrierattr_init (attr)
- pthread_barrierattr_t *attr;
+pthread_barrierattr_init (pthread_barrierattr_t *attr)
{
((struct pthread_barrierattr *) attr)->pshared = PTHREAD_PROCESS_PRIVATE;
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;
int
-__pthread_cond_broadcast (cond)
- pthread_cond_t *cond;
+__pthread_cond_broadcast (pthread_cond_t *cond)
{
LIBC_PROBE (cond_broadcast, 1, cond);
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;
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;
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;
int
-__pthread_condattr_destroy (attr)
- pthread_condattr_t *attr;
+__pthread_condattr_destroy (pthread_condattr_t *attr)
{
/* Nothing to be done. */
return 0;
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));
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;
int
-__pthread_condattr_init (attr)
- pthread_condattr_t *attr;
+__pthread_condattr_init (pthread_condattr_t *attr)
{
memset (attr, '\0', sizeof (*attr));
#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)
int
-pthread_detach (th)
- pthread_t th;
+pthread_detach (pthread_t th)
{
struct pthread *pd = (struct pthread *) th;
int
-__pthread_equal (thread1, thread2)
- pthread_t thread1;
- pthread_t thread2;
+__pthread_equal (pthread_t thread1, pthread_t thread2)
{
return thread1 == thread2;
}
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;
void *
-__pthread_getspecific (key)
- pthread_key_t key;
+__pthread_getspecific (pthread_key_t key)
{
struct pthread_key_data *data;
int
-pthread_key_delete (key)
- pthread_key_t key;
+pthread_key_delete (pthread_key_t key)
{
int result = EINVAL;
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
int
-__pthread_mutex_destroy (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_destroy (pthread_mutex_t *mutex)
{
LIBC_PROBE (mutex_destroy, 1, mutex);
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))
int
-__pthread_mutexattr_destroy (attr)
- pthread_mutexattr_t *attr;
+__pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
{
return 0;
}
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;
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;
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;
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;
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));
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
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
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;
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))
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;
int
-__pthread_rwlock_destroy (rwlock)
- pthread_rwlock_t *rwlock;
+__pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
{
LIBC_PROBE (rwlock_destroy, 1, rwlock);
int
-pthread_rwlockattr_destroy (attr)
- pthread_rwlockattr_t *attr;
+pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
{
/* Nothing to do. For now. */
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;
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;
int
-pthread_rwlockattr_init (attr)
- pthread_rwlockattr_t *attr;
+pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
{
struct pthread_rwlockattr *iattr;
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;
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;
int
-__pthread_setcancelstate (state, oldstate)
- int state;
- int *oldstate;
+__pthread_setcancelstate (int state, int *oldstate)
{
volatile struct pthread *self;
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;
int
-pthread_setconcurrency (level)
- int level;
+pthread_setconcurrency (int level)
{
if (level < 0)
return EINVAL;
int
-pthread_setschedprio (threadid, prio)
- pthread_t threadid;
- int prio;
+pthread_setschedprio (pthread_t threadid, int prio)
{
struct pthread *pd = (struct pthread *) threadid;
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;
int
-pthread_spin_destroy (lock)
- pthread_spinlock_t *lock;
+pthread_spin_destroy (pthread_spinlock_t *lock)
{
/* Nothing to do. */
return 0;
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;
int
-sem_close (sem)
- sem_t *sem;
+sem_close (sem_t *sem)
{
int result = 0;
int
-__new_sem_destroy (sem)
- sem_t *sem;
+__new_sem_destroy (sem_t *sem)
{
/* XXX Check for valid parameter. */
#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))
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))
{
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
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 ();
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;
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;
/* Get file-specific information about descriptor FD. */
long int
-__fpathconf (fd, name)
- int fd;
- int name;
+__fpathconf (int fd, int name)
{
if (fd < 0)
{
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. */
/* Get the process group ID of process PID. */
pid_t
-__getpgid (pid)
- pid_t pid;
+__getpgid (pid_t pid)
{
return pid;
}
#endif
int
-__group_member (gid)
- gid_t gid;
+__group_member (gid_t gid)
{
int n, size;
gid_t *groups;
/* 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)
{
/* 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;
/* 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;
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;
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;
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;
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;
/* Get the value of the system variable NAME. */
long int
-__sysconf (name)
- int name;
+__sysconf (int name)
{
switch (name)
{
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)
{
/* Put information about the system in NAME. */
int
-__uname (name)
- struct utsname *name;
+__uname (struct utsname *name)
{
int save;
#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;
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;
*/
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;
#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;
#ifdef DEBUG
static void
-Dprintf(msg, num)
- char *msg;
- int num;
+Dprintf (char *msg, int num)
{
if (_res.options & RES_DEBUG) {
int save = errno;
libresolv_hidden_proto (gethostbyname2)
struct hostent *
-gethostbyname(name)
- const char *name;
+gethostbyname (const char *name)
{
struct hostent *hp;
}
struct hostent *
-gethostbyname2(name, af)
- const char *name;
- int af;
+gethostbyname2 (const char *name, int af)
{
union
{
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 };
}
void
-_sethtent(f)
- int f;
+_sethtent (int f)
{
if (!hostf)
hostf = fopen(_PATH_HOSTS, "rce" );
libresolv_hidden_def (_gethtent)
struct hostent *
-_gethtbyname(name)
- const char *name;
+_gethtbyname (const char *name)
{
struct hostent *hp;
}
struct hostent *
-_gethtbyname2(name, af)
- const char *name;
- int af;
+_gethtbyname2 (const char *name, int af)
{
struct hostent *p;
char **cp;
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;
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];
}
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;
#ifdef RESOLVSORT
extern void
-addrsort(ap, num)
- char **ap;
- int num;
+addrsort (char **ap, int num)
{
int i, j;
char **p;
#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);
}
}
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));
}
* 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:
* 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;
* 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;
* 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:
*/
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"];
*/
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
* 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:
*/
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;
*/
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;
/* 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;
/* 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
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;
/* 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;
/* 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;
/* 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;
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;
/* 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)
{
*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)
int
-aio_error (aiocbp)
- const struct aiocb *aiocbp;
+aio_error (const struct aiocb *aiocbp)
{
return aiocbp->__error_code;
}
ssize_t
-aio_return (aiocbp)
- struct aiocb *aiocbp;
+aio_return (struct aiocb *aiocbp)
{
return aiocbp->__return_value;
}
#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;
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;
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;
/* Raise the signal SIG. */
int
-raise (sig)
- int sig;
+raise (int sig)
{
__set_errno (ENOSYS);
return -1;
/* 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)
{
/* 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)
{
/* 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;
/* 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)
{
/* Block signals in MASK, returning the old mask. */
int
-__sigblock (mask)
- int mask;
+__sigblock (int mask)
{
__set_errno (ENOSYS);
return -1;
/* 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)
{
/* Clear all signals from SET. */
int
-sigemptyset (set)
- sigset_t *set;
+sigemptyset (sigset_t *set)
{
if (set == NULL)
{
/* Set all signals in SET. */
int
-sigfillset (set)
- sigset_t *set;
+sigfillset (sigset_t *set)
{
if (set == NULL)
{
#include <signal.h>
int
-sighold (sig)
- int sig;
+sighold (int sig)
{
sigset_t set;
/* Set the disposition for SIG to SIG_IGN. */
int
-sigignore (sig)
- int sig;
+sigignore (int sig)
{
__set_errno (ENOSYS);
return -1;
(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;
/* Test whether SET is empty. */
int
-sigisemptyset (set)
- const sigset_t *set;
+sigisemptyset (const sigset_t *set)
{
if (set == NULL)
{
/* 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)
{
/* 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;
/* 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)
{
#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;
/* Store in SET all signals that are blocked and pending. */
int
-sigpending (set)
- sigset_t *set;
+sigpending (sigset_t *set)
{
if (set == NULL)
{
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)
{
#include <signal.h>
int
-sigrelse (sig)
- int sig;
+sigrelse (int sig)
{
sigset_t set;
#include <errno.h>
int
-__sigreturn (context)
- struct sigcontext *context;
+__sigreturn (struct sigcontext *context)
{
__set_errno (ENOSYS);
return -1;
/* 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;
#include <signal.h>
int
-__sigsetmask (mask)
- int mask;
+__sigsetmask (int mask)
{
__set_errno (ENOSYS);
return -1;
/* 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;
/* 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;
# ifndef SA_RESETHAND
static void
-sigvec_wrapper_handler (sig)
- int sig;
+sigvec_wrapper_handler (int sig)
{
struct sigvec_wrapper_data *data;
struct sigaction act;
/* 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)
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;
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;
/* 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;
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;
/* 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;
/* 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;
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;
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;
/* 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;
/* 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;
/* 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;
/* 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;
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;
/* Determine wheter socket is at a out-of-band mark. */
int
-sockatmark (fd)
- int fd;
+sockatmark (int fd)
{
__set_errno (ENOSYS);
return -1;
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;
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;
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;
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. */
#include <stdio.h>
int
-remove (file)
- const char *file;
+remove (const char *file)
{
__set_errno (ENOSYS);
return -1;
/* 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)
{
/* 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))
{
*/
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;
#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)));
b->used += len;
}
-void ReadFile(buffer, input)
- Buffer *buffer;
- FILE *input;
+void
+ReadFile (Buffer *buffer, FILE *input)
{
char buf[BUFSIZ + 1];
int bytes;
long int
-a64l (string)
- const char *string;
+a64l (const char *string)
{
const char *ptr = string;
unsigned long int result = 0ul;
#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);
}
#include <ucontext.h>
int
-getcontext (ucp)
- ucontext_t *ucp;
+getcontext (ucontext_t *ucp)
{
__set_errno (ENOSYS);
return -1;
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;
};
char *
-l64a (n)
- long int n;
+l64a (long int n)
{
unsigned long int m = (unsigned long int) n;
static char result[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;
}
/* 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;
#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)
#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)
/* 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, '=');
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);
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;
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;
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;
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;
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;
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);
}
#include <ucontext.h>
int
-setcontext (ucp)
- const ucontext_t *ucp;
+setcontext (const ucontext_t *ucp)
{
__set_errno (ENOSYS);
return -1;
}
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)
{
}
int
-unsetenv (name)
- const char *name;
+unsetenv (const char *name)
{
size_t len;
char **ep;
void
-srand48 (seedval)
- long seedval;
+srand48 (long seedval)
{
(void) __srand48_r (seedval, &__libc_drand48_data);
}
#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)
#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;
/* 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. */
}
static void
-expand (dst, c)
- char *dst;
- int c;
+expand (char *dst, int c)
{
if (isprint (c))
{
}
static void
-expand (dst, c)
- char *dst;
- int c;
+expand (char *dst, int c)
{
if (isprint (c))
{
}
static void
-expand (dst, c)
- char *dst;
- int c;
+expand (char *dst, int c)
{
if (isprint (c))
{
#include <stropts.h>
int
-fattach (fildes, path)
- int fildes;
- const char *path;
+fattach (int fildes, const char *path)
{
__set_errno (ENOSYS);
return -1;
#include <stropts.h>
int
-fdetach (path)
- const char *path;
+fdetach (const char *path)
{
__set_errno (ENOSYS);
return -1;
#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;
#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
/* Find the first bit set in I. */
int
-__ffs (i)
- int i;
+__ffs (int i)
{
static const unsigned char table[] =
{
/* 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;
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;
`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;
}
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;
#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;
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;
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;
/* 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;
/* 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;
libc_freeres_ptr (static char *buf);
char *
-strerror (errnum)
- int errnum;
+strerror (int errnum)
{
char *ret = __strerror_r (errnum, NULL, 0);
int saved_errno;
#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);
*/
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;
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;
}
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;
}
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);
}
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);
bool_t
-xdr_pmap (xdrs, regs)
- XDR *xdrs;
- struct pmap *regs;
+xdr_pmap (XDR *xdrs, struct pmap *regs)
{
if (xdr_u_long (xdrs, ®s->pm_prog) &&
* 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
* 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;
* 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)) &&
* 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;
}
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;
}
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;
* 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;
}
static void
-pmapdump (argc, argv)
- int argc;
- char **argv;
+pmapdump (int argc, char **argv)
{
struct sockaddr_in server_addr;
register struct hostent *hp;
}
static void
-brdcst (argc, argv)
- int argc;
- char **argv;
+brdcst (int argc, char **argv)
{
enum clnt_stat rpc_stat;
u_long prognum, vers;
}
static void
-deletereg (argc, argv)
- int argc;
- char **argv;
+deletereg (int argc, char **argv)
{
u_long prog_num, version_num;
}
static u_long
-getprognum (arg)
- char *arg;
+getprognum (char *arg)
{
register struct rpcent *rpc;
register u_long prognum;
}
static u_long
-getvers (arg)
- char *arg;
+getvers (char *arg)
{
register u_long vers;
}
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;
}
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;
#endif
SVCXPRT *
-svcudp_create (sock)
- int sock;
+svcudp_create (int sock)
{
return svcudp_bufcreate (sock, UDPMSGSIZE, UDPMSGSIZE);
}
#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);
}
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);
}
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);
}
static void
-svcudp_destroy (xprt)
- SVCXPRT *xprt;
+svcudp_destroy (SVCXPRT *xprt)
{
struct svcudp_data *su = su_data (xprt);
* 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;
* 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);
* 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
* 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))
{
#endif /* vax */
bool_t
-xdr_float(xdrs, fp)
- XDR *xdrs;
- float *fp;
+xdr_float (XDR *xdrs, float *fp)
{
#ifdef vax
struct ieee_single is;
bool_t
-xdr_double(xdrs, dp)
- XDR *xdrs;
- double *dp;
+xdr_double (XDR *xdrs, double *dp)
{
#ifdef vax
struct ieee_double id;
* 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;
*
*/
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;
#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;
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;
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;
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;
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;
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;
/* 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;
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;
/* 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;
from the caller's data segment. */
int
-shmdt (shmaddr)
- const void *shmaddr;
+shmdt (const void *shmaddr)
{
__set_errno (ENOSYS);
return -1;
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;
/* 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;
/* 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)
{
/* 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)
{
/* Suspend or restart transmission on FD. */
int
-tcflow (fd, action)
- int fd;
- int action;
+tcflow (int fd, int action)
{
if (fd < 0)
{
/* Flush pending data on FD. */
int
-tcflush (fd, queue_selector)
- int fd;
- int queue_selector;
+tcflush (int fd, int queue_selector)
{
switch (queue_selector)
{
/* 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)
{
/* Return the foreground process group ID of FD. */
pid_t
-tcgetpgrp (fd)
- int fd;
+tcgetpgrp (int fd)
{
if (fd < 0)
{
/* Return the session ID of FD. */
pid_t
-tcgetsid (fd)
- int fd;
+tcgetsid (int fd)
{
pid_t pgrp;
pid_t sid;
/* Send zero bits on FD. */
int
-tcsendbreak (fd, duration)
- int fd;
- int duration;
+tcsendbreak (int fd, int duration)
{
if (fd < 0)
{
/* 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)
{
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;
#include <time.h>
int
-dysize (year)
- int year;
+dysize (int year)
{
return __isleap (year) ? 366 : 365;
}
#include <sys/timeb.h>
int
-ftime (timebuf)
- struct timeb *timebuf;
+ftime (struct timeb *timebuf)
{
int save = errno;
struct tm tp;
/* 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)
{
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;
/* 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);
}
/* 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);
}
/* 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);
}
/* 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);
}
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;
/* 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;
/* Set the system clock to *WHEN. */
int
-stime (when)
- const time_t *when;
+stime (const time_t *when)
{
if (when == NULL)
{
# 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,
__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;
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);
}
/* 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);
/* 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)
{
/* 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;
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;
`__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);
wint_t
-__btowc (c)
- int c;
+__btowc (int c)
{
const struct gconv_fcts *fcts;
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);
}
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;
}
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);
}
/* 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;
/* 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;
/* 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;
/* 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)
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;
/* 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;
/* 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;
/* 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);
#endif
size_t
-__wcslen (s)
- const wchar_t *s;
+__wcslen (const wchar_t *s)
{
size_t len = 0;
/* 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;
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';
/* 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;
/* 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;
/* 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)
/* 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;
/* 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;
#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;
/* 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;
int
-wctob (c)
- wint_t c;
+wctob (wint_t c)
{
unsigned char buf[MB_LEN_MAX];
struct __gconv_step_data data;
#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)
#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;
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));
}
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));
}
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));
#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;
#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);
#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);
projects / thirdparty / glibc.git / commitdiff
