2015-10-20 Joseph Myers <joseph@codesourcery.com>
+ * crypt/md5-crypt.c (__md5_crypt_r): Convert to prototype-style
+ function definition.
+ * crypt/sha256-crypt.c (__sha256_crypt_r): Likewise.
+ * crypt/sha512-crypt.c (__sha512_crypt_r): Likewise.
+ * debug/backtracesyms.c (__backtrace_symbols): Likewise.
+ * elf/dl-minimal.c (_itoa): Likewise.
+ * hurd/hurdmalloc.c (malloc): Likewise.
+ (free): Likewise.
+ (realloc): Likewise.
+ * inet/inet6_option.c (inet6_option_space): Likewise.
+ (inet6_option_init): Likewise.
+ (inet6_option_append): Likewise.
+ (inet6_option_alloc): Likewise.
+ (inet6_option_next): Likewise.
+ (inet6_option_find): Likewise.
+ * io/ftw.c (FTW_NAME): Likewise.
+ (NFTW_NAME): Likewise.
+ (NFTW_NEW_NAME): Likewise.
+ (NFTW_OLD_NAME): Likewise.
+ * libio/iofwide.c (_IO_fwide): Likewise.
+ * libio/strops.c (_IO_str_init_static_internal): Likewise.
+ (_IO_str_init_static): Likewise.
+ (_IO_str_init_readonly): Likewise.
+ (_IO_str_overflow): Likewise.
+ (_IO_str_underflow): Likewise.
+ (_IO_str_count): Likewise.
+ (_IO_str_seekoff): Likewise.
+ (_IO_str_pbackfail): Likewise.
+ (_IO_str_finish): Likewise.
+ * libio/wstrops.c (_IO_wstr_init_static): Likewise.
+ (_IO_wstr_overflow): Likewise.
+ (_IO_wstr_underflow): Likewise.
+ (_IO_wstr_count): Likewise.
+ (_IO_wstr_seekoff): Likewise.
+ (_IO_wstr_pbackfail): Likewise.
+ (_IO_wstr_finish): Likewise.
+ * locale/programs/localedef.c (normalize_codeset): Likewise.
+ * locale/programs/locarchive.c (add_locale_to_archive): Likewise.
+ (add_locales_to_archive): Likewise.
+ (delete_locales_from_archive): Likewise.
+ * malloc/malloc.c (__libc_mallinfo): Likewise.
+ * math/gen-auto-libm-tests.c (init_fp_formats): Likewise.
+ * misc/tsearch.c (__tfind): Likewise.
+ * nptl/pthread_attr_destroy.c (__pthread_attr_destroy): Likewise.
+ * nptl/pthread_attr_getdetachstate.c
+ (__pthread_attr_getdetachstate): Likewise.
+ * nptl/pthread_attr_getguardsize.c (pthread_attr_getguardsize):
+ Likewise.
+ * nptl/pthread_attr_getinheritsched.c
+ (__pthread_attr_getinheritsched): Likewise.
+ * nptl/pthread_attr_getschedparam.c
+ (__pthread_attr_getschedparam): Likewise.
+ * nptl/pthread_attr_getschedpolicy.c
+ (__pthread_attr_getschedpolicy): Likewise.
+ * nptl/pthread_attr_getscope.c (__pthread_attr_getscope):
+ Likewise.
+ * nptl/pthread_attr_getstack.c (__pthread_attr_getstack):
+ Likewise.
+ * nptl/pthread_attr_getstackaddr.c (__pthread_attr_getstackaddr):
+ Likewise.
+ * nptl/pthread_attr_getstacksize.c (__pthread_attr_getstacksize):
+ Likewise.
+ * nptl/pthread_attr_init.c (__pthread_attr_init_2_1): Likewise.
+ (__pthread_attr_init_2_0): Likewise.
+ * nptl/pthread_attr_setdetachstate.c
+ (__pthread_attr_setdetachstate): Likewise.
+ * nptl/pthread_attr_setguardsize.c (pthread_attr_setguardsize):
+ Likewise.
+ * nptl/pthread_attr_setinheritsched.c
+ (__pthread_attr_setinheritsched): Likewise.
+ * nptl/pthread_attr_setschedparam.c
+ (__pthread_attr_setschedparam): Likewise.
+ * nptl/pthread_attr_setschedpolicy.c
+ (__pthread_attr_setschedpolicy): Likewise.
+ * nptl/pthread_attr_setscope.c (__pthread_attr_setscope):
+ Likewise.
+ * nptl/pthread_attr_setstack.c (__pthread_attr_setstack):
+ Likewise.
+ * nptl/pthread_attr_setstackaddr.c (__pthread_attr_setstackaddr):
+ Likewise.
+ * nptl/pthread_attr_setstacksize.c (__pthread_attr_setstacksize):
+ Likewise.
+ * nptl/pthread_condattr_setclock.c (pthread_condattr_setclock):
+ Likewise.
+ * nptl/pthread_create.c (__find_in_stack_list): Likewise.
+ * nptl/pthread_getattr_np.c (pthread_getattr_np): Likewise.
+ * nptl/pthread_mutex_cond_lock.c (__pthread_mutex_lock): Define to
+ use internal_function.
+ * nptl/pthread_mutex_init.c (__pthread_mutex_init): Convert to
+ prototype-style function definition.
+ * nptl/pthread_mutex_lock.c (__pthread_mutex_lock): Likewise.
+ (__pthread_mutex_cond_lock_adjust): Likewise. Use
+ internal_function.
+ * nptl/pthread_mutex_timedlock.c (pthread_mutex_timedlock):
+ Convert to prototype-style function definition.
+ * nptl/pthread_mutex_trylock.c (__pthread_mutex_trylock):
+ Likewise.
+ * nptl/pthread_mutex_unlock.c (__pthread_mutex_unlock_usercnt):
+ Likewise.
+ (__pthread_mutex_unlock): Likewise.
+ * nptl_db/td_ta_clear_event.c (td_ta_clear_event): Likewise.
+ * nptl_db/td_ta_set_event.c (td_ta_set_event): Likewise.
+ * nptl_db/td_thr_clear_event.c (td_thr_clear_event): Likewise.
+ * nptl_db/td_thr_event_enable.c (td_thr_event_enable): Likewise.
+ * nptl_db/td_thr_set_event.c (td_thr_set_event): Likewise.
+ * nss/makedb.c (process_input): Likewise.
+ * posix/fnmatch.c (__strchrnul): Likewise.
+ (__wcschrnul): Likewise.
+ (fnmatch): Likewise.
+ * posix/fnmatch_loop.c (FCT): Likewise.
+ * posix/glob.c (globfree): Likewise.
+ (__glob_pattern_type): Likewise.
+ (__glob_pattern_p): Likewise.
+ * posix/regcomp.c (re_compile_pattern): Likewise.
+ (re_set_syntax): Likewise.
+ (re_compile_fastmap): Likewise.
+ (regcomp): Likewise.
+ (regerror): Likewise.
+ (regfree): Likewise.
+ * posix/regexec.c (regexec): Likewise.
+ (re_match): Likewise.
+ (re_search): Likewise.
+ (re_match_2): Likewise.
+ (re_search_2): Likewise.
+ (re_search_stub): Likewise. Use internal_function
+ (re_copy_regs): Likewise.
+ (re_set_registers): Convert to prototype-style function
+ definition.
+ (prune_impossible_nodes): Likewise. Use internal_function.
+ * resolv/inet_net_pton.c (inet_net_pton): Convert to
+ prototype-style function definition.
+ (inet_net_pton_ipv4): Likewise.
+ * stdlib/strtod_l.c (____STRTOF_INTERNAL): Likewise.
+ * sysdeps/pthread/aio_cancel.c (aio_cancel): Likewise.
+ * sysdeps/pthread/aio_suspend.c (aio_suspend): Likewise.
+ * sysdeps/pthread/timer_delete.c (timer_delete): Likewise.
+ * sysdeps/unix/sysv/linux/dl-openat64.c (openat64): Likewise.
+ Make variadic.
+ * time/strptime_l.c (localtime_r): Convert to prototype-style
+ function definition.
+ * wcsmbs/mbsnrtowcs.c (__mbsnrtowcs): Likewise.
+ * wcsmbs/mbsrtowcs_l.c (__mbsrtowcs_l): Likewise.
+ * wcsmbs/wcsnrtombs.c (__wcsnrtombs): Likewise.
+ * wcsmbs/wcsrtombs.c (__wcsrtombs): Likewise.
+
* crypt/crypt.c (_ufc_doit_r): Convert to prototype-style function
definition.
(_ufc_doit_r): Likewise.
/* This entry point is equivalent to the `crypt' function in Unix
libcs. */
char *
-__md5_crypt_r (key, salt, buffer, buflen)
- const char *key;
- const char *salt;
- char *buffer;
- int buflen;
+__md5_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
{
unsigned char alt_result[16]
__attribute__ ((__aligned__ (__alignof__ (md5_uint32))));
char *
-__sha256_crypt_r (key, salt, buffer, buflen)
- const char *key;
- const char *salt;
- char *buffer;
- int buflen;
+__sha256_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
{
unsigned char alt_result[32]
__attribute__ ((__aligned__ (__alignof__ (uint32_t))));
char *
-__sha512_crypt_r (key, salt, buffer, buflen)
- const char *key;
- const char *salt;
- char *buffer;
- int buflen;
+__sha512_crypt_r (const char *key, const char *salt, char *buffer, int buflen)
{
unsigned char alt_result[64]
__attribute__ ((__aligned__ (__alignof__ (uint64_t))));
char **
-__backtrace_symbols (array, size)
- void *const *array;
- int size;
+__backtrace_symbols (void *const *array, int size)
{
Dl_info info[size];
int status[size];
also has to be present and it is never about speed when these
functions are used. */
char *
-_itoa (value, buflim, base, upper_case)
- unsigned long long int value;
- char *buflim;
- unsigned int base;
- int upper_case;
+_itoa (unsigned long long int value, char *buflim, unsigned int base,
+ int upper_case)
{
assert (! upper_case);
/* Declaration changed to standard one for GNU. */
void *
-malloc(size)
- size_t size;
+malloc (size_t size)
{
int i, n;
free_list_t fl;
/* Declaration changed to standard one for GNU. */
void
-free(base)
- void *base;
+free (void *base)
{
header_t h;
free_list_t fl;
/* Declaration changed to standard one for GNU. */
void *
-realloc(old_base, new_size)
- void *old_base;
- size_t new_size;
+realloc (void *old_base, size_t new_size)
{
header_t h;
free_list_t fl;
beginning (the value y in the alignment term "xn + y"), the type
byte, the length byte, and the option data. */
int
-inet6_option_space (nbytes)
- int nbytes;
+inet6_option_space (int nbytes)
{
/* Add room for the extension header. */
nbytes += sizeof (struct ip6_ext);
contain either Hop-by-Hop or Destination options. It returns 0 on
success or -1 on an error. */
int
-inet6_option_init (bp, cmsgp, type)
- void *bp;
- struct cmsghdr **cmsgp;
- int type;
+inet6_option_init (void *bp, struct cmsghdr **cmsgp, int type)
{
/* Only Hop-by-Hop or Destination options allowed. */
if (type != IPV6_HOPOPTS && type != IPV6_DSTOPTS)
inet6_option_init(). This function returns 0 if it succeeds or -1 on
an error. */
int
-inet6_option_append (cmsg, typep, multx, plusy)
- struct cmsghdr *cmsg;
- const uint8_t *typep;
- int multx;
- int plusy;
+inet6_option_append (struct cmsghdr *cmsg, const uint8_t *typep, int multx,
+ int plusy)
{
/* typep is a pointer to the 8-bit option type. It is assumed that this
field is immediately followed by the 8-bit option data length field,
uint8_t *
-inet6_option_alloc (cmsg, datalen, multx, plusy)
- struct cmsghdr *cmsg;
- int datalen;
- int multx;
- int plusy;
+inet6_option_alloc (struct cmsghdr *cmsg, int datalen, int multx, int plusy)
{
return option_alloc (cmsg, datalen, multx, plusy);
}
to be processed, the return value is -1 and *tptrp is NULL. If an
error occurs, the return value is -1 and *tptrp is not NULL. */
int
-inet6_option_next (cmsg, tptrp)
- const struct cmsghdr *cmsg;
- uint8_t **tptrp;
+inet6_option_next (const struct cmsghdr *cmsg, uint8_t **tptrp)
{
/* Make sure it is an option of the right type. */
if (cmsg->cmsg_level != IPPROTO_IPV6
pointer to cmsghdr structure of which cmsg_level equals IPPROTO_IPV6
and cmsg_type equals either IPV6_HOPOPTS or IPV6_DSTOPTS. */
int
-inet6_option_find (cmsg, tptrp, type)
- const struct cmsghdr *cmsg;
- uint8_t **tptrp;
- int type;
+inet6_option_find (const struct cmsghdr *cmsg, uint8_t **tptrp, int type)
{
/* Make sure it is an option of the right type. */
if (cmsg->cmsg_level != IPPROTO_IPV6
/* Entry points. */
int
-FTW_NAME (path, func, descriptors)
- const char *path;
- FTW_FUNC_T func;
- int descriptors;
+FTW_NAME (const char *path, FTW_FUNC_T func, int descriptors)
{
return ftw_startup (path, 0, func, descriptors, 0);
}
#ifndef _LIBC
int
-NFTW_NAME (path, func, descriptors, flags)
- const char *path;
- NFTW_FUNC_T func;
- int descriptors;
- int flags;
+NFTW_NAME (const char *path, NFTW_FUNC_T func, int descriptors, int flags)
{
return ftw_startup (path, 1, func, descriptors, flags);
}
int NFTW_NEW_NAME (const char *, NFTW_FUNC_T, int, int);
int
-NFTW_NEW_NAME (path, func, descriptors, flags)
- const char *path;
- NFTW_FUNC_T func;
- int descriptors;
- int flags;
+NFTW_NEW_NAME (const char *path, NFTW_FUNC_T func, int descriptors, int flags)
{
if (flags
& ~(FTW_PHYS | FTW_MOUNT | FTW_CHDIR | FTW_DEPTH | FTW_ACTIONRETVAL))
int
attribute_compat_text_section
-NFTW_OLD_NAME (path, func, descriptors, flags)
- const char *path;
- NFTW_FUNC_T func;
- int descriptors;
- int flags;
+NFTW_OLD_NAME (const char *path, NFTW_FUNC_T func, int descriptors, int flags)
{
flags &= (FTW_PHYS | FTW_MOUNT | FTW_CHDIR | FTW_DEPTH);
return ftw_startup (path, 1, func, descriptors, flags);
the orientation first. */
#undef _IO_fwide
int
-_IO_fwide (fp, mode)
- _IO_FILE *fp;
- int mode;
+_IO_fwide (_IO_FILE *fp, int mode)
{
/* Normalize the value. */
mode = mode < 0 ? -1 : (mode == 0 ? 0 : 1);
#include <stdio_ext.h>
void
-_IO_str_init_static_internal (sf, ptr, size, pstart)
- _IO_strfile *sf;
- char *ptr;
- _IO_size_t size;
- char *pstart;
+_IO_str_init_static_internal (_IO_strfile *sf, char *ptr, _IO_size_t size,
+ char *pstart)
{
_IO_FILE *fp = &sf->_sbf._f;
char *end;
}
void
-_IO_str_init_static (sf, ptr, size, pstart)
- _IO_strfile *sf;
- char *ptr;
- int size;
- char *pstart;
+_IO_str_init_static (_IO_strfile *sf, char *ptr, int size, char *pstart)
{
return _IO_str_init_static_internal (sf, ptr, size < 0 ? -1 : size, pstart);
}
void
-_IO_str_init_readonly (sf, ptr, size)
- _IO_strfile *sf;
- const char *ptr;
- int size;
+_IO_str_init_readonly (_IO_strfile *sf, const char *ptr, int size)
{
_IO_str_init_static_internal (sf, (char *) ptr, size < 0 ? -1 : size, NULL);
sf->_sbf._f._IO_file_flags |= _IO_NO_WRITES;
}
int
-_IO_str_overflow (fp, c)
- _IO_FILE *fp;
- int c;
+_IO_str_overflow (_IO_FILE *fp, int c)
{
int flush_only = c == EOF;
_IO_size_t pos;
libc_hidden_def (_IO_str_overflow)
int
-_IO_str_underflow (fp)
- _IO_FILE *fp;
+_IO_str_underflow (_IO_FILE *fp)
{
if (fp->_IO_write_ptr > fp->_IO_read_end)
fp->_IO_read_end = fp->_IO_write_ptr;
/* The size of the valid part of the buffer. */
_IO_ssize_t
-_IO_str_count (fp)
- _IO_FILE *fp;
+_IO_str_count (_IO_FILE *fp)
{
return ((fp->_IO_write_ptr > fp->_IO_read_end
? fp->_IO_write_ptr : fp->_IO_read_end)
_IO_off64_t
-_IO_str_seekoff (fp, offset, dir, mode)
- _IO_FILE *fp;
- _IO_off64_t offset;
- int dir;
- int mode;
+_IO_str_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
{
_IO_off64_t new_pos;
libc_hidden_def (_IO_str_seekoff)
int
-_IO_str_pbackfail (fp, c)
- _IO_FILE *fp;
- int c;
+_IO_str_pbackfail (_IO_FILE *fp, int c)
{
if ((fp->_flags & _IO_NO_WRITES) && c != EOF)
return EOF;
libc_hidden_def (_IO_str_pbackfail)
void
-_IO_str_finish (fp, dummy)
- _IO_FILE *fp;
- int dummy;
+_IO_str_finish (_IO_FILE *fp, int dummy)
{
if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
(((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);
#include <stdio_ext.h>
void
-_IO_wstr_init_static (fp, ptr, size, pstart)
- _IO_FILE *fp;
- wchar_t *ptr;
- _IO_size_t size;
- wchar_t *pstart;
+_IO_wstr_init_static (_IO_FILE *fp, wchar_t *ptr, _IO_size_t size,
+ wchar_t *pstart)
{
wchar_t *end;
}
_IO_wint_t
-_IO_wstr_overflow (fp, c)
- _IO_FILE *fp;
- _IO_wint_t c;
+_IO_wstr_overflow (_IO_FILE *fp, _IO_wint_t c)
{
int flush_only = c == WEOF;
_IO_size_t pos;
_IO_wint_t
-_IO_wstr_underflow (fp)
- _IO_FILE *fp;
+_IO_wstr_underflow (_IO_FILE *fp)
{
if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_read_end)
fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_write_ptr;
/* The size of the valid part of the buffer. */
_IO_ssize_t
-_IO_wstr_count (fp)
- _IO_FILE *fp;
+_IO_wstr_count (_IO_FILE *fp)
{
struct _IO_wide_data *wd = fp->_wide_data;
_IO_off64_t
-_IO_wstr_seekoff (fp, offset, dir, mode)
- _IO_FILE *fp;
- _IO_off64_t offset;
- int dir;
- int mode;
+_IO_wstr_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
{
_IO_off64_t new_pos;
}
_IO_wint_t
-_IO_wstr_pbackfail (fp, c)
- _IO_FILE *fp;
- _IO_wint_t c;
+_IO_wstr_pbackfail (_IO_FILE *fp, _IO_wint_t c)
{
if ((fp->_flags & _IO_NO_WRITES) && c != WEOF)
return WEOF;
}
void
-_IO_wstr_finish (fp, dummy)
- _IO_FILE *fp;
- int dummy;
+_IO_wstr_finish (_IO_FILE *fp, int dummy)
{
if (fp->_wide_data->_IO_buf_base && !(fp->_flags2 & _IO_FLAGS2_USER_WBUF))
(((_IO_strfile *) fp)->_s._free_buffer) (fp->_wide_data->_IO_buf_base);
names. Normalization allows the user to use any of the common
names. */
static const char *
-normalize_codeset (codeset, name_len)
- const char *codeset;
- size_t name_len;
+normalize_codeset (const char *codeset, size_t name_len)
{
int len = 0;
int only_digit = 1;
of the files if necessary. Add all the names, possibly overwriting
old files. */
int
-add_locale_to_archive (ah, name, data, replace)
- struct locarhandle *ah;
- const char *name;
- locale_data_t data;
- bool replace;
+add_locale_to_archive (struct locarhandle *ah, const char *name,
+ locale_data_t data, bool replace)
{
char *normalized_name = NULL;
uint32_t locrec_offset;
int
-add_locales_to_archive (nlist, list, replace)
- size_t nlist;
- char *list[];
- bool replace;
+add_locales_to_archive (size_t nlist, char *list[], bool replace)
{
struct locarhandle ah;
int result = 0;
int
-delete_locales_from_archive (nlist, list)
- size_t nlist;
- char *list[];
+delete_locales_from_archive (size_t nlist, char *list[])
{
struct locarhandle ah;
struct locarhead *head;
struct mallinfo
-__libc_mallinfo ()
+__libc_mallinfo (void)
{
struct mallinfo m;
mstate ar_ptr;
/* Initialize data for floating-point formats. */
static void
-init_fp_formats ()
+init_fp_formats (void)
{
int global_max_exp = 0, global_min_subnorm_exp = 0;
for (fp_format f = fp_first_format; f < fp_num_formats; f++)
KEY is the key to be located, ROOTP is the address of tree root,
COMPAR the ordering function. */
void *
-__tfind (key, vrootp, compar)
- const void *key;
- void *const *vrootp;
- __compar_fn_t compar;
+__tfind (const void *key, void *const *vrootp, __compar_fn_t compar)
{
node *rootp = (node *) vrootp;
#include <shlib-compat.h>
int
-__pthread_attr_destroy (attr)
- pthread_attr_t *attr;
+__pthread_attr_destroy (pthread_attr_t *attr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getdetachstate (attr, detachstate)
- const pthread_attr_t *attr;
- int *detachstate;
+__pthread_attr_getdetachstate (const pthread_attr_t *attr, int *detachstate)
{
struct pthread_attr *iattr;
int
-pthread_attr_getguardsize (attr, guardsize)
- const pthread_attr_t *attr;
- size_t *guardsize;
+pthread_attr_getguardsize (const pthread_attr_t *attr, size_t *guardsize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getinheritsched (attr, inherit)
- const pthread_attr_t *attr;
- int *inherit;
+__pthread_attr_getinheritsched (const pthread_attr_t *attr, int *inherit)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getschedparam (attr, param)
- const pthread_attr_t *attr;
- struct sched_param *param;
+__pthread_attr_getschedparam (const pthread_attr_t *attr,
+ struct sched_param *param)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getschedpolicy (attr, policy)
- const pthread_attr_t *attr;
- int *policy;
+__pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *policy)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getscope (attr, scope)
- const pthread_attr_t *attr;
- int *scope;
+__pthread_attr_getscope (const pthread_attr_t *attr, int *scope)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstack (attr, stackaddr, stacksize)
- const pthread_attr_t *attr;
- void **stackaddr;
- size_t *stacksize;
+__pthread_attr_getstack (const pthread_attr_t *attr, void **stackaddr,
+ size_t *stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstackaddr (attr, stackaddr)
- const pthread_attr_t *attr;
- void **stackaddr;
+__pthread_attr_getstackaddr (const pthread_attr_t *attr, void **stackaddr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_getstacksize (attr, stacksize)
- const pthread_attr_t *attr;
- size_t *stacksize;
+__pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_init_2_1 (attr)
- pthread_attr_t *attr;
+__pthread_attr_init_2_1 (pthread_attr_t *attr)
{
struct pthread_attr *iattr;
#if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
int
-__pthread_attr_init_2_0 (attr)
- pthread_attr_t *attr;
+__pthread_attr_init_2_0 (pthread_attr_t *attr)
{
/* This code is specific to the old LinuxThread code which has a too
small pthread_attr_t definition. The struct looked like
int
-__pthread_attr_setdetachstate (attr, detachstate)
- pthread_attr_t *attr;
- int detachstate;
+__pthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate)
{
struct pthread_attr *iattr;
int
-pthread_attr_setguardsize (attr, guardsize)
- pthread_attr_t *attr;
- size_t guardsize;
+pthread_attr_setguardsize (pthread_attr_t *attr, size_t guardsize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setinheritsched (attr, inherit)
- pthread_attr_t *attr;
- int inherit;
+__pthread_attr_setinheritsched (pthread_attr_t *attr, int inherit)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setschedparam (attr, param)
- pthread_attr_t *attr;
- const struct sched_param *param;
+__pthread_attr_setschedparam (pthread_attr_t *attr,
+ const struct sched_param *param)
{
assert (sizeof (*attr) >= sizeof (struct pthread_attr));
struct pthread_attr *iattr = (struct pthread_attr *) attr;
int
-__pthread_attr_setschedpolicy (attr, policy)
- pthread_attr_t *attr;
- int policy;
+__pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setscope (attr, scope)
- pthread_attr_t *attr;
- int scope;
+__pthread_attr_setscope (pthread_attr_t *attr, int scope)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstack (attr, stackaddr, stacksize)
- pthread_attr_t *attr;
- void *stackaddr;
- size_t stacksize;
+__pthread_attr_setstack (pthread_attr_t *attr, void *stackaddr,
+ size_t stacksize)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstackaddr (attr, stackaddr)
- pthread_attr_t *attr;
- void *stackaddr;
+__pthread_attr_setstackaddr (pthread_attr_t *attr, void *stackaddr)
{
struct pthread_attr *iattr;
int
-__pthread_attr_setstacksize (attr, stacksize)
- pthread_attr_t *attr;
- size_t stacksize;
+__pthread_attr_setstacksize (pthread_attr_t *attr, size_t stacksize)
{
struct pthread_attr *iattr;
int
-pthread_condattr_setclock (attr, clock_id)
- pthread_condattr_t *attr;
- clockid_t clock_id;
+pthread_condattr_setclock (pthread_condattr_t *attr, clockid_t clock_id)
{
/* Only a few clocks are allowed. */
if (clock_id != CLOCK_MONOTONIC && clock_id != CLOCK_REALTIME)
struct pthread *
internal_function
-__find_in_stack_list (pd)
- struct pthread *pd;
+__find_in_stack_list (struct pthread *pd)
{
list_t *entry;
struct pthread *result = NULL;
int
-pthread_getattr_np (thread_id, attr)
- pthread_t thread_id;
- pthread_attr_t *attr;
+pthread_getattr_np (pthread_t thread_id, pthread_attr_t *attr)
{
struct pthread *thread = (struct pthread *) thread_id;
struct pthread_attr *iattr = (struct pthread_attr *) attr;
#define LLL_ROBUST_MUTEX_LOCK(mutex, id) \
lll_robust_cond_lock ((mutex)->__data.__lock, id, \
PTHREAD_ROBUST_MUTEX_PSHARED (mutex))
-#define __pthread_mutex_lock __pthread_mutex_cond_lock
+#define __pthread_mutex_lock internal_function __pthread_mutex_cond_lock
#define __pthread_mutex_lock_full __pthread_mutex_cond_lock_full
#define NO_INCR
}
int
-__pthread_mutex_init (mutex, mutexattr)
- pthread_mutex_t *mutex;
- const pthread_mutexattr_t *mutexattr;
+__pthread_mutex_init (pthread_mutex_t *mutex,
+ const pthread_mutexattr_t *mutexattr)
{
const struct pthread_mutexattr *imutexattr;
__attribute_noinline__;
int
-__pthread_mutex_lock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_lock (pthread_mutex_t *mutex)
{
assert (sizeof (mutex->__size) >= sizeof (mutex->__data));
#ifdef NO_INCR
void
-__pthread_mutex_cond_lock_adjust (mutex)
- pthread_mutex_t *mutex;
+internal_function
+__pthread_mutex_cond_lock_adjust (pthread_mutex_t *mutex)
{
assert ((mutex->__data.__kind & PTHREAD_MUTEX_PRIO_INHERIT_NP) != 0);
assert ((mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP) == 0);
#endif
int
-pthread_mutex_timedlock (mutex, abstime)
- pthread_mutex_t *mutex;
- const struct timespec *abstime;
+pthread_mutex_timedlock (pthread_mutex_t *mutex,
+ const struct timespec *abstime)
{
int oldval;
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
#endif
int
-__pthread_mutex_trylock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_trylock (pthread_mutex_t *mutex)
{
int oldval;
pid_t id = THREAD_GETMEM (THREAD_SELF, tid);
int
internal_function attribute_hidden
-__pthread_mutex_unlock_usercnt (mutex, decr)
- pthread_mutex_t *mutex;
- int decr;
+__pthread_mutex_unlock_usercnt (pthread_mutex_t *mutex, int decr)
{
int type = PTHREAD_MUTEX_TYPE_ELISION (mutex);
if (__builtin_expect (type &
int
-__pthread_mutex_unlock (mutex)
- pthread_mutex_t *mutex;
+__pthread_mutex_unlock (pthread_mutex_t *mutex)
{
return __pthread_mutex_unlock_usercnt (mutex, 1);
}
td_err_e
-td_ta_clear_event (ta_arg, event)
- const td_thragent_t *ta_arg;
- td_thr_events_t *event;
+td_ta_clear_event (const td_thragent_t *ta_arg, td_thr_events_t *event)
{
td_thragent_t *const ta = (td_thragent_t *) ta_arg;
td_err_e err;
td_err_e
-td_ta_set_event (ta_arg, event)
- const td_thragent_t *ta_arg;
- td_thr_events_t *event;
+td_ta_set_event (const td_thragent_t *ta_arg, td_thr_events_t *event)
{
td_thragent_t *const ta = (td_thragent_t *) ta_arg;
td_err_e err;
td_err_e
-td_thr_clear_event (th, event)
- const td_thrhandle_t *th;
- td_thr_events_t *event;
+td_thr_clear_event (const td_thrhandle_t *th, td_thr_events_t *event)
{
td_err_e err;
psaddr_t eventmask;
td_err_e
-td_thr_event_enable (th, onoff)
- const td_thrhandle_t *th;
- int onoff;
+td_thr_event_enable (const td_thrhandle_t *th, int onoff)
{
LOG ("td_thr_event_enable");
td_err_e
-td_thr_set_event (th, event)
- const td_thrhandle_t *th;
- td_thr_events_t *event;
+td_thr_set_event (const td_thrhandle_t *th, td_thr_events_t *event)
{
td_err_e err;
psaddr_t eventmask;
static int
-process_input (input, inname, to_lowercase, be_quiet)
- FILE *input;
- const char *inname;
- int to_lowercase;
- int be_quiet;
+process_input (FILE *input, const char *inname, int to_lowercase, int be_quiet)
{
char *line;
size_t linelen;
# if !defined HAVE___STRCHRNUL && !defined _LIBC
static char *
-__strchrnul (s, c)
- const char *s;
- int c;
+__strchrnul (const char *s, int c)
{
char *result = strchr (s, c);
if (result == NULL)
# if HANDLE_MULTIBYTE && !defined HAVE___STRCHRNUL && !defined _LIBC
static wchar_t *
-__wcschrnul (s, c)
- const wchar_t *s;
- wint_t c;
+__wcschrnul (const wchar_t *s, wint_t c)
{
wchar_t *result = wcschr (s, c);
if (result == NULL)
int
-fnmatch (pattern, string, flags)
- const char *pattern;
- const char *string;
- int flags;
+fnmatch (const char *pattern, const char *string, int flags)
{
# if HANDLE_MULTIBYTE
if (__builtin_expect (MB_CUR_MAX, 1) != 1)
static int
internal_function
-FCT (pattern, string, string_end, no_leading_period, flags, ends, alloca_used)
- const CHAR *pattern;
- const CHAR *string;
- const CHAR *string_end;
- int no_leading_period;
- int flags;
- struct STRUCT *ends;
- size_t alloca_used;
+FCT (const CHAR *pattern, const CHAR *string, const CHAR *string_end,
+ int no_leading_period, int flags, struct STRUCT *ends, size_t alloca_used)
{
const CHAR *p = pattern, *n = string;
UCHAR c;
/* Free storage allocated in PGLOB by a previous `glob' call. */
void
-globfree (pglob)
- glob_t *pglob;
+globfree (glob_t *pglob)
{
if (pglob->gl_pathv != NULL)
{
/* We must not compile this function twice. */
#if !defined _LIBC || !defined NO_GLOB_PATTERN_P
int
-__glob_pattern_type (pattern, quote)
- const char *pattern;
- int quote;
+__glob_pattern_type (const char *pattern, int quote)
{
const char *p;
int ret = 0;
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
int
-__glob_pattern_p (pattern, quote)
- const char *pattern;
- int quote;
+__glob_pattern_p (const char *pattern, int quote)
{
return __glob_pattern_type (pattern, quote) == 1;
}
are set in BUFP on entry. */
const char *
-re_compile_pattern (pattern, length, bufp)
- const char *pattern;
- size_t length;
- struct re_pattern_buffer *bufp;
+re_compile_pattern (const char *pattern, size_t length,
+ struct re_pattern_buffer *bufp)
{
reg_errcode_t ret;
defined in regex.h. We return the old syntax. */
reg_syntax_t
-re_set_syntax (syntax)
- reg_syntax_t syntax;
+re_set_syntax (reg_syntax_t syntax)
{
reg_syntax_t ret = re_syntax_options;
#endif
int
-re_compile_fastmap (bufp)
- struct re_pattern_buffer *bufp;
+re_compile_fastmap (struct re_pattern_buffer *bufp)
{
re_dfa_t *dfa = (re_dfa_t *) bufp->buffer;
char *fastmap = bufp->fastmap;
the return codes and their meanings.) */
int
-regcomp (preg, pattern, cflags)
- regex_t *__restrict preg;
- const char *__restrict pattern;
- int cflags;
+regcomp (regex_t *__restrict preg, const char *__restrict pattern, int cflags)
{
reg_errcode_t ret;
reg_syntax_t syntax = ((cflags & REG_EXTENDED) ? RE_SYNTAX_POSIX_EXTENDED
from either regcomp or regexec. We don't use PREG here. */
size_t
-regerror (errcode, preg, errbuf, errbuf_size)
- int errcode;
- const regex_t *__restrict preg;
- char *__restrict errbuf;
- size_t errbuf_size;
+regerror (int errcode, const regex_t *__restrict preg, char *__restrict errbuf,
+ size_t errbuf_size)
{
const char *msg;
size_t msg_size;
/* Free dynamically allocated space used by PREG. */
void
-regfree (preg)
- regex_t *preg;
+regfree (regex_t *preg)
{
re_dfa_t *dfa = (re_dfa_t *) preg->buffer;
if (BE (dfa != NULL, 1))
We return 0 if we find a match and REG_NOMATCH if not. */
int
-regexec (preg, string, nmatch, pmatch, eflags)
- const regex_t *__restrict preg;
- const char *__restrict string;
- size_t nmatch;
- regmatch_t pmatch[];
- int eflags;
+regexec (const regex_t *__restrict preg, const char *__restrict string,
+ size_t nmatch, regmatch_t pmatch[], int eflags)
{
reg_errcode_t err;
int start, length;
match was found and -2 indicates an internal error. */
int
-re_match (bufp, string, length, start, regs)
- struct re_pattern_buffer *bufp;
- const char *string;
- int length, start;
- struct re_registers *regs;
+re_match (struct re_pattern_buffer *bufp, const char *string, int length,
+ int start, struct re_registers *regs)
{
return re_search_stub (bufp, string, length, start, 0, length, regs, 1);
}
#endif
int
-re_search (bufp, string, length, start, range, regs)
- struct re_pattern_buffer *bufp;
- const char *string;
- int length, start, range;
- struct re_registers *regs;
+re_search (struct re_pattern_buffer *bufp, const char *string, int length,
+ int start, int range, struct re_registers *regs)
{
return re_search_stub (bufp, string, length, start, range, length, regs, 0);
}
#endif
int
-re_match_2 (bufp, string1, length1, string2, length2, start, regs, stop)
- struct re_pattern_buffer *bufp;
- const char *string1, *string2;
- int length1, length2, start, stop;
- struct re_registers *regs;
+re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int length1,
+ const char *string2, int length2, int start,
+ struct re_registers *regs, int stop)
{
return re_search_2_stub (bufp, string1, length1, string2, length2,
start, 0, regs, stop, 1);
#endif
int
-re_search_2 (bufp, string1, length1, string2, length2, start, range, regs, stop)
- struct re_pattern_buffer *bufp;
- const char *string1, *string2;
- int length1, length2, start, range, stop;
- struct re_registers *regs;
+re_search_2 (struct re_pattern_buffer *bufp, const char *string1, int length1,
+ const char *string2, int length2, int start, int range,
+ struct re_registers *regs, int stop)
{
return re_search_2_stub (bufp, string1, length1, string2, length2,
start, range, regs, stop, 0);
otherwise the position of the match is returned. */
static int
-re_search_stub (bufp, string, length, start, range, stop, regs, ret_len)
- struct re_pattern_buffer *bufp;
- const char *string;
- int length, start, range, stop, ret_len;
- struct re_registers *regs;
+internal_function
+re_search_stub (struct re_pattern_buffer *bufp, const char *string, int length,
+ int start, int range, int stop, struct re_registers *regs,
+ int ret_len)
{
reg_errcode_t result;
regmatch_t *pmatch;
}
static unsigned
-re_copy_regs (regs, pmatch, nregs, regs_allocated)
- struct re_registers *regs;
- regmatch_t *pmatch;
- int nregs, regs_allocated;
+internal_function
+re_copy_regs (struct re_registers *regs, regmatch_t *pmatch, int nregs,
+ int regs_allocated)
{
int rval = REGS_REALLOCATE;
int i;
freeing the old data. */
void
-re_set_registers (bufp, regs, num_regs, starts, ends)
- struct re_pattern_buffer *bufp;
- struct re_registers *regs;
- unsigned num_regs;
- regoff_t *starts, *ends;
+re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs,
+ unsigned num_regs, regoff_t *starts, regoff_t *ends)
{
if (num_regs)
{
}
static reg_errcode_t
-__attribute_warn_unused_result__
-prune_impossible_nodes (mctx)
- re_match_context_t *mctx;
+internal_function __attribute_warn_unused_result__
+prune_impossible_nodes (re_match_context_t *mctx)
{
const re_dfa_t *const dfa = mctx->dfa;
int halt_node, match_last;
* Paul Vixie (ISC), June 1996
*/
int
-inet_net_pton(af, src, dst, size)
- int af;
- const char *src;
- void *dst;
- size_t size;
+inet_net_pton (int af, const char *src, void *dst, size_t size)
{
switch (af) {
case AF_INET:
* Paul Vixie (ISC), June 1996
*/
static int
-inet_net_pton_ipv4(src, dst, size)
- const char *src;
- u_char *dst;
- size_t size;
+inet_net_pton_ipv4 (const char *src, u_char *dst, size_t size)
{
static const char xdigits[] = "0123456789abcdef";
int n, ch, tmp, dirty, bits;
return 0.0. If the number is too big to be represented, set `errno' to
ERANGE and return HUGE_VAL with the appropriate sign. */
FLOAT
-____STRTOF_INTERNAL (nptr, endptr, group, loc)
- const STRING_TYPE *nptr;
- STRING_TYPE **endptr;
- int group;
- __locale_t loc;
+____STRTOF_INTERNAL (const STRING_TYPE *nptr, STRING_TYPE **endptr, int group,
+ __locale_t loc)
{
int negative; /* The sign of the number. */
MPN_VAR (num); /* MP representation of the number. */
int
-aio_cancel (fildes, aiocbp)
- int fildes;
- struct aiocb *aiocbp;
+aio_cancel (int fildes, struct aiocb *aiocbp)
{
struct requestlist *req = NULL;
int result = AIO_ALLDONE;
#endif
int
-aio_suspend (list, nent, timeout)
- const struct aiocb *const list[];
- int nent;
- const struct timespec *timeout;
+aio_suspend (const struct aiocb *const list[], int nent,
+ const struct timespec *timeout)
{
if (__glibc_unlikely (nent < 0))
{
/* Delete timer TIMERID. */
int
-timer_delete (timerid)
- timer_t timerid;
+timer_delete (timer_t timerid)
{
struct timer_node *timer;
int retval = -1;
int
-openat64 (dfd, file, oflag)
- int dfd;
- const char *file;
- int oflag;
+openat64 (int dfd, const char *file, int oflag, ...)
{
assert (!__OPEN_NEEDS_MODE (oflag));
# define localtime_r my_localtime_r
static struct tm *localtime_r (const time_t *, struct tm *);
static struct tm *
-localtime_r (t, tp)
- const time_t *t;
- struct tm *tp;
+localtime_r (const time_t *t, struct tm *tp)
{
struct tm *l = localtime (t);
if (! l)
implementation of stdio because we have to deal with unterminated
buffers. At most NMC bytes will be converted. */
size_t
-__mbsnrtowcs (dst, src, nmc, len, ps)
- wchar_t *dst;
- const char **src;
- size_t nmc;
- size_t len;
- mbstate_t *ps;
+__mbsnrtowcs (wchar_t *dst, const char **src, size_t nmc, size_t len,
+ mbstate_t *ps)
{
const unsigned char *srcend;
struct __gconv_step_data data;
size_t
attribute_hidden
-__mbsrtowcs_l (dst, src, len, ps, l)
- wchar_t *dst;
- const char **src;
- size_t len;
- mbstate_t *ps;
- __locale_t l;
+__mbsrtowcs_l (wchar_t *dst, const char **src, size_t len, mbstate_t *ps,
+ __locale_t l)
{
struct __gconv_step_data data;
size_t result;
implementation of stdio because we have to deal with unterminated
buffers. At most NWC wide character will be converted. */
size_t
-__wcsnrtombs (dst, src, nwc, len, ps)
- char *dst;
- const wchar_t **src;
- size_t nwc;
- size_t len;
- mbstate_t *ps;
+__wcsnrtombs (char *dst, const wchar_t **src, size_t nwc, size_t len,
+ mbstate_t *ps)
{
struct __gconv_step_data data;
const wchar_t *srcend;
static mbstate_t state;
size_t
-__wcsrtombs (dst, src, len, ps)
- char *dst;
- const wchar_t **src;
- size_t len;
- mbstate_t *ps;
+__wcsrtombs (char *dst, const wchar_t **src, size_t len, mbstate_t *ps)
{
struct __gconv_step_data data;
int status;