/* Convert Internet host address from numbers-and-dots notation in CP
into binary data in network byte order. */
extern in_addr_t inet_addr (__const char *__cp) __THROW;
+libc_hidden_proto(inet_addr)
/* Return the local host address part of the Internet address in IN. */
extern in_addr_t inet_lnaof (struct in_addr __in) __THROW;
network number NET with the local address HOST. */
extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
__THROW;
+libc_hidden_proto(inet_makeaddr)
/* Return network number part of the Internet address IN. */
extern in_addr_t inet_netof (struct in_addr __in) __THROW;
+libc_hidden_proto(inet_netof)
/* Extract the network number in network byte order from the address
in numbers-and-dots natation starting at CP. */
extern in_addr_t inet_network (__const char *__cp) __THROW;
+libc_hidden_proto(inet_network)
/* Convert Internet number in IN to ASCII representation. The return value
is a pointer to an internal array containing the string. */
extern char *inet_ntoa (struct in_addr __in) __THROW;
+libc_hidden_proto(inet_ntoa)
/* Recursion-safe flavor */
extern char *inet_ntoa_r (struct in_addr __in, char *__buf) __THROW;
+libc_hidden_proto(inet_ntoa_r)
/* Convert from presentation format of an Internet number in buffer
starting at CP to the binary network format and store result for
interface type AF in buffer starting at BUF. */
extern int inet_pton (int __af, __const char *__restrict __cp,
void *__restrict __buf) __THROW;
+libc_hidden_proto(inet_pton)
/* Convert a Internet address in binary network format for interface
type AF in buffer starting at CP to presentation form and place
extern __const char *inet_ntop (int __af, __const void *__restrict __cp,
char *__restrict __buf, socklen_t __len)
__THROW;
+libc_hidden_proto(inet_ntop)
/* The following functions are not part of XNS 5.2. */
/* Convert Internet host address from numbers-and-dots notation in CP
into binary data and store the result in the structure INP. */
extern int inet_aton (__const char *__cp, struct in_addr *__inp) __THROW;
+libc_hidden_proto(inet_aton)
/* Format a network number NET into presentation format and place result
in buffer starting at BUF with length of LEN bytes. */
u_int32_t ns_datetosecs (const char *cp, int *errp) __THROW;
int ns_name_ntol (const u_char *, u_char *, size_t) __THROW;
int ns_name_ntop (const u_char *, char *, size_t) __THROW;
+libc_hidden_proto(ns_name_ntop)
int ns_name_pton (const char *, u_char *, size_t) __THROW;
int ns_name_unpack (const u_char *, const u_char *,
const u_char *, u_char *, size_t) __THROW;
+libc_hidden_proto(ns_name_unpack)
int ns_name_pack (const u_char *, u_char *, int,
const u_char **, const u_char **) __THROW;
int ns_name_uncompress (const u_char *, const u_char *,
const u_char *, char *, size_t) __THROW;
+libc_hidden_proto(ns_name_uncompress)
int ns_name_compress (const char *, u_char *, size_t,
const u_char **, const u_char **) __THROW;
int ns_name_skip (const u_char **, const u_char *) __THROW;
/* This prints an "Assertion failed" message and aborts. */
extern void __assert __P((const char *, const char *, int, const char *));
+libc_hidden_proto(__assert)
__END_DECLS
__exctype (isprint);
__exctype (ispunct);
__exctype (isspace);
+libc_hidden_proto(isspace)
__exctype (isupper);
__exctype (isxdigit);
/* Return nonzero iff C is in the ASCII set
(i.e., is no more than 7 bits wide). */
extern int isascii (int __c) __THROW;
+libc_hidden_proto(isascii)
/* Return the part of C that is in the ASCII set
(i.e., the low-order 7 bits of C). */
__exctype_l (isprint_l);
__exctype_l (ispunct_l);
__exctype_l (isspace_l);
+libc_hidden_proto(isspace_l)
__exctype_l (isupper_l);
__exctype_l (isxdigit_l);
/* Return the lowercase version of C in locale L. */
extern int __tolower_l (int __c, __locale_t __l) __THROW;
extern int tolower_l (int __c, __locale_t __l) __THROW;
+libc_hidden_proto(tolower_l)
/* Return the uppercase version of C. */
extern int __toupper_l (int __c, __locale_t __l) __THROW;
extern int toupper_l (int __c, __locale_t __l) __THROW;
+libc_hidden_proto(toupper_l)
# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
# define __tolower_l(c, locale) \
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern DIR *opendir (__const char *__name) __nonnull ((1));
+libc_hidden_proto(opendir)
/* Close the directory stream DIRP.
Return 0 if successful, -1 if not.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int closedir (DIR *__dirp) __nonnull ((1));
+libc_hidden_proto(closedir)
/* Read a directory entry from DIRP. Return a pointer to a `struct
dirent' describing the entry, or NULL for EOF or error. The
marked with __THROW. */
#ifndef __USE_FILE_OFFSET64
extern struct dirent *readdir (DIR *__dirp) __nonnull ((1));
+libc_hidden_proto(readdir)
#else
# ifdef __REDIRECT
extern struct dirent *__REDIRECT (readdir, (DIR *__dirp), readdir64)
#ifdef __USE_LARGEFILE64
extern struct dirent64 *readdir64 (DIR *__dirp) __nonnull ((1));
+libc_hidden_proto(readdir64)
#endif
#if defined __USE_POSIX || defined __USE_MISC
struct dirent *__restrict __entry,
struct dirent **__restrict __result)
__nonnull ((1, 2, 3));
+libc_hidden_proto(readdir_r)
# else
# ifdef __REDIRECT
extern int __REDIRECT (readdir_r,
struct dirent64 *__restrict __entry,
struct dirent64 **__restrict __result)
__nonnull ((1, 2, 3));
+libc_hidden_proto(readdir64_r)
# endif
#endif /* POSIX or misc */
/* Return the file descriptor used by DIRP. */
extern int dirfd (DIR *__dirp) __THROW __nonnull ((1));
+libc_hidden_proto(dirfd)
# if 0 /* defined __OPTIMIZE__ && defined _DIR_dirfd */
# define dirfd(dirp) _DIR_dirfd (dirp)
__attribute__ ((__format__ (__printf__, 1, 2)));
extern void vwarn (__const char *__format, __gnuc_va_list)
__attribute__ ((__format__ (__printf__, 1, 0)));
+libc_hidden_proto(vwarn)
/* Likewise, but without ": " and the standard error string. */
extern void warnx (__const char *__format, ...)
__attribute__ ((__format__ (__printf__, 1, 2)));
extern void vwarnx (__const char *__format, __gnuc_va_list)
__attribute__ ((__format__ (__printf__, 1, 0)));
+libc_hidden_proto(vwarnx)
/* Likewise, and then exit with STATUS. */
extern void err (int __status, __const char *__format, ...)
__attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
extern void verr (int __status, __const char *__format, __gnuc_va_list)
__attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
+libc_hidden_proto(verr)
extern void errx (int __status, __const char *__format, ...)
__attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
extern void verrx (int __status, __const char *, __gnuc_va_list)
__attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
+libc_hidden_proto(verrx)
__END_DECLS
#endif
#ifdef __USE_LARGEFILE64
extern int fcntl64 (int __fd, int __cmd, ...);
+libc_hidden_proto(fcntl64)
#endif
/* Open FILE and return a new file descriptor for it, or -1 on error.
#endif
#ifdef __USE_LARGEFILE64
extern int open64 (__const char *__file, int __oflag, ...) __nonnull ((1));
+libc_hidden_proto(open64)
#endif
#if 0 /*def __USE_GNU*/
# ifndef __USE_FILE_OFFSET64
extern int lockf (int __fd, int __cmd, __off_t __len);
+libc_hidden_proto(lockf)
# else
# ifdef __REDIRECT
extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len), lockf64);
# endif
# ifdef __USE_LARGEFILE64
extern int lockf64 (int __fd, int __cmd, __off64_t __len);
+libc_hidden_proto(lockf64)
# endif
#endif
returning zero if it matches, FNM_NOMATCH if not. */
extern int fnmatch (__const char *__pattern, __const char *__name,
int __flags);
+libc_hidden_proto(fnmatch)
#ifdef __cplusplus
}
extern int glob (__const char *__restrict __pattern, int __flags,
int (*__errfunc) (__const char *, int),
glob_t *__restrict __pglob) __THROW;
+libc_hidden_proto(glob)
/* Free storage allocated in PGLOB by a previous `glob' call. */
extern void globfree (glob_t *__pglob) __THROW;
+libc_hidden_proto(globfree)
#else
extern int __REDIRECT_NTH (glob, (__const char *__restrict __pattern,
int __flags,
extern int glob64 (__const char *__restrict __pattern, int __flags,
int (*__errfunc) (__const char *, int),
glob64_t *__restrict __pglob) __THROW;
+libc_hidden_proto(glob64)
extern void globfree64 (glob64_t *__pglob) __THROW;
+libc_hidden_proto(globfree64)
#endif
This function is not part of the interface specified by POSIX.2
but several programs want to use it. */
extern int glob_pattern_p (__const char *__pattern, int __quote) __THROW;
+libc_hidden_proto(glob_pattern_p)
#endif
__END_DECLS
extern int getgrent_r (struct group *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct group **__restrict __result);
+libc_hidden_proto(getgrent_r)
# endif
/* Search for an entry with a matching group ID.
extern int getgrgid_r (__gid_t __gid, struct group *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct group **__restrict __result);
+libc_hidden_proto(getgrgid_r)
/* Search for an entry with a matching group name.
struct group *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct group **__restrict __result);
+libc_hidden_proto(getgrnam_r)
# ifdef __USE_SVID
/* Read a group entry from STREAM. This function is not standardized
struct group *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct group **__restrict __result);
+libc_hidden_proto(fgetgrent_r)
# endif
#endif /* POSIX or reentrant */
/* Set the group set for the current user to GROUPS (N of them). */
extern int setgroups (size_t __n, __const __gid_t *__groups) __THROW;
+libc_hidden_proto(setgroups)
/* Initialize the group set for the current user
by reading the group database and using all groups
it is usually in read-only memory and cannot be modified. */
extern char *nl_langinfo (nl_item __item) __THROW;
+libc_hidden_proto(nl_langinfo)
#ifdef __UCLIBC_HAS_XLOCALE__
/* Just like nl_langinfo but get the information from the locale object L. */
extern char *nl_langinfo_l (nl_item __item, __locale_t l);
+libc_hidden_proto(nl_langinfo_l)
#endif
#endif
/* sources are built w/ _GNU_SOURCE, this gets undefined */
#ifdef __USE_GNU
extern int __xpg_strerror_r (int __errnum, char *__buf, size_t __buflen);
+libc_hidden_proto(__xpg_strerror_r)
#else
extern char *__glibc_strerror_r (int __errnum, char *__buf, size_t __buflen);
+libc_hidden_proto(__glibc_strerror_r)
#endif
/* #include <pthread.h> */
/* Return the numeric/monetary information for the current locale. */
extern struct lconv *localeconv (void) __THROW;
+libc_hidden_proto(localeconv)
__END_NAMESPACE_STD
made by OR'ing together LC_*_MASK bits above. */
extern __locale_t newlocale (int __category_mask, __const char *__locale,
__locale_t __base) __THROW;
+libc_hidden_proto(newlocale)
/* These are the bits that can be set in the CATEGORY_MASK argument to
`newlocale'. In the GNU implementation, LC_FOO_MASK has the value
/* Return a duplicate of the set of locale in DATASET. All usage
counters are increased if necessary. */
extern __locale_t duplocale (__locale_t __dataset) __THROW;
+libc_hidden_proto(duplocale)
/* Free the data associated with a locale dataset previously returned
by a call to `setlocale_r'. */
/* Returns a copy of the updated current mallinfo. */
extern struct mallinfo mallinfo __MALLOC_P ((void));
+libc_hidden_proto(mallinfo)
/* Release all but __pad bytes of freed top-most memory back to the
system. Return 1 if successful, else 0. */
* if it returns. If __uc_malloc_failed is NULL, uclibc will _exit(1).
* NB: do not use stdio in __uc_malloc_failed handler! */
extern void *__uc_malloc(size_t size);
+libc_hidden_proto(__uc_malloc)
extern void (*__uc_malloc_failed)(size_t size);
+libc_hidden_proto(__uc_malloc_failed)
#ifdef __cplusplus
} /* end of extern "C" */
/* Prepare to begin reading and/or writing mount table entries from the
beginning of FILE. MODE is as for `fopen'. */
extern FILE *setmntent (__const char *__file, __const char *__mode) __THROW;
+libc_hidden_proto(setmntent)
/* Read one mount table entry from STREAM. Returns a pointer to storage
reused on the next call, or null for EOF or error (use feof/ferror to
struct mntent *__restrict __result,
char *__restrict __buffer,
int __bufsize) __THROW;
+libc_hidden_proto(getmntent_r)
#endif
/* Write the mount table entry described by MNT to STREAM.
/* Close a stream opened with `setmntent'. */
extern int endmntent (FILE *__stream) __THROW;
+libc_hidden_proto(endmntent)
/* Search MNT->mnt_opts for an option matching OPT.
Returns the address of the substring, or null if none found. */
/* Convert an interface name to an index, and vice versa. */
extern unsigned int if_nametoindex (__const char *__ifname) __THROW;
+libc_hidden_proto(if_nametoindex)
extern char *if_indextoname (unsigned int __ifindex, char *__ifname) __THROW;
/* Return a list of all interfaces and their indices. */
extern struct if_nameindex *if_nameindex (void) __THROW;
+libc_hidden_proto(if_nameindex)
/* Free the data returned from if_nameindex. */
extern void if_freenameindex (struct if_nameindex *__ptr) __THROW;
+libc_hidden_proto(if_freenameindex)
__END_DECLS
/* Function to get address of global `h_errno' variable. */
extern int *__h_errno_location (void) __THROW __attribute__ ((__const__));
+libc_hidden_proto(__h_errno_location)
#ifdef _LIBC
# define __set_h_errno(x) (h_errno = (x))
/* Print error indicated by `h_errno' variable on standard error. STR
if non-null is printed before the error string. */
extern void herror (__const char *__str) __THROW;
+libc_hidden_proto(herror)
/* Return string associated with error ERR_NUM. */
extern __const char *hstrerror (int __err_num) __THROW;
marked with __THROW. */
extern struct hostent *gethostbyaddr (__const void *__addr, __socklen_t __len,
int __type);
+libc_hidden_proto(gethostbyaddr)
/* Return entry from host data base for host with NAME.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern struct hostent *gethostbyname (__const char *__name);
+libc_hidden_proto(gethostbyname)
#ifdef __USE_MISC
/* Return entry from host data base for host with NAME. AF must be
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
+libc_hidden_proto(gethostent_r)
extern int gethostbyaddr_r (__const void *__restrict __addr, __socklen_t __len,
int __type,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
+libc_hidden_proto(gethostbyaddr_r)
extern int gethostbyname_r (__const char *__restrict __name,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
+libc_hidden_proto(gethostbyname_r)
extern int gethostbyname2_r (__const char *__restrict __name, int __af,
struct hostent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct hostent **__restrict __result,
int *__restrict __h_errnop);
+libc_hidden_proto(gethostbyname2_r)
#endif /* misc */
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void setnetent (int __stay_open);
+libc_hidden_proto(setnetent)
/* Close network data base files and clear `stay open' flag.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void endnetent (void);
+libc_hidden_proto(endnetent)
/* Get next entry from network data base file. Open data base if
necessary.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern struct netent *getnetent (void);
+libc_hidden_proto(getnetent)
/* Return entry from network data base which address match NET and
type TYPE.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void setservent (int __stay_open);
+libc_hidden_proto(setservent)
/* Close service data base files and clear `stay open' flag.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void endservent (void);
+libc_hidden_proto(endservent)
/* Get next entry from service data base file. Open data base if
necessary.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern struct servent *getservbyport (int __port, __const char *__proto);
+libc_hidden_proto(getservbyport)
#ifdef __USE_MISC
extern int getservent_r (struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
+libc_hidden_proto(getservent_r)
extern int getservbyname_r (__const char *__restrict __name,
__const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
+libc_hidden_proto(getservbyname_r)
extern int getservbyport_r (int __port, __const char *__restrict __proto,
struct servent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct servent **__restrict __result);
+libc_hidden_proto(getservbyport_r)
#endif /* misc */
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void setprotoent (int __stay_open);
+libc_hidden_proto(setprotoent)
/* Close protocol data base files and clear `stay open' flag.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void endprotoent (void);
+libc_hidden_proto(endprotoent)
/* Get next entry from protocol data base file. Open data base if
necessary.
extern int getprotoent_r (struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
+libc_hidden_proto(getprotoent_r)
extern int getprotobyname_r (__const char *__restrict __name,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
+libc_hidden_proto(getprotobyname_r)
extern int getprotobynumber_r (int __proto,
struct protoent *__restrict __result_buf,
char *__restrict __buf, size_t __buflen,
struct protoent **__restrict __result);
+libc_hidden_proto(getprotobynumber_r)
#ifdef __UCLIBC_HAS_NETGROUP__
/* ruserpass - remote password check.
This function also exists in glibc but is undocumented */
extern int ruserpass(const char *host, const char **aname, const char **apass);
+libc_hidden_proto(ruserpass)
#ifdef __USE_BSD
__const char *__restrict __pass,
__const char *__restrict __cmd, int *__restrict __fd2p,
sa_family_t __af);
+libc_hidden_proto(rexec_af)
/* Check whether user REMUSER on system RHOST is allowed to login as LOCUSER.
If SUSER is not zero the user tries to become superuser. Return 0 if
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int rresvport (int *__alport);
+libc_hidden_proto(rresvport)
#if 0
/* FIXME */
__const char *__restrict __service,
__const struct addrinfo *__restrict __req,
struct addrinfo **__restrict __pai);
+libc_hidden_proto(getaddrinfo)
/* Free `addrinfo' structure AI including associated storage. */
extern void freeaddrinfo (struct addrinfo *__ai) __THROW;
+libc_hidden_proto(freeaddrinfo)
/* Convert error return from getaddrinfo() to a string. */
extern __const char *gai_strerror (int __ecode) __THROW;
socklen_t __salen, char *__restrict __host,
socklen_t __hostlen, char *__restrict __serv,
socklen_t __servlen, unsigned int __flags);
+libc_hidden_proto(getnameinfo)
#endif /* POSIX */
__END_DECLS
extern char *ether_ntoa (__const struct ether_addr *__addr) __THROW;
extern char *ether_ntoa_r (__const struct ether_addr *__addr, char *__buf)
__THROW;
+libc_hidden_proto(ether_ntoa_r)
/* Convert ASCII string S to 48 bit Ethernet address. */
extern struct ether_addr *ether_aton (__const char *__asc) __THROW;
extern const struct in6_addr in6addr_any; /* :: */
extern const struct in6_addr in6addr_loopback; /* ::1 */
+libc_hidden_proto(in6addr_loopback)
#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
/* Bind socket to a privileged IP port. */
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) __THROW;
+libc_hidden_proto(bindresvport)
/* The IPv6 version of this function. */
extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
extern int getpwent_r (struct passwd *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct passwd **__restrict __result);
+libc_hidden_proto(getpwent_r)
# endif
extern int getpwuid_r (__uid_t __uid,
struct passwd *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct passwd **__restrict __result);
+libc_hidden_proto(getpwuid_r)
extern int getpwnam_r (__const char *__restrict __name,
struct passwd *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct passwd **__restrict __result);
+libc_hidden_proto(getpwnam_r)
# ifdef __USE_SVID
struct passwd *__restrict __resultbuf,
char *__restrict __buffer, size_t __buflen,
struct passwd **__restrict __result);
+libc_hidden_proto(fgetpwent_r)
# endif
#endif /* POSIX or reentrant */
void res_close (void) __THROW;
#endif
int res_init (void) __THROW;
+libc_hidden_proto(res_init)
int res_isourserver (const struct sockaddr_in *) __THROW;
int res_mkquery (int, const char *, int, int, const u_char *,
int, const u_char *, u_char *, int) __THROW;
int res_query (const char *, int, int, u_char *, int) __THROW;
+libc_hidden_proto(res_query)
int res_querydomain (const char *, const char *, int, int,
u_char *, int) __THROW;
+libc_hidden_proto(res_querydomain)
int res_search (const char *, int, int, u_char *, int) __THROW;
int res_send (const u_char *, int, u_char *, int) __THROW;
__END_DECLS
*/
extern AUTH *authunix_create (char *__machname, __uid_t __uid, __gid_t __gid,
int __len, __gid_t *__aup_gids);
+libc_hidden_proto(authunix_create)
extern AUTH *authunix_create_default (void);
+libc_hidden_proto(authunix_create_default)
extern AUTH *authnone_create (void) __THROW;
+libc_hidden_proto(authnone_create)
extern AUTH *authdes_create (const char *__servername, u_int __window,
struct sockaddr *__syncaddr, des_block *__ckey)
__THROW;
* XDR an opaque authentication struct.
*/
extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *) __THROW;
+libc_hidden_proto(xdr_opaque_auth)
__END_DECLS
extern int rtime (struct sockaddr_in *__addrp, struct rpc_timeval *__timep,
struct rpc_timeval *__timeout) __THROW;
+libc_hidden_proto(rtime)
__END_DECLS
extern bool_t xdr_authunix_parms (XDR *__xdrs, struct authunix_parms *__p)
__THROW;
+libc_hidden_proto(xdr_authunix_parms)
/*
* If a response verifier has flavor AUTH_SHORT,
extern CLIENT *clnttcp_create (struct sockaddr_in *__raddr, u_long __prog,
u_long __version, int *__sockp, u_int __sendsz,
u_int __recvsz) __THROW;
+libc_hidden_proto(clnttcp_create)
/*
* UDP based rpc.
extern CLIENT *clntudp_create (struct sockaddr_in *__raddr, u_long __program,
u_long __version, struct timeval __wait_resend,
int *__sockp) __THROW;
+libc_hidden_proto(clntudp_create)
extern CLIENT *clntudp_bufcreate (struct sockaddr_in *__raddr,
u_long __program, u_long __version,
struct timeval __wait_resend, int *__sockp,
u_int __sendsz, u_int __recvsz) __THROW;
-
-
+libc_hidden_proto(clntudp_bufcreate)
/*
extern CLIENT *clntunix_create (struct sockaddr_un *__raddr, u_long __program,
u_long __version, int *__sockp,
u_int __sendsz, u_int __recvsz) __THROW;
+libc_hidden_proto(clntunix_create)
extern int callrpc (__const char *__host, __const u_long __prognum,
__const xdrproc_t __inproc, __const char *__in,
__const xdrproc_t __outproc, char *__out) __THROW;
extern int _rpc_dtablesize (void) __THROW;
+libc_hidden_proto(_rpc_dtablesize)
/*
* Print why creation failed
*/
extern void clnt_pcreateerror (__const char *__msg); /* stderr */
extern char *clnt_spcreateerror(__const char *__msg) __THROW; /* string */
+libc_hidden_proto(clnt_spcreateerror)
/*
* Like clnt_perror(), but is more verbose in its output
*/
extern void clnt_perror (CLIENT *__clnt, __const char *__msg);
/* stderr */
+libc_hidden_proto(clnt_perror)
extern char *clnt_sperror (CLIENT *__clnt, __const char *__msg) __THROW;
/* string */
+libc_hidden_proto(clnt_sperror)
+
/*
* If a creation fails, the following allows the user to figure out why.
* Copy error message to buffer.
*/
extern char *clnt_sperrno (enum clnt_stat __num) __THROW; /* string */
+libc_hidden_proto(clnt_sperrno)
/*
* get the port number on the host for the rpc program,version and proto
};
extern void setrpcent (int __stayopen) __THROW;
+libc_hidden_proto(setrpcent)
extern void endrpcent (void) __THROW;
+libc_hidden_proto(endrpcent)
extern struct rpcent *getrpcbyname (__const char *__name) __THROW;
+libc_hidden_proto(getrpcbyname)
extern struct rpcent *getrpcbynumber (int __number) __THROW;
+libc_hidden_proto(getrpcbynumber)
extern struct rpcent *getrpcent (void) __THROW;
+libc_hidden_proto(getrpcent)
#if defined __USE_MISC && defined __UCLIBC_HAS_REENTRANT_RPC__
extern int getrpcbyname_r (__const char *__name, struct rpcent *__result_buf,
extern bool_t pmap_set (__const u_long __program, __const u_long __vers,
int __protocol, u_short __port) __THROW;
+libc_hidden_proto(pmap_set)
extern bool_t pmap_unset (__const u_long __program, __const u_long __vers)
__THROW;
+libc_hidden_proto(pmap_unset)
extern struct pmaplist *pmap_getmaps (struct sockaddr_in *__address) __THROW;
extern enum clnt_stat pmap_rmtcall (struct sockaddr_in *__addr,
__const u_long __prog,
__const u_long __program,
__const u_long __version, u_int __protocol)
__THROW;
+libc_hidden_proto(pmap_getport)
__END_DECLS
};
extern bool_t xdr_pmap (XDR *__xdrs, struct pmap *__regs) __THROW;
+libc_hidden_proto(xdr_pmap)
struct pmaplist {
struct pmap pml_map;
};
extern bool_t xdr_pmaplist (XDR *__xdrs, struct pmaplist **__rp) __THROW;
+libc_hidden_proto(xdr_pmaplist)
__END_DECLS
extern bool_t xdr_rmtcall_args (XDR *__xdrs, struct rmtcallargs *__crp)
__THROW;
+libc_hidden_proto(xdr_rmtcall_args)
+
struct rmtcallres {
u_long *port_ptr;
};
extern bool_t xdr_rmtcallres (XDR *__xdrs, struct rmtcallres *__crp) __THROW;
+libc_hidden_proto(xdr_rmtcallres)
__END_DECLS
/* Global variables, protected for multi-threaded applications. */
extern fd_set *__rpc_thread_svc_fdset (void) __attribute__ ((__const__));
+libc_hidden_proto(__rpc_thread_svc_fdset)
#define svc_fdset (*__rpc_thread_svc_fdset ())
extern struct rpc_createerr *__rpc_thread_createerr (void)
__attribute__ ((__const__));
+libc_hidden_proto(__rpc_thread_createerr)
#define get_rpc_createerr() (*__rpc_thread_createerr ())
/* The people who "engineered" RPC should bee punished for naming the
data structure and the variable the same. We cannot always define the
extern struct pollfd **__rpc_thread_svc_pollfd (void)
__attribute__ ((__const__));
+libc_hidden_proto(__rpc_thread_svc_pollfd)
#define svc_pollfd (*__rpc_thread_svc_pollfd ())
extern int *__rpc_thread_svc_max_pollfd (void) __attribute__ ((__const__));
+libc_hidden_proto(__rpc_thread_svc_max_pollfd)
#define svc_max_pollfd (*__rpc_thread_svc_max_pollfd ())
extern bool_t xdr_accepted_reply (XDR *xdrs, struct accepted_reply *ar);
+libc_hidden_proto(xdr_accepted_reply)
extern bool_t xdr_rejected_reply (XDR *xdrs, struct rejected_reply *rr);
+libc_hidden_proto(xdr_rejected_reply)
__END_DECLS
* struct rpc_msg *cmsg;
*/
extern bool_t xdr_callmsg (XDR *__xdrs, struct rpc_msg *__cmsg) __THROW;
+libc_hidden_proto(xdr_callmsg)
/*
* XDR routine to pre-serialize the static part of a rpc message.
* struct rpc_msg *cmsg;
*/
extern bool_t xdr_callhdr (XDR *__xdrs, struct rpc_msg *__cmsg) __THROW;
+libc_hidden_proto(xdr_callhdr)
/*
* XDR routine to handle a rpc reply.
*/
extern void _seterr_reply (struct rpc_msg *__msg, struct rpc_err *__error)
__THROW;
+libc_hidden_proto(_seterr_reply)
__END_DECLS
extern bool_t svc_register (SVCXPRT *__xprt, rpcprog_t __prog,
rpcvers_t __vers, __dispatch_fn_t __dispatch,
rpcprot_t __protocol) __THROW;
+libc_hidden_proto(svc_register)
/*
* Service un-registration
* rpcvers_t vers;
*/
extern void svc_unregister (rpcprog_t __prog, rpcvers_t __vers) __THROW;
+libc_hidden_proto(svc_unregister)
/*
* Transport registration.
* SVCXPRT *xprt;
*/
extern void xprt_register (SVCXPRT *__xprt) __THROW;
+libc_hidden_proto(xprt_register)
/*
* Transport un-register
* SVCXPRT *xprt;
*/
extern void xprt_unregister (SVCXPRT *__xprt) __THROW;
-
+libc_hidden_proto(xprt_unregister)
/*
* When the service routine is called, it must first check to see if it
extern bool_t svc_sendreply (SVCXPRT *xprt, xdrproc_t __xdr_results,
caddr_t __xdr_location) __THROW;
+libc_hidden_proto(svc_sendreply)
extern void svcerr_decode (SVCXPRT *__xprt) __THROW;
+libc_hidden_proto(svcerr_decode)
extern void svcerr_weakauth (SVCXPRT *__xprt) __THROW;
extern void svcerr_progvers (SVCXPRT *__xprt, rpcvers_t __low_vers,
rpcvers_t __high_vers) __THROW;
+libc_hidden_proto(svcerr_progvers)
extern void svcerr_auth (SVCXPRT *__xprt, enum auth_stat __why) __THROW;
+libc_hidden_proto(svcerr_auth)
extern void svcerr_noprog (SVCXPRT *__xprt) __THROW;
+libc_hidden_proto(svcerr_noprog)
extern void svcerr_systemerr (SVCXPRT *__xprt) __THROW;
* also see clnt.h for protocol numbers.
*/
extern void svc_getreq (int __rdfds) __THROW;
+libc_hidden_proto(svc_getreq)
extern void svc_getreq_common (const int __fd) __THROW;
+libc_hidden_proto(svc_getreq_common)
extern void svc_getreqset (fd_set *__readfds) __THROW;
+libc_hidden_proto(svc_getreqset)
extern void svc_getreq_poll (struct pollfd *, const int) __THROW;
+libc_hidden_proto(svc_getreq_poll)
extern void svc_exit (void) __THROW;
extern void svc_run (void) __THROW;
* Udp based rpc.
*/
extern SVCXPRT *svcudp_create (int __sock) __THROW;
+libc_hidden_proto(svcudp_create)
extern SVCXPRT *svcudp_bufcreate (int __sock, u_int __sendsz, u_int __recvsz)
__THROW;
+libc_hidden_proto(svcudp_bufcreate)
/*
* Tcp based rpc.
*/
extern enum auth_stat _authenticate (struct svc_req *__rqst,
struct rpc_msg *__msg) __THROW;
+libc_hidden_proto(_authenticate)
__END_DECLS
* also, the XDR structure is always updated by some of these calls.
*/
extern bool_t xdr_void (void) __THROW;
+libc_hidden_proto(xdr_void)
extern bool_t xdr_short (XDR *__xdrs, short *__sp) __THROW;
+libc_hidden_proto(xdr_short)
extern bool_t xdr_u_short (XDR *__xdrs, u_short *__usp) __THROW;
+libc_hidden_proto(xdr_u_short)
extern bool_t xdr_int (XDR *__xdrs, int *__ip) __THROW;
+libc_hidden_proto(xdr_int)
extern bool_t xdr_u_int (XDR *__xdrs, u_int *__up) __THROW;
+libc_hidden_proto(xdr_u_int)
extern bool_t xdr_long (XDR *__xdrs, long *__lp) __THROW;
+libc_hidden_proto(xdr_long)
extern bool_t xdr_u_long (XDR *__xdrs, u_long *__ulp) __THROW;
+libc_hidden_proto(xdr_u_long)
extern bool_t xdr_hyper (XDR *__xdrs, quad_t *__llp) __THROW;
+libc_hidden_proto(xdr_hyper)
extern bool_t xdr_u_hyper (XDR *__xdrs, u_quad_t *__ullp) __THROW;
+libc_hidden_proto(xdr_u_hyper)
extern bool_t xdr_longlong_t (XDR *__xdrs, quad_t *__llp) __THROW;
extern bool_t xdr_u_longlong_t (XDR *__xdrs, u_quad_t *__ullp) __THROW;
extern bool_t xdr_int8_t (XDR *__xdrs, int8_t *__ip) __THROW;
extern bool_t xdr_int64_t (XDR *__xdrs, int64_t *__ip) __THROW;
extern bool_t xdr_uint64_t (XDR *__xdrs, uint64_t *__up) __THROW;
extern bool_t xdr_bool (XDR *__xdrs, bool_t *__bp) __THROW;
+libc_hidden_proto(xdr_bool)
extern bool_t xdr_enum (XDR *__xdrs, enum_t *__ep) __THROW;
+libc_hidden_proto(xdr_enum)
extern bool_t xdr_array (XDR * _xdrs, caddr_t *__addrp, u_int *__sizep,
u_int __maxsize, u_int __elsize, xdrproc_t __elproc)
__THROW;
+libc_hidden_proto(xdr_array)
extern bool_t xdr_bytes (XDR *__xdrs, char **__cpp, u_int *__sizep,
u_int __maxsize) __THROW;
+libc_hidden_proto(xdr_bytes)
extern bool_t xdr_opaque (XDR *__xdrs, caddr_t __cp, u_int __cnt) __THROW;
+libc_hidden_proto(xdr_opaque)
extern bool_t xdr_string (XDR *__xdrs, char **__cpp, u_int __maxsize) __THROW;
+libc_hidden_proto(xdr_string)
extern bool_t xdr_union (XDR *__xdrs, enum_t *__dscmp, char *__unp,
__const struct xdr_discrim *__choices,
xdrproc_t dfault) __THROW;
+libc_hidden_proto(xdr_union)
extern bool_t xdr_char (XDR *__xdrs, char *__cp) __THROW;
extern bool_t xdr_u_char (XDR *__xdrs, u_char *__cp) __THROW;
extern bool_t xdr_vector (XDR *__xdrs, char *__basep, u_int __nelem,
extern bool_t xdr_double (XDR *__xdrs, double *__dp) __THROW;
extern bool_t xdr_reference (XDR *__xdrs, caddr_t *__xpp, u_int __size,
xdrproc_t __proc) __THROW;
+libc_hidden_proto(xdr_reference)
extern bool_t xdr_pointer (XDR *__xdrs, char **__objpp,
u_int __obj_size, xdrproc_t __xdr_obj) __THROW;
extern bool_t xdr_wrapstring (XDR *__xdrs, char **__cpp) __THROW;
u_int __recvsize, caddr_t __tcp_handle,
int (*__readit) (char *, char *, int),
int (*__writeit) (char *, char *, int)) __THROW;
+libc_hidden_proto(xdrrec_create)
/* make end of xdr record */
extern bool_t xdrrec_endofrecord (XDR *__xdrs, bool_t __sendnow) __THROW;
+libc_hidden_proto(xdrrec_endofrecord)
/* move to beginning of next record */
extern bool_t xdrrec_skiprecord (XDR *__xdrs) __THROW;
+libc_hidden_proto(xdrrec_skiprecord)
/* true if no more input */
extern bool_t xdrrec_eof (XDR *__xdrs) __THROW;
+libc_hidden_proto(xdrrec_eof)
/* free memory buffers for xdr */
extern void xdr_free (xdrproc_t __proc, char *__objp) __THROW;
same time. */
extern int hsearch_r (ENTRY __item, ACTION __action, ENTRY **__retval,
struct hsearch_data *__htab) __THROW;
+libc_hidden_proto(hsearch_r)
extern int hcreate_r (size_t __nel, struct hsearch_data *__htab) __THROW;
+libc_hidden_proto(hcreate_r)
extern void hdestroy_r (struct hsearch_data *__htab) __THROW;
+libc_hidden_proto(hdestroy_r)
#endif
by *ROOTP and insert a new element if not found. */
extern void *tsearch (__const void *__key, void **__rootp,
__compar_fn_t __compar);
+libc_hidden_proto(tsearch)
/* Search for an entry matching the given KEY in the tree pointed to
by *ROOTP. If no matching entry is available return NULL. */
extern void *tfind (__const void *__key, void *__const *__rootp,
__compar_fn_t __compar);
+libc_hidden_proto(tfind)
/* Remove the element matching KEY from the tree pointed to by *ROOTP. */
extern void *tdelete (__const void *__restrict __key,
/* Destroy the whole tree, call FREEFCT for each node or leaf. */
extern void tdestroy (void *__root, __free_fn_t __freefct);
+libc_hidden_proto(tdestroy)
#endif
[BASE,BASE+NMEMB*SIZE). */
extern void *lfind (__const void *__key, __const void *__base,
size_t *__nmemb, size_t __size, __compar_fn_t __compar);
+libc_hidden_proto(lfind)
/* Perform linear search for KEY by comparing by COMPAR function in
array [BASE,BASE+NMEMB*SIZE) and insert entry if not found. */
therefore not marked with __THROW. */
extern int getspent_r (struct spwd *__result_buf, char *__buffer,
size_t __buflen, struct spwd **__result);
+libc_hidden_proto(getspent_r)
extern int getspnam_r (__const char *__name, struct spwd *__result_buf,
char *__buffer, size_t __buflen,
struct spwd **__result);
+libc_hidden_proto(getspnam_r)
extern int sgetspent_r (__const char *__string, struct spwd *__result_buf,
char *__buffer, size_t __buflen,
struct spwd **__result);
+libc_hidden_proto(sgetspent_r)
extern int fgetspent_r (FILE *__stream, struct spwd *__result_buf,
char *__buffer, size_t __buflen,
struct spwd **__result);
+libc_hidden_proto(fgetspent_r)
#endif /* misc */
#if defined __USE_BSD || !defined __UCLIBC_HAS_OBSOLETE_SYSV_SIGNAL__
extern __sighandler_t signal (int __sig, __sighandler_t __handler)
__THROW;
+libc_hidden_proto(signal)
#else
/* Make sure the used `signal' implementation is the SVID version. */
# ifdef __REDIRECT_NTH
If PID is < -1, send SIG to all processes in process group - PID. */
#ifdef __USE_POSIX
extern int kill (__pid_t __pid, int __sig) __THROW;
+libc_hidden_proto(kill)
#endif /* Use POSIX. */
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
__BEGIN_NAMESPACE_STD
/* Raise signal SIG, i.e., send SIG to yourself. */
extern int raise (int __sig) __THROW;
+libc_hidden_proto(raise)
__END_NAMESPACE_STD
#ifdef __USE_SVID
This function is a cancellation point and therefore not marked with
__THROW. */
extern int __sigpause (int __sig_or_mask, int __is_sig);
+libc_hidden_proto(__sigpause)
#ifdef __FAVOR_BSD
/* Set the mask of blocked signals to MASK,
wait for a signal to arrive, and then restore the mask. */
extern int sigpause (int __mask) __THROW __attribute_deprecated__;
+libc_hidden_proto(sigpause)
# define sigpause(mask) __sigpause ((mask), 0)
#else
# ifdef __USE_XOPEN
# define sigmask(sig) __sigmask(sig)
/* Block signals in MASK, returning the old mask. */
-extern int sigblock (int __mask) __THROW __attribute_deprecated__;
+extern int sigblock (int __mask) __THROW;
+/* collides with libc_hidden_proto: __attribute_deprecated__; */
+libc_hidden_proto(sigblock)
/* Set the mask of blocked signals to MASK, returning the old mask. */
-extern int sigsetmask (int __mask) __THROW __attribute_deprecated__;
+extern int sigsetmask (int __mask) __THROW;
+/* collides with libc_hidden_proto: __attribute_deprecated__; */
+libc_hidden_proto(sigsetmask)
/* Return currently selected signal mask. */
extern int siggetmask (void) __THROW __attribute_deprecated__;
/* Clear all signals from SET. */
extern int sigemptyset (sigset_t *__set) __THROW __nonnull ((1));
+libc_hidden_proto(sigemptyset)
/* Set all signals in SET. */
extern int sigfillset (sigset_t *__set) __THROW __nonnull ((1));
+libc_hidden_proto(sigfillset)
/* Add SIGNO to SET. */
extern int sigaddset (sigset_t *__set, int __signo) __THROW __nonnull ((1));
+libc_hidden_proto(sigaddset)
/* Remove SIGNO from SET. */
extern int sigdelset (sigset_t *__set, int __signo) __THROW __nonnull ((1));
+libc_hidden_proto(sigdelset)
/* Return 1 if SIGNO is in SET, 0 if not. */
extern int sigismember (__const sigset_t *__set, int __signo)
This function is a cancellation point and therefore not marked with
__THROW. */
extern int sigsuspend (__const sigset_t *__set) __nonnull ((1));
+libc_hidden_proto(sigsuspend)
/* Get and/or set the action for signal SIG. */
extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
__THROW. */
extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
__nonnull ((1, 2));
+libc_hidden_proto(sigwait)
# if defined __USE_POSIX199309 && defined __UCLIBC_HAS_REALTIME__
/* Select any of pending signals from SET and place information in INFO.
__THROW. */
extern int sigwaitinfo (__const sigset_t *__restrict __set,
siginfo_t *__restrict __info) __nonnull ((1));
+libc_hidden_proto(sigwaitinfo)
/* Select any of pending signals from SET and place information in INFO.
Wait the time specified by TIMEOUT if no signal is pending.
siginfo_t *__restrict __info,
__const struct timespec *__restrict __timeout)
__nonnull ((1));
+libc_hidden_proto(sigtimedwait)
/* Send signal SIG to the process PID. Associate data in VAL with the
signal. */
__BEGIN_NAMESPACE_STD
/* Remove file FILENAME. */
extern int remove (__const char *__filename) __THROW;
+libc_hidden_proto(remove)
/* Rename file OLD to NEW. */
extern int rename (__const char *__old, __const char *__new) __THROW;
__END_NAMESPACE_STD
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int fflush (FILE *__stream);
+libc_hidden_proto(fflush)
__END_NAMESPACE_STD
#ifdef __USE_MISC
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int fflush_unlocked (FILE *__stream);
+libc_hidden_proto(fflush_unlocked)
#endif
#ifdef __USE_GNU
#ifdef __USE_POSIX
/* Create a new stream that refers to an existing system file descriptor. */
extern FILE *fdopen (int __fd, __const char *__modes) __THROW __wur;
+libc_hidden_proto(fdopen)
#endif
#ifdef __USE_GNU
extern FILE *fopencookie (void *__restrict __magic_cookie,
__const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) __THROW __wur;
+libc_hidden_proto(fopencookie)
/* Create a new stream that refers to a memory buffer. */
extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
and the number of characters written on fflush or fclose. */
extern FILE *open_memstream (char **__restrict __bufloc,
size_t *__restrict __sizeloc) __THROW __wur;
+libc_hidden_proto(open_memstream)
#endif
#endif
else allocate an internal buffer N bytes long. */
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) __THROW;
+libc_hidden_proto(setvbuf)
__END_NAMESPACE_STD
#ifdef __USE_BSD
extern int snprintf (char *__restrict __s, size_t __maxlen,
__const char *__restrict __format, ...)
__THROW __attribute__ ((__format__ (__printf__, 3, 4)));
+libc_hidden_proto(snprintf)
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
__const char *__restrict __format, __gnuc_va_list __arg)
__THROW __attribute__ ((__format__ (__printf__, 3, 0)));
+libc_hidden_proto(vsnprintf)
__END_NAMESPACE_C99
#endif
extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
__gnuc_va_list __arg)
__THROW __attribute__ ((__format__ (__printf__, 2, 0))) __wur;
+libc_hidden_proto(vasprintf)
#if 0 /* uClibc: disabled */
extern int __asprintf (char **__restrict __ptr,
__const char *__restrict __fmt, ...)
extern int asprintf (char **__restrict __ptr,
__const char *__restrict __fmt, ...)
__THROW __attribute__ ((__format__ (__printf__, 2, 3))) __wur;
+libc_hidden_proto(asprintf)
/* Write formatted output to a file descriptor.
extern int vdprintf (int __fd, __const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
+libc_hidden_proto(vdprintf)
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
#endif
marked with __THROW. */
extern int fscanf (FILE *__restrict __stream,
__const char *__restrict __format, ...) __wur;
+libc_hidden_proto(fscanf)
/* Read formatted input from stdin.
This function is a possible cancellation point and therefore not
/* Read formatted input from S. */
extern int sscanf (__const char *__restrict __s,
__const char *__restrict __format, ...) __THROW;
+libc_hidden_proto(sscanf)
__END_NAMESPACE_STD
#ifdef __USE_ISOC99
extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) __wur;
+libc_hidden_proto(vfscanf)
/* Read formatted input from stdin into argument list ARG.
marked with __THROW. */
extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) __wur;
+libc_hidden_proto(vscanf)
/* Read formatted input from S into argument list ARG. */
extern int vsscanf (__const char *__restrict __s,
__const char *__restrict __format, __gnuc_va_list __arg)
__THROW __attribute__ ((__format__ (__scanf__, 2, 0)));
+libc_hidden_proto(vsscanf)
__END_NAMESPACE_C99
#endif /* Use ISO C9x. */
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern int fgetc (FILE *__stream);
+libc_hidden_proto(fgetc)
extern int getc (FILE *__stream);
/* Read a character from stdin.
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern int getc_unlocked (FILE *__stream);
+libc_hidden_proto(getc_unlocked)
extern int getchar_unlocked (void);
+libc_hidden_proto(getchar_unlocked)
/* SUSv3 allows getc_unlocked to be a macro */
#define getc_unlocked(_fp) __GETC_UNLOCKED(_fp)
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int fgetc_unlocked (FILE *__stream);
+libc_hidden_proto(fgetc_unlocked)
#endif /* Use MISC. */
These functions is a possible cancellation point and therefore not
marked with __THROW. */
extern int fputc (int __c, FILE *__stream);
+libc_hidden_proto(fputc)
extern int putc (int __c, FILE *__stream);
+libc_hidden_proto(putc)
/* Write a character to stdout.
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern int fputc_unlocked (int __c, FILE *__stream);
+libc_hidden_proto(fputc_unlocked)
#endif /* Use MISC. */
#if defined __USE_POSIX || defined __USE_MISC
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern int putc_unlocked (int __c, FILE *__stream);
+libc_hidden_proto(putc_unlocked)
extern int putchar_unlocked (int __c);
/* SUSv3 allows putc_unlocked to be a macro */
therefore not marked with __THROW. */
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) __wur;
+libc_hidden_proto(fgets_unlocked)
#endif
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) __wur;
+libc_hidden_proto(getdelim)
/* Like `getdelim', but reads up to a newline.
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) __wur;
+libc_hidden_proto(getline)
#endif
This function is a possible cancellation points and therefore not
marked with __THROW. */
extern int ungetc (int __c, FILE *__stream);
+libc_hidden_proto(ungetc)
/* Read chunks of generic data from STREAM.
marked with __THROW. */
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) __wur;
+libc_hidden_proto(fread)
/* Write chunks of generic data to STREAM.
This function is a possible cancellation points and therefore not
marked with __THROW. */
extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s) __wur;
+libc_hidden_proto(fwrite)
__END_NAMESPACE_STD
#ifdef __USE_GNU
therefore not marked with __THROW. */
extern int fputs_unlocked (__const char *__restrict __s,
FILE *__restrict __stream);
+libc_hidden_proto(fputs_unlocked)
#endif
#ifdef __USE_MISC
therefore not marked with __THROW. */
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) __wur;
+libc_hidden_proto(fread_unlocked)
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) __wur;
+libc_hidden_proto(fwrite_unlocked)
#endif
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern int fseek (FILE *__stream, long int __off, int __whence);
+libc_hidden_proto(fseek)
/* Return the current position of STREAM.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern long int ftell (FILE *__stream) __wur;
+libc_hidden_proto(ftell)
/* Rewind to the beginning of STREAM.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void rewind (FILE *__stream);
+libc_hidden_proto(rewind)
__END_NAMESPACE_STD
/* The Single Unix Specification, Version 2, specifies an alternative,
#ifdef __USE_LARGEFILE64
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+libc_hidden_proto(fseeko64)
extern __off64_t ftello64 (FILE *__stream) __wur;
+libc_hidden_proto(ftello64)
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
#endif
#ifdef __USE_POSIX
/* Return the system file descriptor for STREAM. */
extern int fileno (FILE *__stream) __THROW __wur;
+libc_hidden_proto(fileno)
#endif /* Use POSIX. */
#ifdef __USE_MISC
/* Faster version when locking is not required. */
extern int fileno_unlocked (FILE *__stream) __THROW __wur;
+libc_hidden_proto(fileno_unlocked)
#endif
/* Set locking status of stream FP to TYPE. */
extern int __fsetlocking (FILE *__fp, int __type) __THROW;
+libc_hidden_proto(__fsetlocking)
__END_DECLS
#ifdef __UCLIBC_HAS_WCHAR__
#define MB_CUR_MAX (_stdlib_mb_cur_max ())
extern size_t _stdlib_mb_cur_max (void) __THROW __wur;
+libc_hidden_proto(_stdlib_mb_cur_max)
#endif
/* Convert a string to an integer. */
extern int atoi (__const char *__nptr)
__THROW __attribute_pure__ __nonnull ((1)) __wur;
+libc_hidden_proto(atoi)
/* Convert a string to a long integer. */
extern long int atol (__const char *__nptr)
__THROW __attribute_pure__ __nonnull ((1)) __wur;
+libc_hidden_proto(atol)
__END_NAMESPACE_STD
#if defined __USE_ISOC99 || defined __USE_MISC
extern double strtod (__const char *__restrict __nptr,
char **__restrict __endptr)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(strtod)
__END_NAMESPACE_STD
#ifdef __USE_ISOC99
extern long int strtol (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(strtol)
/* Convert a string to an unsigned long integer. */
extern unsigned long int strtoul (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(strtoul)
__END_NAMESPACE_STD
#ifdef __USE_BSD
extern long long int strtoll (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(strtoll)
/* Convert a string to an unsigned quadword integer. */
__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
extern long int strtol_l (__const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) __THROW __nonnull ((1, 4)) __wur;
+libc_hidden_proto(strtol_l)
extern unsigned long int strtoul_l (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
__THROW __nonnull ((1, 4)) __wur;
+libc_hidden_proto(strtoul_l)
__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
We provide both interfaces to the same random number generator. */
/* Return a random long integer between 0 and RAND_MAX inclusive. */
extern long int random (void) __THROW;
+libc_hidden_proto(random)
/* Seed the random number generator with the given number. */
extern void srandom (unsigned int __seed) __THROW;
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) __THROW __nonnull ((1, 2));
+libc_hidden_proto(random_r)
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
__THROW __nonnull ((2));
+libc_hidden_proto(srandom_r)
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
__THROW __nonnull ((2, 4));
+libc_hidden_proto(initstate_r)
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(setstate_r)
# endif /* Use misc. */
#endif /* Use SVID || extended X/Open || BSD. */
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) __THROW __nonnull ((1, 2));
+libc_hidden_proto(erand48_r)
#endif /* __UCLIBC_HAS_FLOATS__ */
/* Return non-negative, long integer in [0,2^31). */
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(lrand48_r)
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(nrand48_r)
/* Return signed, long integers in [-2^31,2^31). */
extern int mrand48_r (struct drand48_data *__restrict __buffer,
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(jrand48_r)
/* Seed random number generator. */
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
__THROW __nonnull ((2));
+libc_hidden_proto(srand48_r)
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) __THROW __nonnull ((1, 2));
+libc_hidden_proto(seed48_r)
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
If REPLACE is nonzero, overwrite an existing value. */
extern int setenv (__const char *__name, __const char *__value, int __replace)
__THROW __nonnull ((2));
+libc_hidden_proto(setenv)
/* Remove the variable NAME from the environment. */
extern int unsetenv (__const char *__name) __THROW;
+libc_hidden_proto(unsetenv)
#endif
/* The following is used by uClibc in atexit.c and sysconf.c */
using COMPAR to perform the comparisons. */
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __nonnull ((1, 4));
+libc_hidden_proto(qsort)
/* Return the absolute value of X. */
Return 0 on success, otherwise an error number. */
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
__THROW __nonnull ((2));
+libc_hidden_proto(ptsname_r)
# endif
# if defined __UCLIBC_HAS_GETPT__
/* Open a master pseudo terminal and return its file descriptor. */
#include <stdint.h>
extern uint32_t arc4random(void);
extern void arc4random_stir(void);
+libc_hidden_proto(arc4random_stir)
extern void arc4random_addrandom(unsigned char *, int);
#endif
ERRNUM. */
extern int __xpg_strerror_r (int __errnum, char *__buf, size_t __buflen)
__THROW __nonnull ((2));
+libc_hidden_proto(__xpg_strerror_r)
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (strerror_r,
(int __errnum, char *__buf, size_t __buflen),
used. */
extern char *__glibc_strerror_r (int __errnum, char *__buf, size_t __buflen)
__THROW __nonnull ((2));
+libc_hidden_proto(__glibc_strerror_r)
# ifdef __REDIRECT_NTH
extern char * __REDIRECT_NTH (strerror_r,
(int __errnum, char *__buf, size_t __buflen),
/* Deallocate any mapping for the region starting at ADDR and extending LEN
bytes. Returns 0 if successful, -1 for errors (and sets errno). */
extern int munmap (void *__addr, size_t __len) __THROW;
+libc_hidden_proto(munmap)
/* Change the memory protection of the region starting at ADDR and
extending LEN bytes to PROT. Returns 0 if successful, -1 for errors
resides after a successful call. */
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
int __flags, ...) __THROW;
+libc_hidden_proto(mremap)
#ifdef __UCLIBC_LINUX_SPECIFIC__
/* Remap arbitrary pages of a shared backing store within an existing
extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
__const struct timespec *__timeout,
__const __sigset_t *__ss);
+libc_hidden_proto(ppoll)
#endif
__END_DECLS
#ifndef __USE_FILE_OFFSET64
extern int getrlimit (__rlimit_resource_t __resource,
struct rlimit *__rlimits) __THROW;
+libc_hidden_proto(getrlimit)
#else
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (getrlimit, (__rlimit_resource_t __resource,
#ifndef __USE_FILE_OFFSET64
extern int setrlimit (__rlimit_resource_t __resource,
__const struct rlimit *__rlimits) __THROW;
+libc_hidden_proto(setrlimit)
#else
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (setrlimit, (__rlimit_resource_t __resource,
(as specified by WHO) is used. A lower priority number means higher
priority. Priorities range from PRIO_MIN to PRIO_MAX (above). */
extern int getpriority (__priority_which_t __which, id_t __who) __THROW;
+libc_hidden_proto(getpriority)
/* Set the priority of all processes specified by WHICH and WHO (see above)
to PRIO. Returns 0 on success, -1 on errors. */
extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
__THROW;
+libc_hidden_proto(setpriority)
__END_DECLS
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
+libc_hidden_proto(select)
#ifdef __USE_XOPEN2K
/* Same as above only that the TIMEOUT value is given with higher
/* Give the socket FD the local address ADDR (which is LEN bytes long). */
extern int bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
__THROW;
+libc_hidden_proto(bind)
/* Put the local address of FD into *ADDR and its length in *LEN. */
extern int getsockname (int __fd, __SOCKADDR_ARG __addr,
socklen_t *__restrict __len) __THROW;
+libc_hidden_proto(getsockname)
/* Open a connection on socket FD to peer at ADDR (which LEN bytes long).
For connectionless socket types, just set the default address to send to
This function is a cancellation point and therefore not marked with
__THROW. */
extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);
+libc_hidden_proto(connect)
/* Put the address of the peer connected to socket FD into *ADDR
(which is *LEN bytes long), and its actual length into *LEN. */
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t send (int __fd, __const void *__buf, size_t __n, int __flags);
+libc_hidden_proto(send)
/* Read N bytes into BUF from socket FD.
Returns the number read or -1 for errors.
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
+libc_hidden_proto(recv)
/* Send N bytes of BUF on socket FD to peer at address ADDR (which is
ADDR_LEN bytes long). Returns the number sent, or -1 for errors.
extern ssize_t sendto (int __fd, __const void *__buf, size_t __n,
int __flags, __CONST_SOCKADDR_ARG __addr,
socklen_t __addr_len);
+libc_hidden_proto(sendto)
/* Read N bytes into BUF through socket FD.
If ADDR is not NULL, fill in *ADDR_LEN bytes of it with tha address of
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, __SOCKADDR_ARG __addr,
socklen_t *__restrict __addr_len);
+libc_hidden_proto(recvfrom)
/* Send a message described MESSAGE on socket FD.
__THROW. */
extern ssize_t sendmsg (int __fd, __const struct msghdr *__message,
int __flags);
+libc_hidden_proto(sendmsg)
/* Receive a message as described by MESSAGE from socket FD.
Returns the number of bytes read or -1 for errors.
This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
+libc_hidden_proto(recvmsg)
/* Put the current value for socket FD's option OPTNAME at protocol level LEVEL
Returns 0 on success, -1 for errors. */
extern int setsockopt (int __fd, int __level, int __optname,
__const void *__optval, socklen_t __optlen) __THROW;
+libc_hidden_proto(setsockopt)
/* Prepare to accept connections on socket FD.
N connection requests will be queued before further requests are refused.
Returns 0 on success, -1 for errors. */
extern int listen (int __fd, int __n) __THROW;
+libc_hidden_proto(listen)
/* Await a connection on socket FD.
When a connection arrives, open a new socket to communicate with it,
__THROW. */
extern int accept (int __fd, __SOCKADDR_ARG __addr,
socklen_t *__restrict __addr_len);
+libc_hidden_proto(accept)
/* Shut down all or part of the connection open on socket FD.
HOW determines what to shut down:
extern int stat64 (__const char *__restrict __file,
struct stat64 *__restrict __buf) __THROW __nonnull ((1, 2));
extern int fstat64 (int __fd, struct stat64 *__buf) __THROW __nonnull ((2));
+libc_hidden_proto(stat64)
+libc_hidden_proto(fstat64)
#endif
#ifdef __USE_ATFILE
extern int lstat64 (__const char *__restrict __file,
struct stat64 *__restrict __buf)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(lstat64)
# endif
#endif
If FILE is a symbolic link, this affects its target instead. */
extern int chmod (__const char *__file, __mode_t __mode)
__THROW __nonnull ((1));
+libc_hidden_proto(chmod)
#if 0 /*def __USE_BSD*/
/* Set file access permissions for FILE to MODE.
/* Create a new directory named PATH, with permission bits MODE. */
extern int mkdir (__const char *__path, __mode_t __mode)
__THROW __nonnull ((1));
+libc_hidden_proto(mkdir)
#ifdef __USE_ATFILE
/* Like mkdir, create a new directory with permission bits MODE. But
#if defined __USE_MISC || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
__THROW __nonnull ((1));
+libc_hidden_proto(mknod)
#endif
#ifdef __USE_ATFILE
#ifdef __USE_LARGEFILE64
extern int statfs64 (__const char *__file, struct statfs64 *__buf)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(statfs64)
#endif
#if defined __UCLIBC_LINUX_SPECIFIC__
#ifdef __USE_LARGEFILE64
extern int fstatfs64 (int __fildes, struct statfs64 *__buf)
__THROW __nonnull ((2));
+libc_hidden_proto(fstatfs64)
#endif
#endif /* __UCLIBC_LINUX_SPECIFIC__ */
extern int statvfs (__const char *__restrict __file,
struct statvfs *__restrict __buf)
__THROW __nonnull ((1, 2));
+libc_hidden_proto(statvfs)
#else
# ifdef __REDIRECT
extern int __REDIRECT (statvfs,
#ifndef __USE_FILE_OFFSET64
extern int fstatvfs (int __fildes, struct statvfs *__buf)
__THROW __nonnull ((2));
+libc_hidden_proto(fstatvfs)
#else
# ifdef __REDIRECT
extern int __REDIRECT (fstatvfs, (int __fildes, struct statvfs *__buf),
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void closelog (void);
+libc_hidden_proto(closelog)
/* Open connection to system logger.
This function is a possible cancellation point and therefore not
marked with __THROW. */
extern void openlog (__const char *__ident, int __option, int __facility);
+libc_hidden_proto(openlog)
/* Set the log mask level. */
extern int setlogmask (int __mask) __THROW;
marked with __THROW. */
extern void syslog (int __pri, __const char *__fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
+libc_hidden_proto(syslog)
#ifdef __USE_BSD
/* Generate a log message using FMT and using arguments pointed to by AP.
therefore not marked with __THROW. */
extern void vsyslog (int __pri, __const char *__fmt, __gnuc_va_list __ap)
__attribute__ ((__format__ (__printf__, 2, 0)));
+libc_hidden_proto(vsyslog)
#endif
__END_DECLS
extern int settimeofday (__const struct timeval *__tv,
__const struct timezone *__tz)
__THROW __nonnull ((1));
+libc_hidden_proto(settimeofday)
/* Adjust the current time of day by the amount in DELTA.
If OLDDELTA is not NULL, it is filled in with the amount
extern int setitimer (__itimer_which_t __which,
__const struct itimerval *__restrict __new,
struct itimerval *__restrict __old) __THROW;
+libc_hidden_proto(setitimer)
/* Change the access time of FILE to TVP[0] and the modification time of
FILE to TVP[1]. If TVP is a null pointer, use the current time instead.
Returns 0 on success, -1 on errors. */
extern int utimes (__const char *__file, __const struct timeval __tvp[2])
__THROW __nonnull ((1));
+libc_hidden_proto(utimes)
#if 0 /*def __USE_BSD*/
/* Same as `utimes', but does not follow symbolic links. */
Return the elapsed real time, or (clock_t) -1 for errors.
All times are in CLK_TCKths of a second. */
extern clock_t times (struct tms *__buffer) __THROW;
+libc_hidden_proto(times)
__END_DECLS
extern int __adjtimex (struct timex *__ntx) __THROW;
extern int adjtimex (struct timex *__ntx) __THROW;
+libc_hidden_proto(adjtimex)
#if defined __UCLIBC_NTP_LEGACY__
extern int ntp_gettime (struct ntptimeval *__ntv) __THROW;
/* Put information about the system in NAME. */
extern int uname (struct utsname *__name) __THROW;
+libc_hidden_proto(uname)
__END_DECLS
This function is a cancellation point and therefore not marked with
__THROW. */
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
+libc_hidden_proto(waitpid)
#if defined __USE_SVID || defined __USE_XOPEN
# define __need_siginfo_t
/* PID is like waitpid. Other args are like wait3. */
extern __pid_t wait4 (__pid_t __pid, __WAIT_STATUS __stat_loc, int __options,
struct rusage *__usage) __THROW;
+libc_hidden_proto(wait4)
#endif /* Use BSD. */
/* Set the output baud rate stored in *TERMIOS_P to SPEED. */
extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) __THROW;
+libc_hidden_proto(cfsetospeed)
/* Set the input baud rate stored in *TERMIOS_P to SPEED. */
extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) __THROW;
+libc_hidden_proto(cfsetispeed)
#ifdef __USE_BSD
/* Set both the input and output baud rates in *TERMIOS_OP to SPEED. */
/* Put the state of FD into *TERMIOS_P. */
extern int tcgetattr (int __fd, struct termios *__termios_p) __THROW;
+libc_hidden_proto(tcgetattr)
/* Set the state of FD to *TERMIOS_P.
Values for OPTIONAL_ACTIONS (TCSA*) are in <bits/termios.h>. */
extern int tcsetattr (int __fd, int __optional_actions,
__const struct termios *__termios_p) __THROW;
+libc_hidden_proto(tcsetattr)
#ifdef __USE_BSD
extern size_t strftime (char *__restrict __s, size_t __maxsize,
__const char *__restrict __format,
__const struct tm *__restrict __tp) __THROW;
+libc_hidden_proto(strftime)
__END_NAMESPACE_STD
# ifdef __USE_XOPEN
extern char *strptime (__const char *__restrict __s,
__const char *__restrict __fmt, struct tm *__tp)
__THROW;
+libc_hidden_proto(strptime)
# endif
#ifdef __UCLIBC_HAS_XLOCALE__
__const char *__restrict __format,
__const struct tm *__restrict __tp,
__locale_t __loc) __THROW;
+libc_hidden_proto(strftime_l)
extern char *strptime_l (__const char *__restrict __s,
__const char *__restrict __fmt, struct tm *__tp,
__locale_t __loc) __THROW;
+libc_hidden_proto(strptime_l)
# endif
#endif
/* Return the `struct tm' representation
of *TIMER in the local timezone. */
extern struct tm *localtime (__const time_t *__timer) __THROW;
+libc_hidden_proto(localtime)
__END_NAMESPACE_STD
# if defined __USE_POSIX || defined __USE_MISC
using *TP to store the result. */
extern struct tm *localtime_r (__const time_t *__restrict __timer,
struct tm *__restrict __tp) __THROW;
+libc_hidden_proto(localtime_r)
# endif /* POSIX or misc */
__BEGIN_NAMESPACE_STD
/* Return a string of the form "Day Mon dd hh:mm:ss yyyy\n"
that is the representation of TP in this format. */
extern char *asctime (__const struct tm *__tp) __THROW;
+libc_hidden_proto(asctime)
/* Equivalent to `asctime (localtime (timer))'. */
extern char *ctime (__const time_t *__timer) __THROW;
+libc_hidden_proto(ctime)
__END_NAMESPACE_STD
# if defined __USE_POSIX || defined __USE_MISC
that is the representation of TP in this format. */
extern char *asctime_r (__const struct tm *__restrict __tp,
char *__restrict __buf) __THROW;
+libc_hidden_proto(asctime_r)
/* Equivalent to `asctime_r (localtime_r (timer, *TMP*), buf)'. */
extern char *ctime_r (__const time_t *__restrict __timer,
/* Set time conversion information from the TZ environment variable.
If TZ is not defined, a locale-dependent default is used. */
extern void tzset (void) __THROW;
+libc_hidden_proto(tzset)
# endif
# if defined __USE_SVID || defined __USE_XOPEN
__THROW. */
extern int nanosleep (__const struct timespec *__requested_time,
struct timespec *__remaining);
+libc_hidden_proto(nanosleep)
/* Get resolution of clock CLOCK_ID. */
__BEGIN_DECLS
extern struct ttyent *getttyent (void) __THROW;
+libc_hidden_proto(getttyent)
extern struct ttyent *getttynam (__const char *__tty) __THROW;
extern int setttyent (void) __THROW;
+libc_hidden_proto(setttyent)
extern int endttyent (void) __THROW;
+libc_hidden_proto(endttyent)
__END_DECLS
#ifdef __USE_LARGEFILE64
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
__THROW;
+libc_hidden_proto(lseek64)
#endif
/* Close the file descriptor FD.
bytes written on PIPEDES[1] can be read from PIPEDES[0].
Returns 0 if successful, -1 if not. */
extern int pipe (int __pipedes[2]) __THROW __wur;
+libc_hidden_proto(pipe)
/* Schedule an alarm. In SECONDS seconds, the process will get a SIGALRM.
If SECONDS is zero, any currently scheduled alarm will be cancelled.
to 0 and check its value after calling `alarm', and this might tell you.
The signal may come late due to processor scheduling. */
extern unsigned int alarm (unsigned int __seconds) __THROW;
+libc_hidden_proto(alarm)
/* Make the process sleep for SECONDS seconds, or until a signal arrives
and is not ignored. The function returns the number of seconds less
This function is a cancellation point and therefore not marked with
__THROW. */
extern unsigned int sleep (unsigned int __seconds);
+libc_hidden_proto(sleep)
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
/* Set an alarm to go off (generating a SIGALRM signal) in VALUE
/* Change the owner and group of FILE. */
extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(chown)
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
/* Change the owner and group of the file that FD is open on. */
/* Change the process's working directory to PATH. */
extern int chdir (__const char *__path) __THROW __nonnull ((1)) __wur;
+libc_hidden_proto(chdir)
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
/* Change the process's working directory to the one FD is open on. */
extern int fchdir (int __fd) __THROW __wur;
+libc_hidden_proto(fchdir)
#endif
/* Get the pathname of the current working directory,
bytes long, unless SIZE == 0, in which case it is as
big as necessary. */
extern char *getcwd (char *__buf, size_t __size) __THROW __wur;
+libc_hidden_proto(getcwd)
#ifdef __USE_GNU
/* Return a malloc'd string containing the current directory name.
/* Duplicate FD to FD2, closing FD2 and making it open on the same file. */
extern int dup2 (int __fd, int __fd2) __THROW;
+libc_hidden_proto(dup2)
/* NULL-terminated array of "NAME=VALUE" environment variables. */
extern char **__environ;
environment ENVP. ARGV and ENVP are terminated by NULL pointers. */
extern int execve (__const char *__path, char *__const __argv[],
char *__const __envp[]) __THROW __nonnull ((1));
+libc_hidden_proto(execve)
#if 0 /*def __USE_GNU*/
/* Execute the file FD refers to, overlaying the running program image.
/* Execute PATH with arguments ARGV and environment from `environ'. */
extern int execv (__const char *__path, char *__const __argv[])
__THROW __nonnull ((1));
+libc_hidden_proto(execv)
/* Execute PATH with all arguments after PATH until a NULL pointer,
and the argument after that for environment. */
extern int execle (__const char *__path, __const char *__arg, ...)
__THROW __nonnull ((1));
+libc_hidden_proto(execle)
/* Execute PATH with all arguments after PATH until
a NULL pointer and environment from `environ'. */
extern int execl (__const char *__path, __const char *__arg, ...)
__THROW __nonnull ((1));
+libc_hidden_proto(execl)
/* Execute FILE, searching in the `PATH' environment variable if it contains
no slashes, with arguments ARGV and environment from `environ'. */
extern int execvp (__const char *__file, char *__const __argv[])
__THROW __nonnull ((1));
+libc_hidden_proto(execvp)
/* Execute FILE, searching in the `PATH' environment variable if
it contains no slashes, with all arguments after FILE until a
NULL pointer and environment from `environ'. */
extern int execlp (__const char *__file, __const char *__arg, ...)
__THROW __nonnull ((1));
+libc_hidden_proto(execlp)
#if defined __USE_MISC || defined __USE_XOPEN
/* Get the value of the system variable NAME. */
extern long int sysconf (int __name) __THROW;
+libc_hidden_proto(sysconf)
#ifdef __USE_POSIX2
/* Get the value of the string-valued system variable NAME. */
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. */
extern int setpgid (__pid_t __pid, __pid_t __pgid) __THROW;
+libc_hidden_proto(setpgid)
#if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
/* Both System V and BSD have `setpgrp' functions, but with different
The process group IDs of the session and the calling process
are set to the process ID of the calling process, which is returned. */
extern __pid_t setsid (void) __THROW;
+libc_hidden_proto(setsid)
#ifdef __USE_XOPEN_EXTENDED
/* Return the session ID of the given process. */
extern __pid_t getsid (__pid_t __pid) __THROW;
+libc_hidden_proto(getsid)
#endif
/* Get the real user ID of the calling process. */
extern __uid_t getuid (void) __THROW;
+libc_hidden_proto(getuid)
/* Get the effective user ID of the calling process. */
extern __uid_t geteuid (void) __THROW;
+libc_hidden_proto(geteuid)
/* Get the real group ID of the calling process. */
extern __gid_t getgid (void) __THROW;
+libc_hidden_proto(getgid)
/* Get the effective group ID of the calling process. */
extern __gid_t getegid (void) __THROW;
+libc_hidden_proto(getegid)
/* If SIZE is zero, return the number of supplementary groups
the calling process is in. Otherwise, fill in the group IDs
of its supplementary groups in LIST and return the number written. */
extern int getgroups (int __size, __gid_t __list[]) __THROW __wur;
+libc_hidden_proto(getgroups)
#if 0 /*def __USE_GNU*/
/* Return nonzero iff the calling process is in group GID. */
/* Set the real user ID of the calling process to RUID,
and the effective user ID of the calling process to EUID. */
extern int setreuid (__uid_t __ruid, __uid_t __euid) __THROW;
+libc_hidden_proto(setreuid)
#endif
#if defined __USE_BSD || defined __USE_XOPEN2K
/* Set the effective user ID of the calling process to UID. */
extern int seteuid (__uid_t __uid) __THROW;
+libc_hidden_proto(seteuid)
#endif /* Use BSD. */
/* Set the group ID of the calling process to GID.
/* Set the real group ID of the calling process to RGID,
and the effective group ID of the calling process to EGID. */
extern int setregid (__gid_t __rgid, __gid_t __egid) __THROW;
+libc_hidden_proto(setregid)
#endif
#if defined __USE_BSD || defined __USE_XOPEN2K
of the calling process to RUID, EUID, and SUID, respectively. */
extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
__THROW;
+libc_hidden_proto(setresuid)
#endif
/* Set the real group ID, effective group ID, and saved-set group ID,
of the calling process to RGID, EGID, and SGID, respectively. */
extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
__THROW;
+libc_hidden_proto(setresgid)
#endif
Return -1 for errors, 0 to the new process,
and the process ID of the new process to the old process. */
extern __pid_t fork (void) __THROW;
+libc_hidden_proto(fork)
#endif
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
replaced by a call to `execve'. Return -1 for errors, 0 to the new process,
and the process ID of the new process to the old process. */
extern __pid_t vfork (void) __THROW;
+libc_hidden_proto(vfork)
#endif /* Use BSD. */
open on in BUF. Return 0 on success, otherwise an error number. */
extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
__THROW __nonnull ((2)) __wur;
+libc_hidden_proto(ttyname_r)
/* Return 1 if FD is a valid descriptor associated
with a terminal, zero if not. */
extern int isatty (int __fd) __THROW;
+libc_hidden_proto(isatty)
+
#if 0 /*defined __USE_BSD \
|| (defined __USE_XOPEN_EXTENDED && !defined __USE_UNIX98)*/
extern ssize_t readlink (__const char *__restrict __path,
char *__restrict __buf, size_t __len)
__THROW __nonnull ((1, 2)) __wur;
+libc_hidden_proto(readlink)
#endif /* Use BSD. */
#ifdef __USE_ATFILE
/* Remove the link NAME. */
extern int unlink (__const char *__name) __THROW __nonnull ((1));
+libc_hidden_proto(unlink)
#ifdef __USE_ATFILE
/* Remove the link NAME relative to FD. */
/* Remove the directory PATH. */
extern int rmdir (__const char *__path) __THROW __nonnull ((1));
+libc_hidden_proto(rmdir)
/* Return the foreground process group ID of FD. */
extern __pid_t tcgetpgrp (int __fd) __THROW;
+libc_hidden_proto(tcgetpgrp)
/* Set the foreground process group ID of FD set PGRP_ID. */
extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __THROW;
This function is a possible cancellation points and therefore not
marked with __THROW. */
extern char *getlogin (void);
+libc_hidden_proto(getlogin)
#if defined __USE_REENTRANT || defined __USE_POSIX199506
/* Return at most NAME_LEN characters of the login name of the user in NAME.
If it cannot be determined or some other error occurred, return the error
The result is null-terminated if LEN is large enough for the full
name and the terminator. */
extern int gethostname (char *__name, size_t __len) __THROW __nonnull ((1));
+libc_hidden_proto(gethostname)
#endif
The NIS domain name is usually the empty string when not using NIS. */
extern int getdomainname (char *__name, size_t __len)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(getdomainname)
extern int setdomainname (__const char *__name, size_t __len)
__THROW __nonnull ((1)) __wur;
#endif
/* Return the number of bytes in a page. This is the system's page size,
which is not necessarily the same as the hardware page size. */
extern int getpagesize (void) __THROW __attribute__ ((__const__));
+libc_hidden_proto(getpagesize)
/* Return the maximum number of file descriptors
the current process could possibly have. */
extern int getdtablesize (void) __THROW;
+libc_hidden_proto(getdtablesize)
/* Truncate FILE to LENGTH bytes. */
# ifndef __USE_FILE_OFFSET64
extern int truncate (__const char *__file, __off_t __length)
__THROW __nonnull ((1)) __wur;
+libc_hidden_proto(truncate)
# else
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (truncate,
/* Truncate the file FD is open on to LENGTH bytes. */
# ifndef __USE_FILE_OFFSET64
extern int ftruncate (int __fd, __off_t __length) __THROW __wur;
+libc_hidden_proto(ftruncate)
# else
# ifdef __REDIRECT_NTH
extern int __REDIRECT_NTH (ftruncate, (int __fd, __off64_t __length),
# endif
# ifdef __USE_LARGEFILE64
extern int ftruncate64 (int __fd, __off64_t __length) __THROW __wur;
+libc_hidden_proto(ftruncate64)
# endif
#endif /* Use BSD || X/Open Unix || POSIX 2003. */
# ifndef __USE_FILE_OFFSET64
extern int lockf (int __fd, int __cmd, __off_t __len) __wur;
+libc_hidden_proto(lockf)
# else
# ifdef __REDIRECT
extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len),
# endif
# ifdef __USE_LARGEFILE64
extern int lockf64 (int __fd, int __cmd, __off64_t __len) __wur;
+libc_hidden_proto(lockf64)
# endif
#endif /* Use misc and F_LOCK not already defined. */
extern int utime (__const char *__file,
__const struct utimbuf *__file_times)
__THROW __nonnull ((1));
+libc_hidden_proto(utime)
__END_DECLS
/* Reset the input stream to the beginning of the file. */
extern void setutent (void) __THROW;
+libc_hidden_proto(setutent)
/* Close the current open file. */
extern void endutent (void) __THROW;
/* Search forward from the current point in the utmp file until the
next entry with a ut_type matching ID->ut_type. */
extern struct utmp *getutid (__const struct utmp *__id) __THROW;
+libc_hidden_proto(getutid)
/* Search forward from the current point in the utmp file until the
next entry with a ut_line matching LINE->ut_line. */
/* Append SRC onto DEST. */
extern wchar_t *wcscat (wchar_t *__restrict __dest,
__const wchar_t *__restrict __src) __THROW;
+libc_hidden_proto(wcscat)
/* Append no more than N wide-characters of SRC onto DEST. */
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
__const wchar_t *__restrict __src, size_t __n)
/* Compare S1 and S2. */
extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
__THROW __attribute_pure__;
+libc_hidden_proto(wcscmp)
/* Compare N wide-characters of S1 and S2. */
extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
__THROW __attribute_pure__;
#ifdef __USE_GNU
/* Compare S1 and S2, ignoring case. */
extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) __THROW;
+libc_hidden_proto(wcscasecmp)
/* Compare no more than N chars of S1 and S2, ignoring case. */
extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
size_t __n) __THROW;
+libc_hidden_proto(wcsncasecmp)
#ifdef __UCLIBC_HAS_XLOCALE__
/* Similar to the two functions above but take the information from
extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
__locale_t __loc) __THROW;
+libc_hidden_proto(wcscasecmp_l)
extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
size_t __n, __locale_t __loc) __THROW;
+libc_hidden_proto(wcsncasecmp_l)
#endif /* __UCLIBC_HAS_XLOCALE__ */
#endif
/* Compare S1 and S2, both interpreted as appropriate to the
LC_COLLATE category of the current locale. */
extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) __THROW;
+libc_hidden_proto(wcscoll)
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
extern size_t wcsxfrm (wchar_t *__restrict __s1,
__const wchar_t *__restrict __s2, size_t __n) __THROW;
+libc_hidden_proto(wcsxfrm)
__END_NAMESPACE_C99
#ifdef __USE_GNU
LC_COLLATE category of the given locale. */
extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
__locale_t __loc) __THROW;
+libc_hidden_proto(wcscoll_l)
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
size_t __n, __locale_t __loc) __THROW;
+libc_hidden_proto(wcsxfrm_l)
#endif /* __UCLIBC_HAS_XLOCALE__ */
consists entirely of wide characters in ACCEPT. */
extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
__THROW __attribute_pure__;
+libc_hidden_proto(wcsspn)
/* Find the first occurrence in WCS of any character in ACCEPT. */
extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
__THROW __attribute_pure__;
+libc_hidden_proto(wcspbrk)
/* Find the first occurrence of NEEDLE in HAYSTACK. */
extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
__THROW __attribute_pure__;
/* Return the number of wide characters in S. */
extern size_t wcslen (__const wchar_t *__s) __THROW __attribute_pure__;
+libc_hidden_proto(wcslen)
__END_NAMESPACE_C99
#ifdef __USE_XOPEN
/* Return the number of wide characters in S, but at most MAXLEN. */
extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
__THROW __attribute_pure__;
+libc_hidden_proto(wcsnlen)
#endif
/* Search N wide characters of S for C. */
extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
__THROW __attribute_pure__;
+libc_hidden_proto(wmemchr)
/* Compare N wide characters of S1 and S2. */
extern int wmemcmp (__const wchar_t *__restrict __s1,
/* Copy N wide characters of SRC to DEST. */
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
__const wchar_t *__restrict __s2, size_t __n) __THROW;
+libc_hidden_proto(wmemcpy)
/* Copy N wide characters of SRC to DEST, guaranteeing
correct behavior for overlapping strings. */
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
__const wchar_t *__restrict __s2, size_t __n)
__THROW;
+libc_hidden_proto(wmempcpy)
#endif
/* Determine whether C constitutes a valid (one-byte) multibyte
character. */
extern wint_t btowc (int __c) __THROW;
+libc_hidden_proto(btowc)
/* Determine whether C corresponds to a member of the extended
character set whose multibyte representation is a single byte. */
/* Determine whether PS points to an object representing the initial
state. */
extern int mbsinit (__const mbstate_t *__ps) __THROW __attribute_pure__;
+libc_hidden_proto(mbsinit)
/* Write wide character representation of multibyte character pointed
to by S to PWC. */
extern size_t mbrtowc (wchar_t *__restrict __pwc,
__const char *__restrict __s, size_t __n,
mbstate_t *__p) __THROW;
+libc_hidden_proto(mbrtowc)
/* Write multibyte representation of wide character WC to S. */
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(wcrtomb)
/* Return number of bytes in multibyte character pointed to by S. */
#if 0 /* uClibc: disabled */
#endif
extern size_t mbrlen (__const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(mbrlen)
/* Write wide character representation of multibyte character string
SRC to DST. */
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
__const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(mbsrtowcs)
/* Write multibyte character representation of wide character string
SRC to DST. */
extern size_t wcsrtombs (char *__restrict __dst,
__const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(wcsrtombs)
__END_NAMESPACE_C99
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
__const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(mbsnrtowcs)
/* Write multibyte character representation of at most NWC characters
from the wide character string SRC to DST. */
__const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) __THROW;
+libc_hidden_proto(wcsnrtombs)
#endif /* use GNU */
/* Determine number of column positions required for first N wide
characters (or fewer if S ends before this) in S. */
extern int wcswidth (__const wchar_t *__s, size_t __n) __THROW;
+libc_hidden_proto(wcswidth)
#endif /* Use X/Open. */
__const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wprintf__, 2, 0))) */;
+libc_hidden_proto(vfwprintf)
/* Write formatted output to stdout from argument list ARG.
This function is a possible cancellation point and therefore not
__const wchar_t *__restrict __format,
__gnuc_va_list __arg)
__THROW /* __attribute__ ((__format__ (__wprintf__, 3, 0))) */;
+libc_hidden_proto(vswprintf)
/* Read formatted input from STREAM.
__const wchar_t *__restrict __format,
__gnuc_va_list __arg)
/* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
+libc_hidden_proto(vfwscanf)
/* Read formatted input from stdin into argument list ARG.
This function is a possible cancellation point and therefore not
__const wchar_t *__restrict __format,
__gnuc_va_list __arg)
__THROW /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
+libc_hidden_proto(vswscanf)
__END_NAMESPACE_C99
#endif /* Use ISO C99. */
These functions are possible cancellation points and therefore not
marked with __THROW. */
extern wint_t fgetwc (__FILE *__stream);
+libc_hidden_proto(fgetwc)
extern wint_t getwc (__FILE *__stream);
/* Read a character from stdin.
marked with __THROW. */
extern int fputws (__const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
+libc_hidden_proto(fputws)
/* Push a character back onto the input buffer of STREAM.
This function is a possible cancellation points and therefore not
marked with __THROW. */
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+libc_hidden_proto(ungetwc)
__END_NAMESPACE_C99
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern wint_t fgetwc_unlocked (__FILE *__stream);
+libc_hidden_proto(fgetwc_unlocked)
/* Faster version when locking is not necessary.
or due to the implementation it is a cancellation point and
therefore not marked with __THROW. */
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+libc_hidden_proto(fputwc_unlocked)
/* These are defined to be equivalent to the `char' functions defined
in POSIX.1:1996.
therefore not marked with __THROW. */
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
+libc_hidden_proto(fgetws_unlocked)
/* This function does the same as `fputws' but does not lock the stream.
therefore not marked with __THROW. */
extern int fputws_unlocked (__const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
+libc_hidden_proto(fputws_unlocked)
#endif
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
__const wchar_t *__restrict __format,
__const struct tm *__restrict __tp) __THROW;
+libc_hidden_proto(wcsftime)
__END_NAMESPACE_C99
# if defined __USE_GNU && defined __UCLIBC_HAS_XLOCALE__
__const wchar_t *__restrict __format,
__const struct tm *__restrict __tp,
__locale_t __loc) __THROW;
+libc_hidden_proto(wcsftime_l)
# endif
/* The X/Open standard demands that most of the functions defined in
/* Test for any wide character for which `iswalpha' or `iswdigit' is
true. */
extern int iswalnum (wint_t __wc) __THROW;
+libc_hidden_proto(iswalnum)
/* Test for any wide character for which `iswupper' or 'iswlower' is
true, or any wide character that is one of a locale-specific set of
or is one of a locale-specific set of wide characters for which
none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswlower (wint_t __wc) __THROW;
+libc_hidden_proto(iswlower)
/* Test for any printing wide character. */
extern int iswprint (wint_t __wc) __THROW;
or is one of a locale-specific set of wide character for which none
of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */
extern int iswupper (wint_t __wc) __THROW;
+libc_hidden_proto(iswspace)
/* Test for any wide character that corresponds to a hexadecimal-digit
character equivalent to that performed be the functions described
/* Construct value that describes a class of wide characters identified
by the string argument PROPERTY. */
extern wctype_t wctype (__const char *__property) __THROW;
+libc_hidden_proto(wctype)
/* Determine whether the wide-character WC has the property described by
DESC. */
extern int iswctype (wint_t __wc, wctype_t __desc) __THROW;
+libc_hidden_proto(iswctype)
__END_NAMESPACE_C99
__BEGIN_NAMESPACE_C99
/* Converts an uppercase letter to the corresponding lowercase letter. */
extern wint_t towlower (wint_t __wc) __THROW;
+libc_hidden_proto(towlower)
/* Converts an lowercase letter to the corresponding uppercase letter. */
extern wint_t towupper (wint_t __wc) __THROW;
+libc_hidden_proto(towupper)
__END_NAMESPACE_C99
__END_DECLS
/* Construct value that describes a mapping between wide characters
identified by the string argument PROPERTY. */
extern wctrans_t wctrans (__const char *__property) __THROW;
+libc_hidden_proto(wctrans)
/* Map the wide character WC using the mapping described by DESC. */
extern wint_t towctrans (wint_t __wc, wctrans_t __desc) __THROW;
+libc_hidden_proto(towctrans)
__END_NAMESPACE_C99
#if defined(__USE_GNU) && defined(__UCLIBC_HAS_XLOCALE__)
set of wide characters for which none of `iswalnum', `iswgraph', or
`iswpunct' is true. */
extern int iswspace_l (wint_t __wc, __locale_t __locale) __THROW;
+libc_hidden_proto(iswspace_l)
/* Test for any wide character that corresponds to an uppercase letter
or is one of a locale-specific set of wide character for which none
by the string argument PROPERTY. */
extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
__THROW;
+libc_hidden_proto(wctype_l)
/* Determine whether the wide-character WC has the property described by
DESC. */
extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
__THROW;
+libc_hidden_proto(iswctype_l)
/*
/* Converts an uppercase letter to the corresponding lowercase letter. */
extern wint_t towlower_l (wint_t __wc, __locale_t __locale) __THROW;
+libc_hidden_proto(towlower_l)
/* Converts an lowercase letter to the corresponding uppercase letter. */
extern wint_t towupper_l (wint_t __wc, __locale_t __locale) __THROW;
+libc_hidden_proto(towupper_l)
/* Construct value that describes a mapping between wide characters
identified by the string argument PROPERTY. */
/* Map the wide character WC using the mapping described by DESC. */
extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
__locale_t __locale) __THROW;
+libc_hidden_proto(towctrans_l)
# endif /* Use GNU. */
/* Free the storage allocated by a `wordexp' call. */
extern void wordfree (wordexp_t *__wordexp) __THROW;
+libc_hidden_proto(wordfree)
__END_DECLS
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(__ctype_b) */
#endif
-libc_hidden_proto(inet_aton)
+/* libc_hidden_proto(inet_aton) */
int inet_aton(const char *cp, struct in_addr *addrptr)
{
in_addr_t addr;
#endif
#ifdef L_inet_addr
-libc_hidden_proto(inet_aton)
+/* libc_hidden_proto(inet_aton) */
-libc_hidden_proto(inet_addr)
+/* libc_hidden_proto(inet_addr) */
in_addr_t inet_addr(const char *cp)
{
struct in_addr a;
#define INET_NTOA_MAX_LEN 16 /* max 12 digits + 3 '.'s + 1 nul */
-libc_hidden_proto(inet_ntoa_r)
+/* libc_hidden_proto(inet_ntoa_r) */
char *inet_ntoa_r(struct in_addr in, char buf[INET_NTOA_MAX_LEN])
{
in_addr_t addr = ntohl(in.s_addr);
}
libc_hidden_def(inet_ntoa_r)
-libc_hidden_proto(inet_ntoa)
+/* libc_hidden_proto(inet_ntoa) */
char *inet_ntoa(struct in_addr in)
{
static char buf[INET_NTOA_MAX_LEN];
* Formulate an Internet address from network + host. Used in
* building addresses stored in the ifnet structure.
*/
-libc_hidden_proto(inet_makeaddr)
+/* libc_hidden_proto(inet_makeaddr) */
struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host)
{
in_addr_t addr;
* Return the network number from an internet
* address; handles class a/b/c network #'s.
*/
-libc_hidden_proto(inet_netof)
+/* libc_hidden_proto(inet_netof) */
in_addr_t
inet_netof(struct in_addr in)
{
#include <netinet/ether.h>
#include <netinet/if_ether.h>
-libc_hidden_proto(ether_ntoa_r)
+/* libc_hidden_proto(ether_ntoa_r) */
/* libc_hidden_proto(sprintf) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
/* Experimentally off - libc_hidden_proto(strlen) */
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(getservbyname_r)
-libc_hidden_proto(gethostbyname2_r)
-libc_hidden_proto(gethostbyaddr_r)
-libc_hidden_proto(inet_pton)
-libc_hidden_proto(inet_ntop)
-libc_hidden_proto(strtoul)
-libc_hidden_proto(if_nametoindex)
-libc_hidden_proto(__h_errno_location)
+/* libc_hidden_proto(getservbyname_r) */
+/* libc_hidden_proto(gethostbyname2_r) */
+/* libc_hidden_proto(gethostbyaddr_r) */
+/* libc_hidden_proto(inet_pton) */
+/* libc_hidden_proto(inet_ntop) */
+/* libc_hidden_proto(strtoul) */
+/* libc_hidden_proto(if_nametoindex) */
+/* libc_hidden_proto(__h_errno_location) */
/* libc_hidden_proto(uname) */
#ifdef __UCLIBC_HAS_IPV6__
-libc_hidden_proto(in6addr_loopback)
+/* libc_hidden_proto(in6addr_loopback) */
#endif
#define GAIH_OKIFUNSPEC 0x0100
{ PF_UNSPEC, NULL }
};
-libc_hidden_proto(freeaddrinfo)
+/* libc_hidden_proto(freeaddrinfo) */
void
freeaddrinfo(struct addrinfo *ai)
{
}
libc_hidden_def(freeaddrinfo)
-libc_hidden_proto(getaddrinfo)
+/* libc_hidden_proto(getaddrinfo) */
int
getaddrinfo(const char *name, const char *service,
const struct addrinfo *hints, struct addrinfo **pai)
#include <netdb.h>
#include <unistd.h>
-libc_hidden_proto(setnetent)
-libc_hidden_proto(getnetent)
-libc_hidden_proto(endnetent)
+/* libc_hidden_proto(setnetent) */
+/* libc_hidden_proto(getnetent) */
+/* libc_hidden_proto(endnetent) */
extern smallint _net_stayopen attribute_hidden;
#include <unistd.h>
/* Experimentally off - libc_hidden_proto(strcmp) */
-libc_hidden_proto(setnetent)
-libc_hidden_proto(getnetent)
-libc_hidden_proto(endnetent)
+/* libc_hidden_proto(setnetent) */
+/* libc_hidden_proto(getnetent) */
+/* libc_hidden_proto(endnetent) */
extern smallint _net_stayopen attribute_hidden;
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(inet_network)
-libc_hidden_proto(rewind)
+/* libc_hidden_proto(inet_network) */
+/* libc_hidden_proto(rewind) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(abort) */
smallint _net_stayopen attribute_hidden;
-libc_hidden_proto(setnetent)
+/* libc_hidden_proto(setnetent) */
void setnetent(int f)
{
__UCLIBC_MUTEX_LOCK(mylock);
}
libc_hidden_def(setnetent)
-libc_hidden_proto(endnetent)
+/* libc_hidden_proto(endnetent) */
void endnetent(void)
{
__UCLIBC_MUTEX_LOCK(mylock);
return ((char *)0);
}
-libc_hidden_proto(getnetent)
+/* libc_hidden_proto(getnetent) */
struct netent *getnetent(void)
{
char *p;
/* libc_hidden_proto(fopen) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strpbrk) */
-libc_hidden_proto(atoi)
-libc_hidden_proto(rewind)
+/* libc_hidden_proto(atoi) */
+/* libc_hidden_proto(rewind) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(abort) */
}
}
-libc_hidden_proto(setprotoent)
+/* libc_hidden_proto(setprotoent) */
void setprotoent(int f)
{
__UCLIBC_MUTEX_LOCK(mylock);
}
libc_hidden_def(setprotoent)
-libc_hidden_proto(endprotoent)
+/* libc_hidden_proto(endprotoent) */
void endprotoent(void)
{
__UCLIBC_MUTEX_LOCK(mylock);
}
libc_hidden_def(endprotoent)
-libc_hidden_proto(getprotoent_r)
+/* libc_hidden_proto(getprotoent_r) */
int getprotoent_r(struct protoent *result_buf,
char *buf, size_t buflen,
struct protoent **result)
}
-libc_hidden_proto(getprotobyname_r)
+/* libc_hidden_proto(getprotobyname_r) */
int getprotobyname_r(const char *name,
struct protoent *result_buf,
char *buf, size_t buflen,
}
-libc_hidden_proto(getprotobynumber_r)
+/* libc_hidden_proto(getprotobynumber_r) */
int getprotobynumber_r (int proto_num,
struct protoent *result_buf,
char *buf, size_t buflen,
/* Experimentally off - libc_hidden_proto(strpbrk) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(atoi)
-libc_hidden_proto(rewind)
+/* libc_hidden_proto(atoi) */
+/* libc_hidden_proto(rewind) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(abort) */
}
}
-libc_hidden_proto(setservent)
+/* libc_hidden_proto(setservent) */
void setservent(int f)
{
__UCLIBC_MUTEX_LOCK(mylock);
}
libc_hidden_def(setservent)
-libc_hidden_proto(endservent)
+/* libc_hidden_proto(endservent) */
void endservent(void)
{
__UCLIBC_MUTEX_LOCK(mylock);
}
libc_hidden_def(endservent)
-libc_hidden_proto(getservent_r)
+/* libc_hidden_proto(getservent_r) */
int getservent_r(struct servent * result_buf,
char * buf, size_t buflen,
struct servent ** result)
return result;
}
-libc_hidden_proto(getservbyname_r)
+/* libc_hidden_proto(getservbyname_r) */
int getservbyname_r(const char *name, const char *proto,
struct servent * result_buf, char * buf, size_t buflen,
struct servent ** result)
}
-libc_hidden_proto(getservbyport_r)
+/* libc_hidden_proto(getservbyport_r) */
int getservbyport_r(int port, const char *proto,
struct servent * result_buf, char * buf,
size_t buflen, struct servent ** result)
}
libc_hidden_def(getservbyport_r)
-libc_hidden_proto(getservbyport)
+/* libc_hidden_proto(getservbyport) */
struct servent * getservbyport(int port, const char *proto)
{
struct servent *result;
#include <netdb.h>
/* libc_hidden_proto(fprintf) */
-libc_hidden_proto(__h_errno_location)
+/* libc_hidden_proto(__h_errno_location) */
static const char error_msg[] = "Resolver error";
static const char *const h_errlist[] = {
/*
* herror -- print the error indicated by the h_errno value.
*/
-libc_hidden_proto(herror)
+/* libc_hidden_proto(herror) */
void herror(const char *s)
{
static const char colon_space[] = ": ";
/* libc_hidden_proto(close) */
/* libc_hidden_proto(read) */
/* libc_hidden_proto(write) */
-libc_hidden_proto(getuid)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(gethostbyname_r)
-libc_hidden_proto(gethostname)
+/* libc_hidden_proto(getuid) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(gethostbyname_r) */
+/* libc_hidden_proto(gethostname) */
#define HOSTID "/etc/hostid"
extern int __opensock(void) attribute_hidden;
-libc_hidden_proto(if_nametoindex)
+/* libc_hidden_proto(if_nametoindex) */
unsigned int
if_nametoindex(const char* ifname)
{
}
libc_hidden_def(if_nametoindex)
-libc_hidden_proto(if_freenameindex)
+/* libc_hidden_proto(if_freenameindex) */
void
if_freenameindex (struct if_nameindex *ifn)
{
}
libc_hidden_def(if_freenameindex)
-libc_hidden_proto(if_nameindex)
+/* libc_hidden_proto(if_nameindex) */
#if !__ASSUME_NETLINK_SUPPORT
struct if_nameindex *
if_nameindex (void)
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
/* Experimentally off - libc_hidden_proto(time) */
-libc_hidden_proto(sendto)
-libc_hidden_proto(recvmsg)
-libc_hidden_proto(bind)
+/* libc_hidden_proto(sendto) */
+/* libc_hidden_proto(recvmsg) */
+/* libc_hidden_proto(bind) */
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(mempcpy) */
-libc_hidden_proto(getsockname)
+/* libc_hidden_proto(getsockname) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(abort) */
#ifdef __UCLIBC_HAS_IPV6__
const struct in6_addr in6addr_any =
{ { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } };
-libc_hidden_proto(in6addr_loopback)
+/* libc_hidden_proto(in6addr_loopback) */
const struct in6_addr in6addr_loopback =
{ { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } };
libc_hidden_data_def(in6addr_loopback)
* The library routines call this routine to interpret
* network numbers.
*/
-libc_hidden_proto(inet_network)
+/* libc_hidden_proto(inet_network) */
in_addr_t
inet_network(const char *cp)
{
* author:
* Paul Vixie, 1996.
*/
-libc_hidden_proto(inet_ntop)
+/* libc_hidden_proto(inet_ntop) */
const char *
inet_ntop(int af, const void *src, char *dst, socklen_t size)
{
* author:
* Paul Vixie, 1996.
*/
-libc_hidden_proto(inet_pton)
+/* libc_hidden_proto(inet_pton) */
int
inet_pton(int af, const char *src, void *dst)
{
/* libc_hidden_proto(close) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(random)
-libc_hidden_proto(getservbyport)
-libc_hidden_proto(gethostname)
-libc_hidden_proto(uname)
-libc_hidden_proto(inet_addr)
-libc_hidden_proto(inet_aton)
-libc_hidden_proto(inet_pton)
-libc_hidden_proto(inet_ntop)
-libc_hidden_proto(connect)
+/* libc_hidden_proto(random) */
+/* libc_hidden_proto(getservbyport) */
+/* libc_hidden_proto(gethostname) */
+/* libc_hidden_proto(uname) */
+/* libc_hidden_proto(inet_addr) */
+/* libc_hidden_proto(inet_aton) */
+/* libc_hidden_proto(inet_pton) */
+/* libc_hidden_proto(inet_ntop) */
+/* libc_hidden_proto(connect) */
/* libc_hidden_proto(poll) */
-libc_hidden_proto(select)
-libc_hidden_proto(recv)
-libc_hidden_proto(send)
+/* libc_hidden_proto(select) */
+/* libc_hidden_proto(recv) */
+/* libc_hidden_proto(send) */
/* libc_hidden_proto(printf) */
/* libc_hidden_proto(sprintf) */
-libc_hidden_proto(snprintf)
+/* libc_hidden_proto(snprintf) */
/* libc_hidden_proto(fgets) */
-libc_hidden_proto(getnameinfo)
-libc_hidden_proto(gethostbyname)
-libc_hidden_proto(gethostbyname_r)
-libc_hidden_proto(gethostbyname2_r)
-libc_hidden_proto(gethostbyaddr)
-libc_hidden_proto(gethostbyaddr_r)
-libc_hidden_proto(ns_name_uncompress)
-libc_hidden_proto(ns_name_unpack)
-libc_hidden_proto(ns_name_ntop)
-libc_hidden_proto(res_init)
-libc_hidden_proto(res_query)
-libc_hidden_proto(res_querydomain)
-libc_hidden_proto(gethostent_r)
+/* libc_hidden_proto(getnameinfo) */
+/* libc_hidden_proto(gethostbyname) */
+/* libc_hidden_proto(gethostbyname_r) */
+/* libc_hidden_proto(gethostbyname2_r) */
+/* libc_hidden_proto(gethostbyaddr) */
+/* libc_hidden_proto(gethostbyaddr_r) */
+/* libc_hidden_proto(ns_name_uncompress) */
+/* libc_hidden_proto(ns_name_unpack) */
+/* libc_hidden_proto(ns_name_ntop) */
+/* libc_hidden_proto(res_init) */
+/* libc_hidden_proto(res_query) */
+/* libc_hidden_proto(res_querydomain) */
+/* libc_hidden_proto(gethostent_r) */
/* libc_hidden_proto(fprintf) */
-libc_hidden_proto(__h_errno_location)
+/* libc_hidden_proto(__h_errno_location) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(__ctype_b) */
#endif
-int __libc_getdomainname(char *name, size_t len);
+
+extern int __libc_getdomainname(char *name, size_t len);
libc_hidden_proto(__libc_getdomainname)
#include "rpc_private.h"
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_opaque_auth) */
#define MAX_MARSHAL_SIZE 20
static struct authnone_private_s *authnone_private;
#endif
-libc_hidden_proto(authnone_create)
+/* libc_hidden_proto(authnone_create) */
AUTH *
authnone_create (void)
{
#endif
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(sysconf)
-libc_hidden_proto(getegid)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(getgroups)
-libc_hidden_proto(gethostname)
+/* libc_hidden_proto(sysconf) */
+/* libc_hidden_proto(getegid) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(getgroups) */
+/* libc_hidden_proto(gethostname) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_authunix_parms)
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_authunix_parms) */
+/* libc_hidden_proto(xdr_opaque_auth) */
/* libc_hidden_proto(gettimeofday) */
/* libc_hidden_proto(fputs) */
/* libc_hidden_proto(perror) */
* Create a unix style authenticator.
* Returns an auth handle with the given stuff in it.
*/
-libc_hidden_proto(authunix_create)
+/* libc_hidden_proto(authunix_create) */
AUTH *
authunix_create (char *machname, uid_t uid, gid_t gid, int len,
gid_t *aup_gids)
* Returns an auth handle with parameters determined by doing lots of
* syscalls.
*/
-libc_hidden_proto(authunix_create_default)
+/* libc_hidden_proto(authunix_create_default) */
AUTH *
authunix_create_default (void)
{
#include <rpc/auth.h>
#include <rpc/auth_unix.h>
-libc_hidden_proto(xdr_string)
-libc_hidden_proto(xdr_u_int)
-libc_hidden_proto(xdr_array)
-libc_hidden_proto(xdr_u_long)
-libc_hidden_proto(xdr_u_short)
+/* libc_hidden_proto(xdr_string) */
+/* libc_hidden_proto(xdr_u_int) */
+/* libc_hidden_proto(xdr_array) */
+/* libc_hidden_proto(xdr_u_long) */
+/* libc_hidden_proto(xdr_u_short) */
/*
* XDR for unix authentication parameters.
* Unfortunately, none of these can be declared const.
*/
-libc_hidden_proto(xdr_authunix_parms)
+/* libc_hidden_proto(xdr_authunix_parms) */
bool_t
xdr_authunix_parms (XDR * xdrs, struct authunix_parms *p)
{
#include <netinet/in.h>
/* Experimentally off - libc_hidden_proto(memset) */
-libc_hidden_proto(bind)
+/* libc_hidden_proto(bind) */
/* libc_hidden_proto(getpid) */
/*
* Bind a socket to a privileged IP port
*/
-libc_hidden_proto(bindresvport)
+/* libc_hidden_proto(bindresvport) */
int
bindresvport (int sd, struct sockaddr_in *sin)
{
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strcpy) */
-libc_hidden_proto(clnttcp_create)
-libc_hidden_proto(clntudp_create)
-libc_hidden_proto(clntunix_create)
-libc_hidden_proto(getprotobyname_r)
-libc_hidden_proto(gethostbyname_r)
-libc_hidden_proto(__rpc_thread_createerr)
+/* libc_hidden_proto(clnttcp_create) */
+/* libc_hidden_proto(clntudp_create) */
+/* libc_hidden_proto(clntunix_create) */
+/* libc_hidden_proto(getprotobyname_r) */
+/* libc_hidden_proto(gethostbyname_r) */
+/* libc_hidden_proto(__rpc_thread_createerr) */
/*
* Generic client creation: takes (hostname, program-number, protocol) and
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
/* libc_hidden_proto(sprintf) */
-libc_hidden_proto(__glibc_strerror_r)
+/* libc_hidden_proto(__glibc_strerror_r) */
/* libc_hidden_proto(fputs) */
#ifdef USE_IN_LIBIO
/* libc_hidden_proto(fwprintf) */
/*
* This interface for use by clntrpc
*/
-libc_hidden_proto(clnt_sperrno)
+/* libc_hidden_proto(clnt_sperrno) */
char *
clnt_sperrno (enum clnt_stat stat)
{
/*
* Print reply error info
*/
-libc_hidden_proto(clnt_sperror)
+/* libc_hidden_proto(clnt_sperror) */
char *
clnt_sperror (CLIENT * rpch, const char *msg)
{
}
libc_hidden_def(clnt_sperror)
-libc_hidden_proto(clnt_perror)
+/* libc_hidden_proto(clnt_perror) */
void
clnt_perror (CLIENT * rpch, const char *msg)
{
}
libc_hidden_def(clnt_perror)
-libc_hidden_proto(clnt_spcreateerror)
+/* libc_hidden_proto(clnt_spcreateerror) */
char *
clnt_spcreateerror (const char *msg)
{
#include <rpc/xdr.h>
/* libc_hidden_proto(perror) */
-libc_hidden_proto(authnone_create)
+/* libc_hidden_proto(authnone_create) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_callhdr)
+/* libc_hidden_proto(xdr_callhdr) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xdr_opaque_auth)
-libc_hidden_proto(svc_getreq)
-libc_hidden_proto(_seterr_reply)
+/* libc_hidden_proto(xdr_opaque_auth) */
+/* libc_hidden_proto(svc_getreq) */
+/* libc_hidden_proto(_seterr_reply) */
#define MCALL_MSG_SIZE 24
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strncpy) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(clntudp_create)
-libc_hidden_proto(gethostbyname_r)
+/* libc_hidden_proto(clntudp_create) */
+/* libc_hidden_proto(gethostbyname_r) */
struct callrpc_private_s
{
/* libc_hidden_proto(read) */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(authnone_create)
-libc_hidden_proto(xdrrec_create)
-libc_hidden_proto(xdrrec_endofrecord)
-libc_hidden_proto(xdrrec_skiprecord)
-libc_hidden_proto(xdr_callhdr)
+/* libc_hidden_proto(authnone_create) */
+/* libc_hidden_proto(xdrrec_create) */
+/* libc_hidden_proto(xdrrec_endofrecord) */
+/* libc_hidden_proto(xdrrec_skiprecord) */
+/* libc_hidden_proto(xdr_callhdr) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_opaque_auth) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_void)
-libc_hidden_proto(pmap_getport)
-libc_hidden_proto(_seterr_reply)
-libc_hidden_proto(connect)
-libc_hidden_proto(bindresvport)
+/* libc_hidden_proto(xdr_void) */
+/* libc_hidden_proto(pmap_getport) */
+/* libc_hidden_proto(_seterr_reply) */
+/* libc_hidden_proto(connect) */
+/* libc_hidden_proto(bindresvport) */
/* libc_hidden_proto(poll) */
/* libc_hidden_proto(fputs) */
-libc_hidden_proto(__rpc_thread_createerr)
+/* libc_hidden_proto(__rpc_thread_createerr) */
#ifdef USE_IN_LIBIO
/* libc_hidden_proto(fwprintf) */
#endif
* NB: The rpch->cl_auth is set null authentication. Caller may wish to set this
* something more useful.
*/
-libc_hidden_proto(clnttcp_create)
+/* libc_hidden_proto(clnttcp_create) */
CLIENT *
clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
int *sockp, u_int sendsz, u_int recvsz)
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
/* CMSG_NXTHDR is using it */
-libc_hidden_proto(__cmsg_nxthdr)
+/* libc_hidden_proto(__cmsg_nxthdr) */
-libc_hidden_proto(authnone_create)
+/* libc_hidden_proto(authnone_create) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_callhdr)
+/* libc_hidden_proto(xdr_callhdr) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xdr_opaque_auth)
-libc_hidden_proto(pmap_getport)
-libc_hidden_proto(_seterr_reply)
-libc_hidden_proto(setsockopt)
-libc_hidden_proto(bindresvport)
-libc_hidden_proto(recvfrom)
-libc_hidden_proto(sendto)
-libc_hidden_proto(recvmsg)
+/* libc_hidden_proto(xdr_opaque_auth) */
+/* libc_hidden_proto(pmap_getport) */
+/* libc_hidden_proto(_seterr_reply) */
+/* libc_hidden_proto(setsockopt) */
+/* libc_hidden_proto(bindresvport) */
+/* libc_hidden_proto(recvfrom) */
+/* libc_hidden_proto(sendto) */
+/* libc_hidden_proto(recvmsg) */
/* libc_hidden_proto(poll) */
/* libc_hidden_proto(fputs) */
-libc_hidden_proto(__rpc_thread_createerr)
+/* libc_hidden_proto(__rpc_thread_createerr) */
extern u_long _create_xid (void) attribute_hidden;
* sendsz and recvsz are the maximum allowable packet sizes that can be
* sent and received.
*/
-libc_hidden_proto(clntudp_bufcreate)
+/* libc_hidden_proto(clntudp_bufcreate) */
CLIENT *
clntudp_bufcreate (struct sockaddr_in *raddr, u_long program, u_long version,
struct timeval wait, int *sockp, u_int sendsz,
}
libc_hidden_def(clntudp_bufcreate)
-libc_hidden_proto(clntudp_create)
+/* libc_hidden_proto(clntudp_create) */
CLIENT *
clntudp_create (struct sockaddr_in *raddr, u_long program, u_long version, struct timeval wait, int *sockp)
{
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
/* libc_hidden_proto(getpid) */
-libc_hidden_proto(authnone_create)
-libc_hidden_proto(xdrrec_create)
-libc_hidden_proto(xdrrec_endofrecord)
-libc_hidden_proto(xdrrec_skiprecord)
-libc_hidden_proto(xdr_callhdr)
+/* libc_hidden_proto(authnone_create) */
+/* libc_hidden_proto(xdrrec_create) */
+/* libc_hidden_proto(xdrrec_endofrecord) */
+/* libc_hidden_proto(xdrrec_skiprecord) */
+/* libc_hidden_proto(xdr_callhdr) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_opaque_auth) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_void)
-libc_hidden_proto(getegid)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(_seterr_reply)
-libc_hidden_proto(setsockopt)
-libc_hidden_proto(connect)
-libc_hidden_proto(recvmsg)
-libc_hidden_proto(sendmsg)
+/* libc_hidden_proto(xdr_void) */
+/* libc_hidden_proto(getegid) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(_seterr_reply) */
+/* libc_hidden_proto(setsockopt) */
+/* libc_hidden_proto(connect) */
+/* libc_hidden_proto(recvmsg) */
+/* libc_hidden_proto(sendmsg) */
/* libc_hidden_proto(poll) */
/* libc_hidden_proto(fputs) */
-libc_hidden_proto(__rpc_thread_createerr)
+/* libc_hidden_proto(__rpc_thread_createerr) */
extern u_long _create_xid (void) attribute_hidden;
* NB: The rpch->cl_auth is set null authentication. Caller may wish to set this
* something more useful.
*/
-libc_hidden_proto(clntunix_create)
+/* libc_hidden_proto(clntunix_create) */
CLIENT *
clntunix_create (struct sockaddr_un *raddr, u_long prog, u_long vers,
int *sockp, u_int sendsz, u_int recvsz)
#include <sys/time.h>
#include <rpc/rpc.h>
-libc_hidden_proto(lrand48_r)
-libc_hidden_proto(srand48_r)
+/* libc_hidden_proto(lrand48_r) */
+/* libc_hidden_proto(srand48_r) */
/* libc_hidden_proto(gettimeofday) */
/* The RPC code is not threadsafe, but new code should be threadsafe. */
/* Experimentally off - libc_hidden_proto(strlen) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(atoi)
-libc_hidden_proto(rewind)
+/* libc_hidden_proto(atoi) */
+/* libc_hidden_proto(rewind) */
/* libc_hidden_proto(fgets) */
/*
return d;
}
-libc_hidden_proto(endrpcent)
+/* libc_hidden_proto(endrpcent) */
void endrpcent(void)
{
register struct rpcdata *d = _rpcdata();
}
libc_hidden_def(endrpcent)
-libc_hidden_proto(setrpcent)
+/* libc_hidden_proto(setrpcent) */
void setrpcent(int f)
{
register struct rpcdata *d = _rpcdata();
return interpret(d);
}
-libc_hidden_proto(getrpcent)
+/* libc_hidden_proto(getrpcent) */
struct rpcent *getrpcent(void)
{
register struct rpcdata *d = _rpcdata();
}
libc_hidden_def(getrpcent)
-libc_hidden_proto(getrpcbynumber)
+/* libc_hidden_proto(getrpcbynumber) */
struct rpcent *getrpcbynumber(register int number)
{
register struct rpcdata *d = _rpcdata();
}
libc_hidden_def(getrpcbynumber)
-libc_hidden_proto(getrpcbyname)
+/* libc_hidden_proto(getrpcbyname) */
struct rpcent *getrpcbyname(const char *name)
{
struct rpcent *rpc;
#include <sys/socket.h>
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(pmap_getport)
-libc_hidden_proto(gethostbyname_r)
+/* libc_hidden_proto(pmap_getport) */
+/* libc_hidden_proto(gethostbyname_r) */
int
getrpcport (const char *host, u_long prognum, u_long versnum, u_int proto)
#include <errno.h>
#include <unistd.h>
-libc_hidden_proto(clnt_perror)
-libc_hidden_proto(clnttcp_create)
-libc_hidden_proto(xdr_pmap)
-libc_hidden_proto(xdr_pmaplist)
-libc_hidden_proto(xdr_void)
+/* libc_hidden_proto(clnt_perror) */
+/* libc_hidden_proto(clnttcp_create) */
+/* libc_hidden_proto(xdr_pmap) */
+/* libc_hidden_proto(xdr_pmaplist) */
+/* libc_hidden_proto(xdr_void) */
/*
* Get a copy of the current port maps.
#include <rpc/pmap_prot.h>
#include <rpc/pmap_clnt.h>
-libc_hidden_proto(clntudp_bufcreate)
-libc_hidden_proto(__rpc_thread_createerr)
-libc_hidden_proto(xdr_u_short)
-libc_hidden_proto(xdr_pmap)
+/* libc_hidden_proto(clntudp_bufcreate) */
+/* libc_hidden_proto(__rpc_thread_createerr) */
+/* libc_hidden_proto(xdr_u_short) */
+/* libc_hidden_proto(xdr_pmap) */
static const struct timeval timeout =
{5, 0};
* Calls the pmap service remotely to do the lookup.
* Returns 0 if no map exists.
*/
-libc_hidden_proto(pmap_getport)
+/* libc_hidden_proto(pmap_getport) */
u_short
pmap_getport (address, program, version, protocol)
struct sockaddr_in *address;
/* libc_hidden_proto(close) */
/* libc_hidden_proto(perror) */
/* libc_hidden_proto(exit) */
-libc_hidden_proto(clnt_perror)
-libc_hidden_proto(clntudp_bufcreate)
-libc_hidden_proto(xdr_bool)
-libc_hidden_proto(xdr_pmap)
+/* libc_hidden_proto(clnt_perror) */
+/* libc_hidden_proto(clntudp_bufcreate) */
+/* libc_hidden_proto(xdr_bool) */
+/* libc_hidden_proto(xdr_pmap) */
/*
* Same as get_myaddress, but we try to use the loopback
* Set a mapping between program,version and port.
* Calls the pmap service remotely to do the mapping.
*/
-libc_hidden_proto(pmap_set)
+/* libc_hidden_proto(pmap_set) */
bool_t
pmap_set (u_long program, u_long version, int protocol, u_short port)
{
* Remove the mapping between program,version and port.
* Calls the pmap service remotely to do the un-mapping.
*/
-libc_hidden_proto(pmap_unset)
+/* libc_hidden_proto(pmap_unset) */
bool_t
pmap_unset (u_long program, u_long version)
{
#include <rpc/xdr.h>
#include <rpc/pmap_prot.h>
-libc_hidden_proto(xdr_u_long)
+/* libc_hidden_proto(xdr_u_long) */
-libc_hidden_proto(xdr_pmap)
+/* libc_hidden_proto(xdr_pmap) */
bool_t
xdr_pmap (xdrs, regs)
XDR *xdrs;
#include <rpc/xdr.h>
#include <rpc/pmap_prot.h>
-libc_hidden_proto(xdr_bool)
-libc_hidden_proto(xdr_reference)
-libc_hidden_proto(xdr_pmap)
+/* libc_hidden_proto(xdr_bool) */
+/* libc_hidden_proto(xdr_reference) */
+/* libc_hidden_proto(xdr_pmap) */
/*
* What is going on with linked lists? (!)
* the net, yet is the data that the pointer points to which is interesting;
* this sounds like a job for xdr_reference!
*/
-libc_hidden_proto(xdr_pmaplist)
+/* libc_hidden_proto(xdr_pmaplist) */
bool_t
xdr_pmaplist (xdrs, rp)
XDR *xdrs;
/* libc_hidden_proto(perror) */
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(authunix_create_default)
+/* libc_hidden_proto(authunix_create_default) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdr_callmsg) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xdr_reference)
-libc_hidden_proto(xdr_u_long)
-libc_hidden_proto(xdr_void)
-libc_hidden_proto(xdr_rmtcallres)
-libc_hidden_proto(xdr_rmtcall_args)
-libc_hidden_proto(inet_makeaddr)
-libc_hidden_proto(inet_netof)
-libc_hidden_proto(clntudp_create)
-libc_hidden_proto(setsockopt)
-libc_hidden_proto(recvfrom)
-libc_hidden_proto(sendto)
+/* libc_hidden_proto(xdr_reference) */
+/* libc_hidden_proto(xdr_u_long) */
+/* libc_hidden_proto(xdr_void) */
+/* libc_hidden_proto(xdr_rmtcallres) */
+/* libc_hidden_proto(xdr_rmtcall_args) */
+/* libc_hidden_proto(inet_makeaddr) */
+/* libc_hidden_proto(inet_netof) */
+/* libc_hidden_proto(clntudp_create) */
+/* libc_hidden_proto(setsockopt) */
+/* libc_hidden_proto(recvfrom) */
+/* libc_hidden_proto(sendto) */
/* libc_hidden_proto(poll) */
/* libc_hidden_proto(fprintf) */
/* libc_hidden_proto(lstat) */
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(tolower) */
-libc_hidden_proto(sysconf)
-libc_hidden_proto(getline)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(seteuid)
-libc_hidden_proto(getpwnam_r)
-libc_hidden_proto(gethostbyname)
-libc_hidden_proto(gethostbyname_r)
-libc_hidden_proto(fileno)
-libc_hidden_proto(sleep)
-libc_hidden_proto(inet_addr)
-libc_hidden_proto(inet_ntoa)
-libc_hidden_proto(herror)
-libc_hidden_proto(bind)
-libc_hidden_proto(connect)
-libc_hidden_proto(sigblock)
-libc_hidden_proto(snprintf)
+/* libc_hidden_proto(sysconf) */
+/* libc_hidden_proto(getline) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(seteuid) */
+/* libc_hidden_proto(getpwnam_r) */
+/* libc_hidden_proto(gethostbyname) */
+/* libc_hidden_proto(gethostbyname_r) */
+/* libc_hidden_proto(fileno) */
+/* libc_hidden_proto(sleep) */
+/* libc_hidden_proto(inet_addr) */
+/* libc_hidden_proto(inet_ntoa) */
+/* libc_hidden_proto(herror) */
+/* libc_hidden_proto(bind) */
+/* libc_hidden_proto(connect) */
+/* libc_hidden_proto(sigblock) */
+/* libc_hidden_proto(snprintf) */
/* libc_hidden_proto(poll) */
-libc_hidden_proto(accept)
-libc_hidden_proto(listen)
-libc_hidden_proto(sigsetmask)
-libc_hidden_proto(getc_unlocked)
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(accept) */
+/* libc_hidden_proto(listen) */
+/* libc_hidden_proto(sigsetmask) */
+/* libc_hidden_proto(getc_unlocked) */
+/* libc_hidden_proto(__fgetc_unlocked) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(fprintf) */
-libc_hidden_proto(__h_errno_location)
+/* libc_hidden_proto(__h_errno_location) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
/* libc_hidden_proto(__ctype_tolower_loc) */
/* libc_hidden_proto(__ctype_tolower) */
#endif
-libc_hidden_proto(rresvport)
+/* libc_hidden_proto(rresvport) */
/* some forward declarations */
static int __ivaliduser2(FILE *hostf, u_int32_t raddr,
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(perror) */
/* libc_hidden_proto(sprintf) */
-libc_hidden_proto(snprintf)
-libc_hidden_proto(getsockname)
-libc_hidden_proto(getnameinfo)
-libc_hidden_proto(getaddrinfo)
-libc_hidden_proto(freeaddrinfo)
-libc_hidden_proto(sleep)
-libc_hidden_proto(atoi)
-libc_hidden_proto(connect)
-libc_hidden_proto(accept)
-libc_hidden_proto(listen)
-libc_hidden_proto(ruserpass)
+/* libc_hidden_proto(snprintf) */
+/* libc_hidden_proto(getsockname) */
+/* libc_hidden_proto(getnameinfo) */
+/* libc_hidden_proto(getaddrinfo) */
+/* libc_hidden_proto(freeaddrinfo) */
+/* libc_hidden_proto(sleep) */
+/* libc_hidden_proto(atoi) */
+/* libc_hidden_proto(connect) */
+/* libc_hidden_proto(accept) */
+/* libc_hidden_proto(listen) */
+/* libc_hidden_proto(ruserpass) */
#define SA_LEN(_x) __libc_sa_len((_x)->sa_family)
extern int __libc_sa_len (sa_family_t __af) __THROW attribute_hidden;
int rexecoptions;
char ahostbuf[NI_MAXHOST] attribute_hidden;
-libc_hidden_proto(rexec_af)
+/* libc_hidden_proto(rexec_af) */
int
rexec_af(char **ahost, int rport, const char *name, const char *pass, const char *cmd, int *fd2p, sa_family_t af)
{
#include <rpc/rpc.h>
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(xdr_enum)
-libc_hidden_proto(xdr_opaque)
-libc_hidden_proto(xdr_u_int)
-libc_hidden_proto(xdr_u_long)
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_enum) */
+/* libc_hidden_proto(xdr_opaque) */
+/* libc_hidden_proto(xdr_u_int) */
+/* libc_hidden_proto(xdr_u_long) */
+/* libc_hidden_proto(xdr_opaque_auth) */
/*
* XDR a call message
*/
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdr_callmsg) */
bool_t
xdr_callmsg (XDR *xdrs, struct rpc_msg *cmsg)
{
#include <unistd.h>
#include <rpc/clnt.h>
-libc_hidden_proto(getdtablesize)
+/* libc_hidden_proto(getdtablesize) */
/*
* Cache the result of getdtablesize(), so we don't have to do an
* expensive system call every time.
*/
-libc_hidden_proto(_rpc_dtablesize)
+/* libc_hidden_proto(_rpc_dtablesize) */
int
_rpc_dtablesize(void)
{
/* Now define the internal interfaces. */
extern u_long _create_xid (void) attribute_hidden;
-libc_hidden_proto(__rpc_thread_createerr)
+/* libc_hidden_proto(__rpc_thread_createerr) */
/*
* Multi-threaded support
#include <rpc/rpc.h>
-libc_hidden_proto(xdr_bytes)
-libc_hidden_proto(xdr_union)
-libc_hidden_proto(xdr_enum)
-libc_hidden_proto(xdr_opaque)
-libc_hidden_proto(xdr_u_long)
+/* libc_hidden_proto(xdr_bytes) */
+/* libc_hidden_proto(xdr_union) */
+/* libc_hidden_proto(xdr_enum) */
+/* libc_hidden_proto(xdr_opaque) */
+/* libc_hidden_proto(xdr_u_long) */
/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
* XDR an opaque authentication struct
* (see auth.h)
*/
-libc_hidden_proto(xdr_opaque_auth)
+/* libc_hidden_proto(xdr_opaque_auth) */
bool_t
xdr_opaque_auth (XDR *xdrs, struct opaque_auth *ap)
{
/*
* XDR the MSG_ACCEPTED part of a reply message union
*/
-libc_hidden_proto(xdr_accepted_reply)
+/* libc_hidden_proto(xdr_accepted_reply) */
bool_t
xdr_accepted_reply (XDR *xdrs, struct accepted_reply *ar)
{
/*
* XDR the MSG_DENIED part of a reply message union
*/
-libc_hidden_proto(xdr_rejected_reply)
+/* libc_hidden_proto(xdr_rejected_reply) */
bool_t
xdr_rejected_reply (XDR *xdrs, struct rejected_reply *rr)
{
* The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
* The rm_xid is not really static, but the user can easily munge on the fly.
*/
-libc_hidden_proto(xdr_callhdr)
+/* libc_hidden_proto(xdr_callhdr) */
bool_t
xdr_callhdr (XDR *xdrs, struct rpc_msg *cmsg)
{
/*
* given a reply message, fills in the error
*/
-libc_hidden_proto(_seterr_reply)
+/* libc_hidden_proto(_seterr_reply) */
void
_seterr_reply (struct rpc_msg *msg,
struct rpc_err *error)
#include <assert.h>
#include "rpc_private.h"
-libc_hidden_proto(__rpc_thread_svc_fdset)
-libc_hidden_proto(__rpc_thread_createerr)
-libc_hidden_proto(__rpc_thread_svc_pollfd)
-libc_hidden_proto(__rpc_thread_svc_max_pollfd)
+/* libc_hidden_proto(__rpc_thread_svc_fdset) */
+/* libc_hidden_proto(__rpc_thread_createerr) */
+/* libc_hidden_proto(__rpc_thread_svc_pollfd) */
+/* libc_hidden_proto(__rpc_thread_svc_max_pollfd) */
#ifdef __UCLIBC_HAS_THREADS__
/* libc_hidden_proto(read) */
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(connect)
-libc_hidden_proto(recvfrom)
-libc_hidden_proto(sendto)
+/* libc_hidden_proto(connect) */
+/* libc_hidden_proto(recvfrom) */
+/* libc_hidden_proto(sendto) */
/* libc_hidden_proto(poll) */
-libc_hidden_proto(rtime)
+/* libc_hidden_proto(rtime) */
#define NYEARS (u_long)(1970 - 1900)
#define TOFFSET (u_long)(60*60*24*(365*NYEARS + (NYEARS/4)))
/* libc_hidden_proto(getenv) */
/* libc_hidden_proto(printf) */
/* libc_hidden_proto(fstat) */
-libc_hidden_proto(__fsetlocking)
-libc_hidden_proto(getgid)
-libc_hidden_proto(getuid)
-libc_hidden_proto(getegid)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(gethostname)
-libc_hidden_proto(fileno)
+/* libc_hidden_proto(__fsetlocking) */
+/* libc_hidden_proto(getgid) */
+/* libc_hidden_proto(getuid) */
+/* libc_hidden_proto(getegid) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(gethostname) */
+/* libc_hidden_proto(fileno) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(getc_unlocked)
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(getc_unlocked) */
+/* libc_hidden_proto(__fgetc_unlocked) */
#define _(X) (X)
/* #include "ftp_var.h" */
/* ruserpass - remote password check.
This function also exists in glibc but is undocumented */
-libc_hidden_proto(ruserpass)
+/* libc_hidden_proto(ruserpass) */
int ruserpass(const char *host, const char **aname, const char **apass)
{
char *hdir, *buf, *tmp;
#include <sys/poll.h>
/* Experimentally off - libc_hidden_proto(ffs) */
-libc_hidden_proto(pmap_set)
-libc_hidden_proto(pmap_unset)
-libc_hidden_proto(_authenticate)
-libc_hidden_proto(_rpc_dtablesize)
+/* libc_hidden_proto(pmap_set) */
+/* libc_hidden_proto(pmap_unset) */
+/* libc_hidden_proto(_authenticate) */
+/* libc_hidden_proto(_rpc_dtablesize) */
/* used by svc_[max_]pollfd */
-libc_hidden_proto(__rpc_thread_svc_pollfd)
-libc_hidden_proto(__rpc_thread_svc_max_pollfd)
+/* libc_hidden_proto(__rpc_thread_svc_pollfd) */
+/* libc_hidden_proto(__rpc_thread_svc_max_pollfd) */
/* used by svc_fdset */
-libc_hidden_proto(__rpc_thread_svc_fdset)
+/* libc_hidden_proto(__rpc_thread_svc_fdset) */
#ifdef __UCLIBC_HAS_THREADS__
#define xports (*(SVCXPRT ***)&RPC_THREAD_VARIABLE(svc_xports_s))
/* *************** SVCXPRT related stuff **************** */
/* Activate a transport handle. */
-libc_hidden_proto(xprt_register)
+/* libc_hidden_proto(xprt_register) */
void
xprt_register (SVCXPRT *xprt)
{
libc_hidden_def(xprt_register)
/* De-activate a transport handle. */
-libc_hidden_proto(xprt_unregister)
+/* libc_hidden_proto(xprt_unregister) */
void
xprt_unregister (SVCXPRT *xprt)
{
/* Add a service program to the callout list.
The dispatch routine will be called when a rpc request for this
program number comes in. */
-libc_hidden_proto(svc_register)
+/* libc_hidden_proto(svc_register) */
bool_t
svc_register (SVCXPRT * xprt, rpcprog_t prog, rpcvers_t vers,
void (*dispatch) (struct svc_req *, SVCXPRT *),
libc_hidden_def(svc_register)
/* Remove a service program from the callout list. */
-libc_hidden_proto(svc_unregister)
+/* libc_hidden_proto(svc_unregister) */
void
svc_unregister (rpcprog_t prog, rpcvers_t vers)
{
/* ******************* REPLY GENERATION ROUTINES ************ */
/* Send a reply to an rpc request */
-libc_hidden_proto(svc_sendreply)
+/* libc_hidden_proto(svc_sendreply) */
bool_t
svc_sendreply (register SVCXPRT *xprt, xdrproc_t xdr_results,
caddr_t xdr_location)
}
/* Can't decode args error reply */
-libc_hidden_proto(svcerr_decode)
+/* libc_hidden_proto(svcerr_decode) */
void
svcerr_decode (register SVCXPRT *xprt)
{
}
/* Authentication error reply */
-libc_hidden_proto(svcerr_auth)
+/* libc_hidden_proto(svcerr_auth) */
void
svcerr_auth (SVCXPRT *xprt, enum auth_stat why)
{
}
/* Program unavailable error reply */
-libc_hidden_proto(svcerr_noprog)
+/* libc_hidden_proto(svcerr_noprog) */
void
svcerr_noprog (register SVCXPRT *xprt)
{
libc_hidden_def(svcerr_noprog)
/* Program version mismatch error reply */
-libc_hidden_proto(svcerr_progvers)
+/* libc_hidden_proto(svcerr_progvers) */
void
svcerr_progvers (register SVCXPRT *xprt, rpcvers_t low_vers,
rpcvers_t high_vers)
* is mallocated in kernel land.
*/
-libc_hidden_proto(svc_getreq_common)
+/* libc_hidden_proto(svc_getreq_common) */
void
svc_getreq_common (const int fd)
{
}
libc_hidden_def(svc_getreq_common)
-libc_hidden_proto(svc_getreqset)
+/* libc_hidden_proto(svc_getreqset) */
void
svc_getreqset (fd_set *readfds)
{
}
libc_hidden_def(svc_getreqset)
-libc_hidden_proto(svc_getreq)
+/* libc_hidden_proto(svc_getreq) */
void
svc_getreq (int rdfds)
{
}
libc_hidden_def(svc_getreq)
-libc_hidden_proto(svc_getreq_poll)
+/* libc_hidden_proto(svc_getreq_poll) */
void
svc_getreq_poll (struct pollfd *pfdp, int pollretval)
{
* There is an assumption that any flavour less than AUTH_NULL is
* invalid.
*/
-libc_hidden_proto(_authenticate)
+/* libc_hidden_proto(_authenticate) */
enum auth_stat
_authenticate (register struct svc_req *rqst, struct rpc_msg *msg)
{
/* Experimentally off - libc_hidden_proto(memcpy) */
/* libc_hidden_proto(printf) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_authunix_parms)
+/* libc_hidden_proto(xdr_authunix_parms) */
/*
* Unix longhand authenticator
#include <rpc/svc.h>
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdr_callmsg) */
/* libc_hidden_proto(xdr_replymsg) */
/*
#include <rpc/rpc.h>
/* libc_hidden_proto(perror) */
-libc_hidden_proto(svc_getreq_poll)
+/* libc_hidden_proto(svc_getreq_poll) */
/* libc_hidden_proto(poll) */
/* used by svc_[max_]pollfd */
-libc_hidden_proto(__rpc_thread_svc_pollfd)
-libc_hidden_proto(__rpc_thread_svc_max_pollfd)
+/* libc_hidden_proto(__rpc_thread_svc_pollfd) */
+/* libc_hidden_proto(__rpc_thread_svc_max_pollfd) */
/* This function can be used as a signal handler to terminate the
server loop. */
/* Experimentally off - libc_hidden_proto(strdup) */
/* Experimentally off - libc_hidden_proto(memset) */
-libc_hidden_proto(asprintf)
+/* libc_hidden_proto(asprintf) */
/* libc_hidden_proto(fputs) */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(exit) */
-libc_hidden_proto(svc_sendreply)
-libc_hidden_proto(svc_register)
-libc_hidden_proto(svcerr_decode)
-libc_hidden_proto(svcudp_create)
-libc_hidden_proto(pmap_unset)
-libc_hidden_proto(xdr_void)
+/* libc_hidden_proto(svc_sendreply) */
+/* libc_hidden_proto(svc_register) */
+/* libc_hidden_proto(svcerr_decode) */
+/* libc_hidden_proto(svcudp_create) */
+/* libc_hidden_proto(pmap_unset) */
+/* libc_hidden_proto(xdr_void) */
struct proglst_
{
/* libc_hidden_proto(read) */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(perror) */
-libc_hidden_proto(xdrrec_create)
-libc_hidden_proto(xdrrec_endofrecord)
-libc_hidden_proto(xdrrec_skiprecord)
-libc_hidden_proto(xdrrec_eof)
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdrrec_create) */
+/* libc_hidden_proto(xdrrec_endofrecord) */
+/* libc_hidden_proto(xdrrec_skiprecord) */
+/* libc_hidden_proto(xdrrec_eof) */
+/* libc_hidden_proto(xdr_callmsg) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xprt_register)
-libc_hidden_proto(xprt_unregister)
-libc_hidden_proto(getsockname)
-libc_hidden_proto(bind)
-libc_hidden_proto(bindresvport)
+/* libc_hidden_proto(xprt_register) */
+/* libc_hidden_proto(xprt_unregister) */
+/* libc_hidden_proto(getsockname) */
+/* libc_hidden_proto(bind) */
+/* libc_hidden_proto(bindresvport) */
/* libc_hidden_proto(poll) */
-libc_hidden_proto(accept)
-libc_hidden_proto(listen)
+/* libc_hidden_proto(accept) */
+/* libc_hidden_proto(listen) */
/* libc_hidden_proto(fputs) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(abort) */
/* libc_hidden_proto(perror) */
/* libc_hidden_proto(socket) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(xprt_register)
-libc_hidden_proto(xprt_unregister)
+/* libc_hidden_proto(xprt_register) */
+/* libc_hidden_proto(xprt_unregister) */
/* libc_hidden_proto(xdrmem_create) */
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdr_callmsg) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(getsockname)
-libc_hidden_proto(setsockopt)
-libc_hidden_proto(bind)
-libc_hidden_proto(bindresvport)
-libc_hidden_proto(recvfrom)
-libc_hidden_proto(sendto)
-libc_hidden_proto(recvmsg)
-libc_hidden_proto(sendmsg)
+/* libc_hidden_proto(getsockname) */
+/* libc_hidden_proto(setsockopt) */
+/* libc_hidden_proto(bind) */
+/* libc_hidden_proto(bindresvport) */
+/* libc_hidden_proto(recvfrom) */
+/* libc_hidden_proto(sendto) */
+/* libc_hidden_proto(recvmsg) */
+/* libc_hidden_proto(sendmsg) */
/* libc_hidden_proto(fputs) */
/* libc_hidden_proto(fprintf) */
* see (svc.h, xprt_register).
* The routines returns NULL if a problem occurred.
*/
-libc_hidden_proto(svcudp_bufcreate)
+/* libc_hidden_proto(svcudp_bufcreate) */
SVCXPRT *
svcudp_bufcreate (int sock, u_int sendsz, u_int recvsz)
{
}
libc_hidden_def(svcudp_bufcreate)
-libc_hidden_proto(svcudp_create)
+/* libc_hidden_proto(svcudp_create) */
SVCXPRT *
svcudp_create (int sock)
{
/* libc_hidden_proto(close) */
/* libc_hidden_proto(perror) */
/* libc_hidden_proto(getpid) */
-libc_hidden_proto(xdrrec_create)
-libc_hidden_proto(xdrrec_endofrecord)
-libc_hidden_proto(xdrrec_skiprecord)
-libc_hidden_proto(xdrrec_eof)
-libc_hidden_proto(xdr_callmsg)
+/* libc_hidden_proto(xdrrec_create) */
+/* libc_hidden_proto(xdrrec_endofrecord) */
+/* libc_hidden_proto(xdrrec_skiprecord) */
+/* libc_hidden_proto(xdrrec_eof) */
+/* libc_hidden_proto(xdr_callmsg) */
/* libc_hidden_proto(xdr_replymsg) */
-libc_hidden_proto(xprt_register)
-libc_hidden_proto(xprt_unregister)
-libc_hidden_proto(getegid)
-libc_hidden_proto(geteuid)
-libc_hidden_proto(getsockname)
-libc_hidden_proto(setsockopt)
-libc_hidden_proto(bind)
-libc_hidden_proto(recvmsg)
-libc_hidden_proto(sendmsg)
+/* libc_hidden_proto(xprt_register) */
+/* libc_hidden_proto(xprt_unregister) */
+/* libc_hidden_proto(getegid) */
+/* libc_hidden_proto(geteuid) */
+/* libc_hidden_proto(getsockname) */
+/* libc_hidden_proto(setsockopt) */
+/* libc_hidden_proto(bind) */
+/* libc_hidden_proto(recvmsg) */
+/* libc_hidden_proto(sendmsg) */
/* libc_hidden_proto(poll) */
-libc_hidden_proto(accept)
-libc_hidden_proto(listen)
+/* libc_hidden_proto(accept) */
+/* libc_hidden_proto(listen) */
/* libc_hidden_proto(fputs) */
/* libc_hidden_proto(abort) */
/*
* XDR nothing
*/
-libc_hidden_proto(xdr_void)
+/* libc_hidden_proto(xdr_void) */
bool_t
xdr_void (void)
{
* The definition of xdr_long() is kept for backward
* compatibility. Instead xdr_int() should be used.
*/
-libc_hidden_proto(xdr_long)
+/* libc_hidden_proto(xdr_long) */
bool_t
xdr_long (XDR *xdrs, long *lp)
{
/*
* XDR short integers
*/
-libc_hidden_proto(xdr_short)
+/* libc_hidden_proto(xdr_short) */
bool_t
xdr_short (XDR *xdrs, short *sp)
{
/*
* XDR integers
*/
-libc_hidden_proto(xdr_int)
+/* libc_hidden_proto(xdr_int) */
bool_t
xdr_int (XDR *xdrs, int *ip)
{
* The definition of xdr_u_long() is kept for backward
* compatibility. Instead xdr_u_int() should be used.
*/
-libc_hidden_proto(xdr_u_long)
+/* libc_hidden_proto(xdr_u_long) */
bool_t
xdr_u_long (XDR *xdrs, u_long *ulp)
{
/*
* XDR unsigned integers
*/
-libc_hidden_proto(xdr_u_int)
+/* libc_hidden_proto(xdr_u_int) */
bool_t
xdr_u_int (XDR *xdrs, u_int *up)
{
* XDR hyper integers
* same as xdr_u_hyper - open coded to save a proc call!
*/
-libc_hidden_proto(xdr_hyper)
+/* libc_hidden_proto(xdr_hyper) */
bool_t
xdr_hyper (XDR *xdrs, quad_t *llp)
{
* XDR hyper integers
* same as xdr_hyper - open coded to save a proc call!
*/
-libc_hidden_proto(xdr_u_hyper)
+/* libc_hidden_proto(xdr_u_hyper) */
bool_t
xdr_u_hyper (XDR *xdrs, u_quad_t *ullp)
{
/*
* XDR unsigned short integers
*/
-libc_hidden_proto(xdr_u_short)
+/* libc_hidden_proto(xdr_u_short) */
bool_t
xdr_u_short (XDR *xdrs, u_short *usp)
{
/*
* XDR booleans
*/
-libc_hidden_proto(xdr_bool)
+/* libc_hidden_proto(xdr_bool) */
bool_t
xdr_bool (XDR *xdrs, bool_t *bp)
{
/*
* XDR enumerations
*/
-libc_hidden_proto(xdr_enum)
+/* libc_hidden_proto(xdr_enum) */
bool_t
xdr_enum (XDR *xdrs, enum_t *ep)
{
* Allows the specification of a fixed size sequence of opaque bytes.
* cp points to the opaque object and cnt gives the byte length.
*/
-libc_hidden_proto(xdr_opaque)
+/* libc_hidden_proto(xdr_opaque) */
bool_t
xdr_opaque (XDR *xdrs, caddr_t cp, u_int cnt)
{
* *cpp is a pointer to the bytes, *sizep is the count.
* If *cpp is NULL maxsize bytes are allocated
*/
-libc_hidden_proto(xdr_bytes)
+/* libc_hidden_proto(xdr_bytes) */
bool_t
xdr_bytes (XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize)
{
* routine may be called.
* If there is no specific or default routine an error is returned.
*/
-libc_hidden_proto(xdr_union)
+/* libc_hidden_proto(xdr_union) */
bool_t
xdr_union (XDR *xdrs, enum_t *dscmp, char *unp, const struct xdr_discrim *choices, xdrproc_t dfault)
{
* storage is allocated. The last parameter is the max allowed length
* of the string as specified by a protocol.
*/
-libc_hidden_proto(xdr_string)
+/* libc_hidden_proto(xdr_string) */
bool_t
xdr_string (XDR *xdrs, char **cpp, u_int maxsize)
{
/* Experimentally off - libc_hidden_proto(memset) */
/* libc_hidden_proto(fputs) */
-libc_hidden_proto(xdr_u_int)
+/* libc_hidden_proto(xdr_u_int) */
#define LASTUNSIGNED ((u_int)0-1)
* elsize is the size (in bytes) of each element, and elproc is the
* xdr procedure to call to handle each element of the array.
*/
-libc_hidden_proto(xdr_array)
+/* libc_hidden_proto(xdr_array) */
bool_t
xdr_array (XDR *xdrs, caddr_t *addrp, u_int *sizep, u_int maxsize, u_int elsize, xdrproc_t elproc)
{
* write respectively. They are like the system
* calls expect that they take an opaque handle rather than an fd.
*/
-libc_hidden_proto(xdrrec_create)
+/* libc_hidden_proto(xdrrec_create) */
void
xdrrec_create (XDR *xdrs, u_int sendsize,
u_int recvsize, caddr_t tcp_handle,
* Before reading (deserializing from the stream, one should always call
* this procedure to guarantee proper record alignment.
*/
-libc_hidden_proto(xdrrec_skiprecord)
+/* libc_hidden_proto(xdrrec_skiprecord) */
bool_t
xdrrec_skiprecord (XDR *xdrs)
{
* Returns TRUE iff there is no more input in the buffer
* after consuming the rest of the current record.
*/
-libc_hidden_proto(xdrrec_eof)
+/* libc_hidden_proto(xdrrec_eof) */
bool_t
xdrrec_eof (XDR *xdrs)
{
* (output) tcp stream. (This lets the package support batched or
* pipelined procedure calls.) TRUE => immediate flush to tcp connection.
*/
-libc_hidden_proto(xdrrec_endofrecord)
+/* libc_hidden_proto(xdrrec_endofrecord) */
bool_t
xdrrec_endofrecord (XDR *xdrs, bool_t sendnow)
{
#endif
/* Experimentally off - libc_hidden_proto(memset) */
-libc_hidden_proto(xdr_bool)
+/* libc_hidden_proto(xdr_bool) */
/* libc_hidden_proto(fputs) */
#define LASTUNSIGNED ((u_int)0-1)
* size is the size of the referneced structure.
* proc is the routine to handle the referenced structure.
*/
-libc_hidden_proto(xdr_reference)
+/* libc_hidden_proto(xdr_reference) */
bool_t
xdr_reference (XDR *xdrs, caddr_t *pp, u_int size, xdrproc_t proc)
{
# define fwrite(p, m, n, s) _IO_fwrite (p, m, n, s)
#endif
-libc_hidden_proto(fread)
-libc_hidden_proto(fwrite)
-libc_hidden_proto(fseek)
-libc_hidden_proto(fflush)
-libc_hidden_proto(ftell)
+/* libc_hidden_proto(fread) */
+/* libc_hidden_proto(fwrite) */
+/* libc_hidden_proto(fseek) */
+/* libc_hidden_proto(fflush) */
+/* libc_hidden_proto(ftell) */
static bool_t xdrstdio_getlong (XDR *, long *);
static bool_t xdrstdio_putlong (XDR *, const long *);
return __socketcall(SYS_ACCEPT, args);
}
#endif
-libc_hidden_proto(accept)
+/* libc_hidden_proto(accept) */
weak_alias(__libc_accept,accept)
libc_hidden_weak(accept)
#endif
#ifdef L_bind
-libc_hidden_proto(bind)
+/* libc_hidden_proto(bind) */
#ifdef __NR_bind
_syscall3(int, bind, int, sockfd, const struct sockaddr *, myaddr, socklen_t, addrlen)
#elif defined(__NR_socketcall)
return __socketcall(SYS_CONNECT, args);
}
#endif
-libc_hidden_proto(connect)
+/* libc_hidden_proto(connect) */
weak_alias(__libc_connect,connect)
libc_hidden_weak(connect)
#endif
#endif
#ifdef L_getsockname
-libc_hidden_proto(getsockname)
+/* libc_hidden_proto(getsockname) */
#ifdef __NR_getsockname
_syscall3(int, getsockname, int, sockfd, struct sockaddr *, addr, socklen_t *,paddrlen)
#elif defined(__NR_socketcall)
#endif
#ifdef L_listen
-libc_hidden_proto(listen)
+/* libc_hidden_proto(listen) */
#ifdef __NR_listen
_syscall2(int, listen, int, sockfd, int, backlog)
#elif defined(__NR_socketcall)
return (__socketcall(SYS_RECV, args));
}
#elif defined(__NR_recvfrom)
-libc_hidden_proto(recvfrom)
+/* libc_hidden_proto(recvfrom) */
ssize_t __libc_recv(int sockfd, __ptr_t buffer, size_t len, int flags)
{
return (recvfrom(sockfd, buffer, len, flags, NULL, NULL));
}
#endif
-libc_hidden_proto(recv)
+/* libc_hidden_proto(recv) */
weak_alias(__libc_recv,recv)
libc_hidden_weak(recv)
#endif
return (__socketcall(SYS_RECVFROM, args));
}
#endif
-libc_hidden_proto(recvfrom)
+/* libc_hidden_proto(recvfrom) */
weak_alias(__libc_recvfrom,recvfrom)
libc_hidden_weak(recvfrom)
#endif
return (__socketcall(SYS_RECVMSG, args));
}
#endif
-libc_hidden_proto(recvmsg)
+/* libc_hidden_proto(recvmsg) */
weak_alias(__libc_recvmsg,recvmsg)
libc_hidden_weak(recvmsg)
#endif
return (__socketcall(SYS_SEND, args));
}
#elif defined(__NR_sendto)
-libc_hidden_proto(sendto)
+/* libc_hidden_proto(sendto) */
ssize_t __libc_send(int sockfd, const void *buffer, size_t len, int flags)
{
return (sendto(sockfd, buffer, len, flags, NULL, 0));
}
#endif
-libc_hidden_proto(send)
+/* libc_hidden_proto(send) */
weak_alias(__libc_send,send)
libc_hidden_weak(send)
#endif
return (__socketcall(SYS_SENDMSG, args));
}
#endif
-libc_hidden_proto(sendmsg)
+/* libc_hidden_proto(sendmsg) */
weak_alias(__libc_sendmsg,sendmsg)
libc_hidden_weak(sendmsg)
#endif
return (__socketcall(SYS_SENDTO, args));
}
#endif
-libc_hidden_proto(sendto)
+/* libc_hidden_proto(sendto) */
weak_alias(__libc_sendto,sendto)
libc_hidden_weak(sendto)
#endif
#ifdef L_setsockopt
-libc_hidden_proto(setsockopt)
+/* libc_hidden_proto(setsockopt) */
#ifdef __NR_setsockopt
_syscall5(int, setsockopt, int, fd, int, level, int, optname, const void *, optval, socklen_t, optlen)
#elif defined(__NR_socketcall)
#include <assert.h>
#undef assert
-libc_hidden_proto(__assert)
+/* libc_hidden_proto(__assert) */
#define ASSERT_SHOW_PROGNAME 1
#ifdef L_tolower_l
#undef tolower_l
-libc_hidden_proto(tolower_l)
+/* libc_hidden_proto(tolower_l) */
int tolower_l(int c, __locale_t l)
{
#if defined(__UCLIBC_HAS_CTYPE_ENFORCED__)
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_toupper_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
-libc_hidden_proto(__ctype_toupper)
+/* libc_hidden_proto(__ctype_toupper) */
#endif
/* libc_hidden_proto(toupper) */
#ifdef __UCLIBC_HAS_CTYPE_TABLES__
#ifdef L_toupper_l
#undef toupper_l
-libc_hidden_proto(toupper_l)
+/* libc_hidden_proto(toupper_l) */
int toupper_l(int c, __locale_t l)
{
#if defined(__UCLIBC_HAS_CTYPE_ENFORCED__)
#else /* __UCLIBC_HAS_CTYPE_TABLES__ */
-libc_hidden_proto(isascii)
+/* libc_hidden_proto(isascii) */
int isascii(int c)
{
return __isascii(c); /* locale-independent */
/**********************************************************************/
#ifdef L___C_ctype_b
+//vda:TODO:make static
+
extern const __ctype_mask_t __C_ctype_b_data[];
libc_hidden_proto(__C_ctype_b_data)
const __ctype_mask_t __C_ctype_b_data[] = {
/**********************************************************************/
#ifdef L___C_ctype_tolower
+//vda:TODO: make static
+
extern const __ctype_touplow_t __C_ctype_tolower_data[];
libc_hidden_proto(__C_ctype_tolower_data)
const __ctype_touplow_t __C_ctype_tolower_data[] = {
libc_hidden_data_def(__C_ctype_tolower_data)
/* libc_hidden_proto(__C_ctype_tolower) */
-const __ctype_touplow_t *__C_ctype_tolower = __C_ctype_tolower_data
- + __UCLIBC_CTYPE_TO_TBL_OFFSET;
+const __ctype_touplow_t *__C_ctype_tolower =
+ __C_ctype_tolower_data + __UCLIBC_CTYPE_TO_TBL_OFFSET;
libc_hidden_data_def(__C_ctype_tolower)
#ifndef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_tolower) */
-const __ctype_touplow_t *__ctype_tolower = __C_ctype_tolower_data
- + __UCLIBC_CTYPE_TO_TBL_OFFSET;
+const __ctype_touplow_t *__ctype_tolower =
+ __C_ctype_tolower_data + __UCLIBC_CTYPE_TO_TBL_OFFSET;
libc_hidden_data_def(__ctype_tolower)
#endif
/**********************************************************************/
#ifdef L___C_ctype_toupper
+//vda:TODO: make static
+
extern const __ctype_touplow_t __C_ctype_toupper_data[];
libc_hidden_proto(__C_ctype_toupper_data)
const __ctype_touplow_t __C_ctype_toupper_data[] = {
libc_hidden_data_def(__C_ctype_toupper_data)
/* libc_hidden_proto(__C_ctype_toupper) */
-const __ctype_touplow_t *__C_ctype_toupper = __C_ctype_toupper_data
- + __UCLIBC_CTYPE_TO_TBL_OFFSET;
+const __ctype_touplow_t *__C_ctype_toupper =
+ __C_ctype_toupper_data + __UCLIBC_CTYPE_TO_TBL_OFFSET;
libc_hidden_data_def(__C_ctype_toupper)
#ifndef __UCLIBC_HAS_XLOCALE__
-libc_hidden_proto(__ctype_toupper)
-const __ctype_touplow_t *__ctype_toupper = __C_ctype_toupper_data
- + __UCLIBC_CTYPE_TO_TBL_OFFSET;
+/* libc_hidden_proto(__ctype_toupper) */
+const __ctype_touplow_t *__ctype_toupper =
+ __C_ctype_toupper_data + __UCLIBC_CTYPE_TO_TBL_OFFSET;
libc_hidden_data_def(__ctype_toupper)
#endif
#include <unistd.h>
#include "dirstream.h"
-libc_hidden_proto(closedir)
+/* libc_hidden_proto(closedir) */
/* libc_hidden_proto(close) */
int closedir(DIR * dir)
#include <errno.h>
#include "dirstream.h"
-libc_hidden_proto(dirfd)
+/* libc_hidden_proto(dirfd) */
int dirfd(DIR * dir)
{
#include <sys/stat.h>
#include "dirstream.h"
-libc_hidden_proto(opendir)
+/* libc_hidden_proto(opendir) */
/* libc_hidden_proto(open) */
/* libc_hidden_proto(fcntl) */
/* libc_hidden_proto(close) */
#include <dirent.h>
#include "dirstream.h"
-libc_hidden_proto(readdir)
+/* libc_hidden_proto(readdir) */
struct dirent *readdir(DIR * dir)
{
#include <dirent.h>
#include "dirstream.h"
-libc_hidden_proto(readdir64)
+/* libc_hidden_proto(readdir64) */
struct dirent64 *readdir64(DIR * dir)
{
ssize_t bytes;
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(readdir64_r)
+/* libc_hidden_proto(readdir64_r) */
int readdir64_r(DIR *dir, struct dirent64 *entry, struct dirent64 **result)
{
int ret;
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(readdir_r)
+/* libc_hidden_proto(readdir_r) */
int readdir_r(DIR *dir, struct dirent *entry, struct dirent **result)
{
int ret;
#include "dirstream.h"
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(closedir)
-libc_hidden_proto(qsort)
-libc_hidden_proto(readdir)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(closedir) */
+/* libc_hidden_proto(qsort) */
+/* libc_hidden_proto(readdir) */
int scandir(const char *dir, struct dirent ***namelist,
int (*selector) (const struct dirent *),
#include "dirstream.h"
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(closedir)
-libc_hidden_proto(qsort)
-libc_hidden_proto(readdir64)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(closedir) */
+/* libc_hidden_proto(qsort) */
+/* libc_hidden_proto(readdir64) */
int scandir64(const char *dir, struct dirent64 ***namelist,
int (*selector) (const struct dirent64 *),
#if defined __USE_BSD
-libc_hidden_proto(vwarn)
-libc_hidden_proto(vwarnx)
-libc_hidden_proto(verr)
-libc_hidden_proto(verrx)
+/* libc_hidden_proto(vwarn) */
+/* libc_hidden_proto(vwarnx) */
+/* libc_hidden_proto(verr) */
+/* libc_hidden_proto(verrx) */
/* libc_hidden_proto(fprintf) */
/* libc_hidden_proto(vfprintf) */
-libc_hidden_proto(__xpg_strerror_r)
+/* libc_hidden_proto(__xpg_strerror_r) */
/* libc_hidden_proto(exit) */
/* libc_hidden_proto(vfprintf) */
/* Experimentally off - libc_hidden_proto(strerror) */
/* libc_hidden_proto(fprintf) */
/* libc_hidden_proto(exit) */
-libc_hidden_proto(putc)
+/* libc_hidden_proto(putc) */
/* libc_hidden_proto(vfprintf) */
-libc_hidden_proto(fflush)
-libc_hidden_proto(fputc)
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(fflush) */
+/* libc_hidden_proto(fputc) */
+/* libc_hidden_proto(__fputc_unlocked) */
/* This variable is incremented each time `error' is called. */
unsigned int error_message_count = 0;
#include <errno.h>
#include <string.h>
-libc_hidden_proto(lockf)
+/* libc_hidden_proto(lockf) */
/* Experimentally off - libc_hidden_proto(memset) */
/* libc_hidden_proto(fcntl) */
#define F_GETLK F_GETLK64
#undef F_SETLK
#define F_SETLK F_SETLK64
-libc_hidden_proto(fcntl64)
+/* libc_hidden_proto(fcntl64) */
#else
/* libc_hidden_proto(fcntl) */
#endif
/* lockf is a simplified interface to fcntl's locking facilities. */
-libc_hidden_proto(lockf64)
+/* libc_hidden_proto(lockf64) */
int lockf64 (int fd, int cmd, off64_t len64)
{
struct flock fl;
/* libc_hidden_proto(__ctype_tolower) */
#endif
/* libc_hidden_proto(tolower) */
-libc_hidden_proto(fnmatch)
+/* libc_hidden_proto(fnmatch) */
/* libc_hidden_proto(getenv) */
#endif
# include <wchar.h>
# include <wctype.h>
# ifdef __UCLIBC__
-libc_hidden_proto(wctype)
-libc_hidden_proto(iswctype)
-libc_hidden_proto(btowc)
+/* libc_hidden_proto(wctype) */
+/* libc_hidden_proto(iswctype) */
+/* libc_hidden_proto(btowc) */
# ifdef __UCLIBC_HAS_LOCALE__
-libc_hidden_proto(wmemchr)
-libc_hidden_proto(wmempcpy)
-libc_hidden_proto(wcscat)
+/* libc_hidden_proto(wmemchr) */
+/* libc_hidden_proto(wmempcpy) */
+/* libc_hidden_proto(wcscat) */
/*libc_hidden_proto(wcschr)*/
/*libc_hidden_proto(wcschrnul)*/
-libc_hidden_proto(wcslen)
-libc_hidden_proto(wcscoll)
-libc_hidden_proto(towlower)
-libc_hidden_proto(mbsrtowcs)
+/* libc_hidden_proto(wcslen) */
+/* libc_hidden_proto(wcscoll) */
+/* libc_hidden_proto(towlower) */
+/* libc_hidden_proto(mbsrtowcs) */
# endif
# endif
#endif
# endif
#ifdef __UCLIBC_HAS_WCHAR__
-libc_hidden_proto(_stdlib_mb_cur_max)
+/* libc_hidden_proto(_stdlib_mb_cur_max) */
#else
#undef MB_CUR_MAX
#define MB_CUR_MAX 1
#include <fnmatch.h>
#include <ctype.h>
-libc_hidden_proto(fnmatch)
+/* libc_hidden_proto(fnmatch) */
/* libc_hidden_proto(tolower) */
/* Comment out all this code if we are using the GNU C Library, and are not
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strchr) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(dirfd)
-libc_hidden_proto(tsearch)
-libc_hidden_proto(tfind)
-libc_hidden_proto(tdestroy)
-libc_hidden_proto(getcwd)
-libc_hidden_proto(chdir)
-libc_hidden_proto(fchdir)
+/* libc_hidden_proto(dirfd) */
+/* libc_hidden_proto(tsearch) */
+/* libc_hidden_proto(tfind) */
+/* libc_hidden_proto(tdestroy) */
+/* libc_hidden_proto(getcwd) */
+/* libc_hidden_proto(chdir) */
+/* libc_hidden_proto(fchdir) */
/* Experimentally off - libc_hidden_proto(mempcpy) */
-libc_hidden_proto(opendir)
+/* libc_hidden_proto(opendir) */
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(readdir64)
-libc_hidden_proto(lstat64)
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(readdir64) */
+/* libc_hidden_proto(lstat64) */
+/* libc_hidden_proto(stat64) */
#endif
-libc_hidden_proto(closedir)
+/* libc_hidden_proto(closedir) */
/* Experimentally off - libc_hidden_proto(stpcpy) */
/* libc_hidden_proto(lstat) */
/* libc_hidden_proto(stat) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(closedir)
-libc_hidden_proto(qsort)
-libc_hidden_proto(fnmatch)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(closedir) */
+/* libc_hidden_proto(qsort) */
+/* libc_hidden_proto(fnmatch) */
struct match
{
# define stat stat64
# define readdir_r readdir64_r
# define dirent dirent64
-libc_hidden_proto(readdir64_r)
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(readdir64_r) */
+/* libc_hidden_proto(stat64) */
# define struct_stat struct stat64
#else
-libc_hidden_proto(readdir_r)
+/* libc_hidden_proto(readdir_r) */
/* libc_hidden_proto(stat) */
# define struct_stat struct stat
#endif
#endif /* !__GLOB64 */
#ifdef __GLOB64
-libc_hidden_proto(glob64)
+/* libc_hidden_proto(glob64) */
#else
-libc_hidden_proto(glob)
+/* libc_hidden_proto(glob) */
#endif
int glob(const char *pat, int flags, int (*errfunc)(const char *path, int err), glob_t *g)
{
#endif
#ifdef __GLOB64
-libc_hidden_proto(globfree64)
+/* libc_hidden_proto(globfree64) */
#else
-libc_hidden_proto(globfree)
+/* libc_hidden_proto(globfree) */
#endif
void globfree(glob_t *g)
{
#include <fnmatch.h>
#include <glob.h>
-libc_hidden_proto(closedir)
-libc_hidden_proto(fnmatch)
+/* libc_hidden_proto(closedir) */
+/* libc_hidden_proto(fnmatch) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(mempcpy) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(qsort)
-libc_hidden_proto(readdir)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(qsort) */
+/* libc_hidden_proto(readdir) */
/* Experimentally off - libc_hidden_proto(strchr) */
/* Experimentally off - libc_hidden_proto(strcoll) */
/* Experimentally off - libc_hidden_proto(strcpy) */
#ifdef ENABLE_GLOB_TILDE_EXPANSION
#include <pwd.h>
-libc_hidden_proto(getpwnam_r)
+/* libc_hidden_proto(getpwnam_r) */
#endif
#ifdef COMPILE_GLOB64
#define glob_t glob64_t
#define glob(pattern, flags, errfunc, pglob) glob64 (pattern, flags, errfunc, pglob)
#define globfree(pglob) globfree64 (pglob)
-libc_hidden_proto(stat64)
-libc_hidden_proto(readdir64)
+/* libc_hidden_proto(stat64) */
+/* libc_hidden_proto(readdir64) */
#else
#define __readdir readdir
#ifdef __UCLIBC_HAS_LFS__
#define __readdir64 readdir64
-libc_hidden_proto(readdir64)
+/* libc_hidden_proto(readdir64) */
#else
#define __readdir64 readdir
#endif
extern const char *__next_brace_sub (const char *cp, int flags) attribute_hidden;
#endif
-libc_hidden_proto(glob_pattern_p)
+/* libc_hidden_proto(glob_pattern_p) */
#ifndef COMPILE_GLOB64
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
}
#ifdef COMPILE_GLOB64
-libc_hidden_proto(glob64)
-libc_hidden_proto(globfree64)
+/* libc_hidden_proto(glob64) */
+/* libc_hidden_proto(globfree64) */
#else
-libc_hidden_proto(glob)
-libc_hidden_proto(globfree)
+/* libc_hidden_proto(glob) */
+/* libc_hidden_proto(globfree) */
#endif
/* Do glob searching for PATTERN, placing results in PGLOB.
The bits defined above may be set in FLAGS.
#include "internal_errno.h"
-/* psm: moved to bits/errno.h: libc_hidden_proto(__errno_location) */
-libc_hidden_proto(__errno_location)
+/* psm: moved to bits/errno.h: */
+/* libc_hidden_proto(__errno_location) */
int * weak_const_function __errno_location (void)
{
return &errno;
#include "internal_errno.h"
-libc_hidden_proto(__h_errno_location)
+/* libc_hidden_proto(__h_errno_location) */
int * weak_const_function __h_errno_location (void)
{
return &h_errno;
#endif
#ifndef __ARCH_HAS_NO_LDSO__
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(getgid)
-libc_hidden_proto(getuid)
-libc_hidden_proto(getegid)
-libc_hidden_proto(geteuid)
+/* libc_hidden_proto(getgid) */
+/* libc_hidden_proto(getuid) */
+/* libc_hidden_proto(getegid) */
+/* libc_hidden_proto(geteuid) */
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(abort) */
#include "internal_errno.h"
#ifdef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(errno)
-libc_hidden_proto(h_errno)
+/* libc_hidden_proto(errno) */
+/* libc_hidden_proto(h_errno) */
#endif
int errno = 0;
int h_errno = 0;
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* libc_hidden_proto(sprintf) */
-libc_hidden_proto(mkdir)
+/* libc_hidden_proto(mkdir) */
/* libc_hidden_proto(open) */
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(open64)
+/* libc_hidden_proto(open64) */
#endif
/* libc_hidden_proto(read) */
/* libc_hidden_proto(close) */
static char hr_locale[(MAX_LOCALE_CATEGORY_STR * LC_ALL) + MAX_LOCALE_STR];
/* Experimentally off - libc_hidden_proto(stpcpy) */
-libc_hidden_proto(newlocale)
+/* libc_hidden_proto(newlocale) */
static void update_hr_locale(const unsigned char *spec)
{
* placement of the fields in the struct. If necessary, we could ensure
* this usings an array of offsets but at some size cost. */
-libc_hidden_proto(localeconv)
+/* libc_hidden_proto(localeconv) */
#ifdef __LOCALE_C_ONLY
#ifndef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b) */
/* libc_hidden_proto(__ctype_tolower) */
-libc_hidden_proto(__ctype_toupper)
+/* libc_hidden_proto(__ctype_toupper) */
#endif
__uclibc_locale_t __global_locale_data;
']', '\x00', '^', '[', 'n', 'N', ']', '\x00',
};
-libc_hidden_proto(nl_langinfo)
+/* libc_hidden_proto(nl_langinfo) */
char *nl_langinfo(nl_item item)
{
unsigned int c;
#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-libc_hidden_proto(nl_langinfo)
+/* libc_hidden_proto(nl_langinfo) */
-libc_hidden_proto(nl_langinfo_l)
+/* libc_hidden_proto(nl_langinfo_l) */
char *nl_langinfo(nl_item item)
{
#ifdef L_newlocale
/* Experimentally off - libc_hidden_proto(stpcpy) */
-libc_hidden_proto(newlocale)
+/* libc_hidden_proto(newlocale) */
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Move posix and utf8 strings.
/**********************************************************************/
#ifdef L_duplocale
-libc_hidden_proto(duplocale)
+/* libc_hidden_proto(duplocale) */
#ifdef __UCLIBC_MJN3_ONLY__
#warning REMINDER: When we allocate ctype tables, remember to dup them.
__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
-libc_hidden_proto(getmntent_r)
-libc_hidden_proto(setmntent)
-libc_hidden_proto(endmntent)
+/* libc_hidden_proto(getmntent_r) */
+/* libc_hidden_proto(setmntent) */
+/* libc_hidden_proto(endmntent) */
/* Experimentally off - libc_hidden_proto(strstr) */
/* Experimentally off - libc_hidden_proto(strtok_r) */
-libc_hidden_proto(atoi)
+/* libc_hidden_proto(atoi) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(fseek)
+/* libc_hidden_proto(fseek) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(abort) */
/* libc_hidden_proto(fprintf) */
as the initial length of some arrays. */
#ifdef __UCLIBC_HAS_WCHAR__
-libc_hidden_proto(_stdlib_mb_cur_max)
+/* libc_hidden_proto(_stdlib_mb_cur_max) */
#endif
static reg_errcode_t
#define __wcrtomb wcrtomb
#define __btowc btowc
#define __wctype wctype
-libc_hidden_proto(wcscoll)
-libc_hidden_proto(wcrtomb)
-libc_hidden_proto(mbrtowc)
-libc_hidden_proto(iswctype)
-libc_hidden_proto(iswlower)
-libc_hidden_proto(iswalnum)
-libc_hidden_proto(towlower)
-libc_hidden_proto(towupper)
-libc_hidden_proto(mbsinit)
-libc_hidden_proto(btowc)
-libc_hidden_proto(wctype)
+/* libc_hidden_proto(wcscoll) */
+/* libc_hidden_proto(wcrtomb) */
+/* libc_hidden_proto(mbrtowc) */
+/* libc_hidden_proto(iswctype) */
+/* libc_hidden_proto(iswlower) */
+/* libc_hidden_proto(iswalnum) */
+/* libc_hidden_proto(towlower) */
+/* libc_hidden_proto(towupper) */
+/* libc_hidden_proto(mbsinit) */
+/* libc_hidden_proto(btowc) */
+/* libc_hidden_proto(wctype) */
#endif
/* libc_hidden_proto(__ctype_toupper_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(__ctype_b) */
-libc_hidden_proto(__ctype_toupper)
+/* libc_hidden_proto(__ctype_toupper) */
#else
-libc_hidden_proto(isascii)
+/* libc_hidden_proto(isascii) */
#endif
/* libc_hidden_proto(toupper) */
/* libc_hidden_proto(tolower) */
#if defined HAVE_LANGINFO_H || defined HAVE_LANGINFO_CODESET || defined _LIBC
# include <langinfo.h>
-libc_hidden_proto(nl_langinfo)
+/* libc_hidden_proto(nl_langinfo) */
#endif
#if defined HAVE_LOCALE_H || defined _LIBC
# include <locale.h>
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */
# include <wchar.h>
# include <wctype.h>
-libc_hidden_proto(wcslen)
-libc_hidden_proto(mbrtowc)
-libc_hidden_proto(wcrtomb)
-libc_hidden_proto(wcscoll)
-libc_hidden_proto(wctype)
-libc_hidden_proto(iswctype)
-libc_hidden_proto(iswalnum)
-libc_hidden_proto(btowc)
+/* libc_hidden_proto(wcslen) */
+/* libc_hidden_proto(mbrtowc) */
+/* libc_hidden_proto(wcrtomb) */
+/* libc_hidden_proto(wcscoll) */
+/* libc_hidden_proto(wctype) */
+/* libc_hidden_proto(iswctype) */
+/* libc_hidden_proto(iswalnum) */
+/* libc_hidden_proto(btowc) */
# endif
indexing as explained in the comment for the hsearch function.
The contents of the table is zeroed, especially the field used
becomes zero. */
-libc_hidden_proto(hcreate_r)
+/* libc_hidden_proto(hcreate_r) */
int hcreate_r (size_t nel, struct hsearch_data *htab)
{
/* Test for correct arguments. */
#ifdef L_hdestroy_r
/* After using the hash table it has to be destroyed. The used memory can
be freed and the local static variable can be marked as not used. */
-libc_hidden_proto(hdestroy_r)
+/* libc_hidden_proto(hdestroy_r) */
void hdestroy_r (struct hsearch_data *htab)
{
/* Test for correct arguments. */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(hsearch_r)
+/* libc_hidden_proto(hsearch_r) */
int hsearch_r (ENTRY item, ACTION action, ENTRY **retval,
struct hsearch_data *htab)
{
#include <stdio.h>
#include <search.h>
-libc_hidden_proto(lfind)
+/* libc_hidden_proto(lfind) */
#ifdef L_lfind
int (*compar)(); ordering function
*/
-libc_hidden_proto(tsearch)
+/* libc_hidden_proto(tsearch) */
void *tsearch(__const void *key, void **vrootp, __compar_fn_t compar)
{
register node *q;
#endif
#ifdef L_tfind
-libc_hidden_proto(tfind)
+/* libc_hidden_proto(tfind) */
void *tfind(__const void *key, void * __const *vrootp, __compar_fn_t compar)
{
register node **rootp = (node **) vrootp;
free (root);
}
-libc_hidden_proto(tdestroy)
+/* libc_hidden_proto(tdestroy) */
void tdestroy (void *vroot, __free_fn_t freefct)
{
node *root = (node *) vroot;
#include <search.h>
-libc_hidden_proto(hdestroy_r)
-libc_hidden_proto(hsearch_r)
-libc_hidden_proto(hcreate_r)
+/* libc_hidden_proto(hdestroy_r) */
+/* libc_hidden_proto(hsearch_r) */
+/* libc_hidden_proto(hcreate_r) */
/* The non-reentrant version use a global space for storing the table. */
static struct hsearch_data htab;
libc_hidden_proto(__libc_fstatfs)
/* Return information about the filesystem on which FD resides. */
-libc_hidden_proto(fstatfs64)
+/* libc_hidden_proto(fstatfs64) */
int fstatfs64 (int fd, struct statfs64 *buf)
{
struct statfs buf32;
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strsep) */
-libc_hidden_proto(setmntent)
-libc_hidden_proto(getmntent_r)
-libc_hidden_proto(endmntent)
+/* libc_hidden_proto(setmntent) */
+/* libc_hidden_proto(getmntent_r) */
+/* libc_hidden_proto(endmntent) */
/* libc_hidden_proto(stat) */
#ifndef __USE_FILE_OFFSET64
libc_hidden_proto(__libc_fstatfs)
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(stat) */
-libc_hidden_proto(fstatvfs)
+/* libc_hidden_proto(fstatvfs) */
int fstatvfs (int fd, struct statvfs *buf)
{
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strsep) */
-libc_hidden_proto(setmntent)
-libc_hidden_proto(getmntent_r)
-libc_hidden_proto(endmntent)
+/* libc_hidden_proto(setmntent) */
+/* libc_hidden_proto(getmntent_r) */
+/* libc_hidden_proto(endmntent) */
#undef stat
#define stat stat64
#if !defined __UCLIBC_LINUX_SPECIFIC__
-libc_hidden_proto(fstatvfs)
+/* libc_hidden_proto(fstatvfs) */
#else
-libc_hidden_proto(fstatfs64)
+/* libc_hidden_proto(fstatfs64) */
#endif
-libc_hidden_proto(fstat64)
+/* libc_hidden_proto(fstat64) */
/* libc_hidden_proto(stat) */
int fstatvfs64 (int fd, struct statvfs64 *buf)
libc_hidden_proto(__libc_statfs)
/* Return information about the filesystem on which FILE resides. */
-libc_hidden_proto(statfs64)
+/* libc_hidden_proto(statfs64) */
int statfs64 (const char *file, struct statfs64 *buf)
{
struct statfs buf32;
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strsep) */
-libc_hidden_proto(setmntent)
-libc_hidden_proto(getmntent_r)
-libc_hidden_proto(endmntent)
+/* libc_hidden_proto(setmntent) */
+/* libc_hidden_proto(getmntent_r) */
+/* libc_hidden_proto(endmntent) */
extern __typeof(statfs) __libc_statfs;
libc_hidden_proto(__libc_statfs)
/* libc_hidden_proto(stat) */
-libc_hidden_proto(statvfs)
+/* libc_hidden_proto(statvfs) */
int statvfs (const char *file, struct statvfs *buf)
{
struct statfs fsbuf;
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strsep) */
-libc_hidden_proto(setmntent)
-libc_hidden_proto(getmntent_r)
-libc_hidden_proto(endmntent)
+/* libc_hidden_proto(setmntent) */
+/* libc_hidden_proto(getmntent_r) */
+/* libc_hidden_proto(endmntent) */
#undef stat
#define stat stat64
#if defined __UCLIBC_LINUX_SPECIFIC__
-libc_hidden_proto(statfs64)
+/* libc_hidden_proto(statfs64) */
#else
-libc_hidden_proto(statvfs)
+/* libc_hidden_proto(statvfs) */
#endif
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(stat64) */
int statvfs64 (const char *file, struct statvfs64 *buf)
{
#include <ctype.h>
#include <signal.h>
-libc_hidden_proto(openlog)
-libc_hidden_proto(syslog)
-libc_hidden_proto(vsyslog)
-libc_hidden_proto(closelog)
+/* libc_hidden_proto(openlog) */
+/* libc_hidden_proto(syslog) */
+/* libc_hidden_proto(vsyslog) */
+/* libc_hidden_proto(closelog) */
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* libc_hidden_proto(close) */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(getpid) */
-libc_hidden_proto(ctime)
+/* libc_hidden_proto(ctime) */
/* libc_hidden_proto(sigaction) */
-libc_hidden_proto(sigemptyset)
-libc_hidden_proto(connect)
+/* libc_hidden_proto(sigemptyset) */
+/* libc_hidden_proto(connect) */
/* libc_hidden_proto(sprintf) */
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
/* Experimentally off - libc_hidden_proto(time) */
#include <bits/uClibc_mutex.h>
#else
/* psm: don't remove this, else mips will fail */
#include <unistd.h>
-libc_hidden_proto(getpagesize)
+/* libc_hidden_proto(getpagesize) */
void * shmat (int shmid, const void *shmaddr, int shmflg)
{
#include <sys/timex.h>
#include <errno.h>
-libc_hidden_proto(adjtimex)
+/* libc_hidden_proto(adjtimex) */
#define MAX_SEC (LONG_MAX / 1000000L - 2)
#define MIN_SEC (LONG_MIN / 1000000L + 2)
#include <xlocale.h>
#endif
-libc_hidden_proto(asctime)
-libc_hidden_proto(asctime_r)
-libc_hidden_proto(ctime)
-libc_hidden_proto(localtime)
-libc_hidden_proto(localtime_r)
+/* libc_hidden_proto(asctime) */
+/* libc_hidden_proto(asctime_r) */
+/* libc_hidden_proto(ctime) */
+/* libc_hidden_proto(localtime) */
+/* libc_hidden_proto(localtime_r) */
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* libc_hidden_proto(read) */
/* libc_hidden_proto(close) */
/* libc_hidden_proto(getenv) */
-libc_hidden_proto(tzset)
+/* libc_hidden_proto(tzset) */
/* libc_hidden_proto(gettimeofday) */
/* Experimentally off - libc_hidden_proto(strncasecmp) */
-libc_hidden_proto(strtol)
-libc_hidden_proto(strtoul)
-libc_hidden_proto(nl_langinfo)
+/* libc_hidden_proto(strtol) */
+/* libc_hidden_proto(strtoul) */
+/* libc_hidden_proto(nl_langinfo) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* Experimentally off - libc_hidden_proto(strncasecmp_l) */
-libc_hidden_proto(strtol_l)
-libc_hidden_proto(strtoul_l)
-libc_hidden_proto(nl_langinfo_l)
+/* libc_hidden_proto(strtol_l) */
+/* libc_hidden_proto(strtoul_l) */
+/* libc_hidden_proto(nl_langinfo_l) */
/* libc_hidden_proto(__ctype_b_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(__ctype_b) */
#include <sys/times.h>
-libc_hidden_proto(times)
+/* libc_hidden_proto(times) */
#ifndef __BCC__
#if CLOCKS_PER_SEC != 1000000L
#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-libc_hidden_proto(strftime)
+/* libc_hidden_proto(strftime) */
-libc_hidden_proto(strftime_l)
+/* libc_hidden_proto(strftime_l) */
size_t strftime(char *__restrict s, size_t maxsize,
const char *__restrict format,
#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-libc_hidden_proto(strptime)
+/* libc_hidden_proto(strptime) */
-libc_hidden_proto(strptime_l)
+/* libc_hidden_proto(strptime_l) */
char *strptime(const char *__restrict buf, const char *__restrict format,
struct tm *__restrict tm)
#endif /* __UCLIBC_HAS_TZ_FILE__ */
#ifndef __UCLIBC_HAS_CTYPE_TABLES__
-libc_hidden_proto(isascii)
+/* libc_hidden_proto(isascii) */
#endif
void tzset(void)
#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-libc_hidden_proto(wcsftime)
+/* libc_hidden_proto(wcsftime) */
-libc_hidden_proto(wcsftime_l)
+/* libc_hidden_proto(wcsftime_l) */
size_t wcsftime(wchar_t *__restrict s, size_t maxsize,
const wchar_t *__restrict format,
/* Experimentally off - libc_hidden_proto(strchr) */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strncmp) */
-libc_hidden_proto(__fsetlocking)
-libc_hidden_proto(rewind)
-libc_hidden_proto(fgets_unlocked)
-libc_hidden_proto(getc_unlocked)
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(__fsetlocking) */
+/* libc_hidden_proto(rewind) */
+/* libc_hidden_proto(fgets_unlocked) */
+/* libc_hidden_proto(getc_unlocked) */
+/* libc_hidden_proto(__fgetc_unlocked) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(abort) */
return ((p = strchr(p, '=')) ? ++p : NULL);
}
-libc_hidden_proto(setttyent)
+/* libc_hidden_proto(setttyent) */
int setttyent(void)
{
}
libc_hidden_def(setttyent)
-libc_hidden_proto(getttyent)
+/* libc_hidden_proto(getttyent) */
struct ttyent * getttyent(void)
{
register int c;
}
libc_hidden_def(getttyent)
-libc_hidden_proto(endttyent)
+/* libc_hidden_proto(endttyent) */
int endttyent(void)
{
int rval;
return;
}
-libc_hidden_proto(setutent)
+/* libc_hidden_proto(setutent) */
void setutent(void)
{
__UCLIBC_MUTEX_LOCK(utmplock);
return NULL;
}
-libc_hidden_proto(getutid)
+/* libc_hidden_proto(getutid) */
struct utmp *getutid(const struct utmp *utmp_entry)
{
struct utmp *ret = NULL;
#if 0
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strncpy) */
-libc_hidden_proto(updwtmp)
+/* libc_hidden_proto(updwtmp) */
#endif
/* libc_hidden_proto(open) */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(lockf)
+/* libc_hidden_proto(lockf) */
/* libc_hidden_proto(gettimeofday) */
#if 0
/**********************************************************************/
#ifdef L_btowc
-libc_hidden_proto(mbrtowc)
+/* libc_hidden_proto(mbrtowc) */
-libc_hidden_proto(btowc)
+/* libc_hidden_proto(btowc) */
wint_t btowc(int c)
{
#ifdef __CTYPE_HAS_8_BIT_LOCALES
/* Note: We completely ignore ps in all currently supported conversions. */
-libc_hidden_proto(wcrtomb)
+/* libc_hidden_proto(wcrtomb) */
int wctob(wint_t c)
{
/**********************************************************************/
#ifdef L_mbsinit
-libc_hidden_proto(mbsinit)
+/* libc_hidden_proto(mbsinit) */
int mbsinit(const mbstate_t *ps)
{
return !ps || !ps->__mask;
/**********************************************************************/
#ifdef L_mbrlen
-libc_hidden_proto(mbrtowc)
+/* libc_hidden_proto(mbrtowc) */
-libc_hidden_proto(mbrlen)
+/* libc_hidden_proto(mbrlen) */
size_t mbrlen(const char *__restrict s, size_t n, mbstate_t *__restrict ps)
{
static mbstate_t mbstate; /* Rely on bss 0-init. */
/**********************************************************************/
#ifdef L_mbrtowc
-libc_hidden_proto(mbsnrtowcs)
+/* libc_hidden_proto(mbsnrtowcs) */
-libc_hidden_proto(mbrtowc)
+/* libc_hidden_proto(mbrtowc) */
size_t mbrtowc(wchar_t *__restrict pwc, const char *__restrict s,
size_t n, mbstate_t *__restrict ps)
{
/**********************************************************************/
#ifdef L_wcrtomb
-libc_hidden_proto(wcsnrtombs)
+/* libc_hidden_proto(wcsnrtombs) */
/* Note: We completely ignore ps in all currently supported conversions. */
/* TODO: Check for valid state anyway? */
-libc_hidden_proto(wcrtomb)
+/* libc_hidden_proto(wcrtomb) */
size_t wcrtomb(register char *__restrict s, wchar_t wc,
mbstate_t *__restrict ps)
{
/**********************************************************************/
#ifdef L_mbsrtowcs
-libc_hidden_proto(mbsnrtowcs)
+/* libc_hidden_proto(mbsnrtowcs) */
-libc_hidden_proto(mbsrtowcs)
+/* libc_hidden_proto(mbsrtowcs) */
size_t mbsrtowcs(wchar_t *__restrict dst, const char **__restrict src,
size_t len, mbstate_t *__restrict ps)
{
* TODO: Check for valid state anyway? */
-libc_hidden_proto(wcsnrtombs)
+/* libc_hidden_proto(wcsnrtombs) */
-libc_hidden_proto(wcsrtombs)
+/* libc_hidden_proto(wcsrtombs) */
size_t wcsrtombs(char *__restrict dst, const wchar_t **__restrict src,
size_t len, mbstate_t *__restrict ps)
{
/* WARNING: We treat len as SIZE_MAX when dst is NULL! */
-libc_hidden_proto(mbsnrtowcs)
+/* libc_hidden_proto(mbsnrtowcs) */
size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
size_t NMC, size_t len, mbstate_t *__restrict ps)
{
/* Note: We completely ignore ps in all currently supported conversions.
* TODO: Check for valid state anyway? */
-libc_hidden_proto(wcsnrtombs)
+/* libc_hidden_proto(wcsnrtombs) */
size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
size_t NWC, size_t len, mbstate_t *__restrict ps)
{
/**********************************************************************/
#ifdef L_wcswidth
-libc_hidden_proto(wcswidth)
+/* libc_hidden_proto(wcswidth) */
#ifdef __UCLIBC_MJN3_ONLY__
#warning REMINDER: If we start doing translit, wcwidth and wcswidth will need updating.
0, 2, 1, 2, 1, 0, 1,
};
-libc_hidden_proto(wcsnrtombs)
+/* libc_hidden_proto(wcsnrtombs) */
int wcswidth(const wchar_t *pwcs, size_t n)
{
/**********************************************************************/
#ifdef L_wcwidth
-libc_hidden_proto(wcswidth)
+/* libc_hidden_proto(wcswidth) */
int wcwidth(wchar_t wc)
{
*
*/
+//vda:TODO: make hidden
+
extern const unsigned char __iconv_codesets[];
-libc_hidden_proto(__iconv_codesets)
+/* libc_hidden_proto(__iconv_codesets) */
const unsigned char __iconv_codesets[] =
"\x0a\xe0""WCHAR_T\x00" /* superset of UCS-4 but platform-endian */
#if __BYTE_ORDER == __BIG_ENDIAN
/* Experimentally off - libc_hidden_proto(strcmp) */
/* libc_hidden_proto(tolower) */
/* libc_hidden_proto(toupper) */
-libc_hidden_proto(towlower)
-libc_hidden_proto(towupper)
-libc_hidden_proto(towctrans)
-libc_hidden_proto(iswctype)
+/* libc_hidden_proto(towlower) */
+/* libc_hidden_proto(towupper) */
+/* libc_hidden_proto(towctrans) */
+/* libc_hidden_proto(iswctype) */
#if defined(__LOCALE_C_ONLY) && defined(__UCLIBC_DO_XLOCALE)
#error xlocale functionality is not supported in stub locale mode.
#ifdef __UCLIBC_HAS_XLOCALE__
#include <xlocale.h>
-libc_hidden_proto(towlower_l)
-libc_hidden_proto(towupper_l)
-libc_hidden_proto(towctrans_l)
-libc_hidden_proto(iswctype_l)
+/* libc_hidden_proto(towlower_l) */
+/* libc_hidden_proto(towupper_l) */
+/* libc_hidden_proto(towctrans_l) */
+/* libc_hidden_proto(iswctype_l) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(__ctype_b) */
#endif /* __UCLIBC_HAS_XLOCALE__ */
static const unsigned char typestring[] = __CTYPE_TYPESTRING;
/* extern const unsigned char typestring[]; */
-libc_hidden_proto(wctype)
+/* libc_hidden_proto(wctype) */
wctype_t wctype(const char *property)
{
const unsigned char *p;
#warning REMINDER: Currently wctype_l simply calls wctype.
#endif /* __UCLIBC_MJN3_ONLY__ */
-libc_hidden_proto(wctype)
+/* libc_hidden_proto(wctype) */
-libc_hidden_proto(wctype_l)
+/* libc_hidden_proto(wctype_l) */
wctype_t wctype_l (const char *property, __locale_t locale)
{
return wctype(property);
static const char transstring[] = __CTYPE_TRANSTRING;
-libc_hidden_proto(wctrans)
+/* libc_hidden_proto(wctrans) */
wctrans_t wctrans(const char *property)
{
const unsigned char *p;
#warning REMINDER: Currently wctrans_l simply calls wctrans.
#endif /* __UCLIBC_MJN3_ONLY__ */
-libc_hidden_proto(wctrans)
+/* libc_hidden_proto(wctrans) */
wctrans_t wctrans_l(const char *property, __locale_t locale)
{
/* Experimentally off - libc_hidden_proto(strndup) */
/* Experimentally off - libc_hidden_proto(strspn) */
/* Experimentally off - libc_hidden_proto(strcspn) */
-libc_hidden_proto(setenv)
-libc_hidden_proto(unsetenv)
-libc_hidden_proto(waitpid)
-libc_hidden_proto(kill)
-libc_hidden_proto(getuid)
-libc_hidden_proto(getpwnam_r)
-libc_hidden_proto(getpwuid_r)
-libc_hidden_proto(execve)
-libc_hidden_proto(dup2)
-libc_hidden_proto(atoi)
-libc_hidden_proto(fnmatch)
-libc_hidden_proto(pipe)
-libc_hidden_proto(fork)
+/* libc_hidden_proto(setenv) */
+/* libc_hidden_proto(unsetenv) */
+/* libc_hidden_proto(waitpid) */
+/* libc_hidden_proto(kill) */
+/* libc_hidden_proto(getuid) */
+/* libc_hidden_proto(getpwnam_r) */
+/* libc_hidden_proto(getpwuid_r) */
+/* libc_hidden_proto(execve) */
+/* libc_hidden_proto(dup2) */
+/* libc_hidden_proto(atoi) */
+/* libc_hidden_proto(fnmatch) */
+/* libc_hidden_proto(pipe) */
+/* libc_hidden_proto(fork) */
/* libc_hidden_proto(open) */
/* libc_hidden_proto(close) */
/* libc_hidden_proto(read) */
/* libc_hidden_proto(sprintf) */
/* libc_hidden_proto(fprintf) */
/* libc_hidden_proto(abort) */
-libc_hidden_proto(glob)
-libc_hidden_proto(globfree)
-libc_hidden_proto(wordfree)
+/* libc_hidden_proto(glob) */
+/* libc_hidden_proto(globfree) */
+/* libc_hidden_proto(wordfree) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
/* libc_hidden_proto(open) */
/* libc_hidden_proto(fcntl) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(sigfillset)
+/* libc_hidden_proto(sigfillset) */
/* libc_hidden_proto(sigaction) */
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(sigaddset)
-libc_hidden_proto(sigemptyset)
-libc_hidden_proto(alarm)
+/* libc_hidden_proto(sigaddset) */
+/* libc_hidden_proto(sigemptyset) */
+/* libc_hidden_proto(alarm) */
/* How long to wait for getting the lock before returning with an
error. */
/* Experimentally off - libc_hidden_proto(strcmp) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(strtoul)
-libc_hidden_proto(rewind)
-libc_hidden_proto(fgets_unlocked)
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(strtoul) */
+/* libc_hidden_proto(rewind) */
+/* libc_hidden_proto(fgets_unlocked) */
+/* libc_hidden_proto(__fputc_unlocked) */
/* libc_hidden_proto(sprintf) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
#ifdef L_fgetpwent_r
#ifdef __USE_SVID
-libc_hidden_proto(fgetpwent_r)
+/* libc_hidden_proto(fgetpwent_r) */
int fgetpwent_r(FILE *__restrict stream, struct passwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct passwd **__restrict result)
#ifdef L_fgetgrent_r
#ifdef __USE_SVID
-libc_hidden_proto(fgetgrent_r)
+/* libc_hidden_proto(fgetgrent_r) */
int fgetgrent_r(FILE *__restrict stream, struct group *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct group **__restrict result)
/**********************************************************************/
#ifdef L_fgetspent_r
-libc_hidden_proto(fgetspent_r)
+/* libc_hidden_proto(fgetspent_r) */
int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct spwd **__restrict result)
#ifdef L_fgetpwent
#ifdef __USE_SVID
-libc_hidden_proto(fgetpwent_r)
+/* libc_hidden_proto(fgetpwent_r) */
struct passwd *fgetpwent(FILE *stream)
{
#ifdef L_fgetgrent
#ifdef __USE_SVID
-libc_hidden_proto(fgetgrent_r)
+/* libc_hidden_proto(fgetgrent_r) */
struct group *fgetgrent(FILE *stream)
{
/**********************************************************************/
#ifdef L_fgetspent
-libc_hidden_proto(fgetspent_r)
+/* libc_hidden_proto(fgetspent_r) */
struct spwd *fgetspent(FILE *stream)
{
/**********************************************************************/
#ifdef L_sgetspent_r
-libc_hidden_proto(sgetspent_r)
+/* libc_hidden_proto(sgetspent_r) */
int sgetspent_r(const char *string, struct spwd *result_buf,
char *buffer, size_t buflen, struct spwd **result)
{
/**********************************************************************/
#ifdef L_getpwuid
-libc_hidden_proto(getpwuid_r)
+/* libc_hidden_proto(getpwuid_r) */
struct passwd *getpwuid(uid_t uid)
{
/**********************************************************************/
#ifdef L_getgrgid
-libc_hidden_proto(getgrgid_r)
+/* libc_hidden_proto(getgrgid_r) */
struct group *getgrgid(gid_t gid)
{
* to have been created as a reentrant version of the non-standard
* functions getspuid. Why getspuid was added, I do not know. */
-libc_hidden_proto(getpwuid_r)
-libc_hidden_proto(getspnam_r)
+/* libc_hidden_proto(getpwuid_r) */
+/* libc_hidden_proto(getspnam_r) */
int getspuid_r(uid_t uid, struct spwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
/* This function is non-standard and is currently not built.
* Why it was added, I do not know. */
-libc_hidden_proto(getspuid_r)
-
struct spwd *getspuid(uid_t uid)
{
static char buffer[__UCLIBC_PWD_BUFFER_SIZE__];
/**********************************************************************/
#ifdef L_getpwnam
-libc_hidden_proto(getpwnam_r)
+/* libc_hidden_proto(getpwnam_r) */
struct passwd *getpwnam(const char *name)
{
/**********************************************************************/
#ifdef L_getgrnam
-libc_hidden_proto(getgrnam_r)
+/* libc_hidden_proto(getgrnam_r) */
struct group *getgrnam(const char *name)
{
/**********************************************************************/
#ifdef L_getspnam
-libc_hidden_proto(getspnam_r)
+/* libc_hidden_proto(getspnam_r) */
struct spwd *getspnam(const char *name)
{
/**********************************************************************/
#ifdef L_getpw
-libc_hidden_proto(getpwuid_r)
+/* libc_hidden_proto(getpwuid_r) */
int getpw(uid_t uid, char *buf)
{
}
-libc_hidden_proto(getpwent_r)
+/* libc_hidden_proto(getpwent_r) */
int getpwent_r(struct passwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct passwd **__restrict result)
__UCLIBC_MUTEX_UNLOCK(mylock);
}
-libc_hidden_proto(getgrent_r)
+/* libc_hidden_proto(getgrent_r) */
int getgrent_r(struct group *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct group **__restrict result)
__UCLIBC_MUTEX_UNLOCK(mylock);
}
-libc_hidden_proto(getspent_r)
+/* libc_hidden_proto(getspent_r) */
int getspent_r(struct spwd *resultbuf, char *buffer,
size_t buflen, struct spwd **result)
{
/**********************************************************************/
#ifdef L_getpwent
-libc_hidden_proto(getpwent_r)
+/* libc_hidden_proto(getpwent_r) */
struct passwd *getpwent(void)
{
/**********************************************************************/
#ifdef L_getgrent
-libc_hidden_proto(getgrent_r)
+/* libc_hidden_proto(getgrent_r) */
struct group *getgrent(void)
{
/**********************************************************************/
#ifdef L_getspent
-libc_hidden_proto(getspent_r)
+/* libc_hidden_proto(getspent_r) */
struct spwd *getspent(void)
{
/**********************************************************************/
#ifdef L_sgetspent
-libc_hidden_proto(sgetspent_r)
+/* libc_hidden_proto(sgetspent_r) */
struct spwd *sgetspent(const char *string)
{
#ifdef L_initgroups
#ifdef __USE_BSD
-libc_hidden_proto(setgroups)
+/* libc_hidden_proto(setgroups) */
int initgroups(const char *user, gid_t gid)
{
#include <errno.h>
#include <signal.h>
-libc_hidden_proto(kill)
+/* libc_hidden_proto(kill) */
/* Send SIG to all processes in process group PGRP.
If PGRP is zero, send SIG to all processes in
/* libc_hidden_proto(getpid) */
-libc_hidden_proto(kill)
+/* libc_hidden_proto(kill) */
int __raise (int signo) attribute_hidden;
int __raise(int signo)
{
return kill(getpid(), signo);
}
-libc_hidden_proto(raise)
+/* libc_hidden_proto(raise) */
weak_alias(__raise,raise)
libc_hidden_def(raise)
#include "sigsetops.h"
/* Add SIGNO to SET. */
-libc_hidden_proto(sigaddset)
+/* libc_hidden_proto(sigaddset) */
int
sigaddset (sigset_t *set, int signo)
{
#include "sigset-cvt-mask.h"
/* Block signals in MASK, returning the old mask. */
-libc_hidden_proto(sigblock)
+/* libc_hidden_proto(sigblock) */
int sigblock (int mask)
{
sigset_t set, oset;
#include "sigsetops.h"
/* Add SIGNO to SET. */
-libc_hidden_proto(sigdelset)
+/* libc_hidden_proto(sigdelset) */
int sigdelset (sigset_t *set, int signo)
{
if (set == NULL || signo <= 0 || signo >= NSIG)
/* Experimentally off - libc_hidden_proto(memset) */
/* Clear all signals from SET. */
-libc_hidden_proto(sigemptyset)
+/* libc_hidden_proto(sigemptyset) */
int sigemptyset (sigset_t *set)
{
if (set == NULL)
/* Experimentally off - libc_hidden_proto(memset) */
/* Set all signals in SET. */
-libc_hidden_proto(sigfillset)
+/* libc_hidden_proto(sigfillset) */
int
sigfillset (sigset_t *set)
{
#define __UCLIBC_HIDE_DEPRECATED__
#include <signal.h>
-libc_hidden_proto(sigblock)
+/* libc_hidden_proto(sigblock) */
int
siggetmask (void)
#include <signal.h>
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(sigaddset)
+/* libc_hidden_proto(sigaddset) */
int sighold (int sig)
{
return oact.sa_handler;
}
strong_alias(__bsd_signal,bsd_signal)
-libc_hidden_proto(signal)
+/* libc_hidden_proto(signal) */
strong_alias(__bsd_signal,signal)
libc_hidden_def(signal)
#include <stddef.h> /* For NULL. */
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(sigdelset)
-libc_hidden_proto(sigsuspend)
+/* libc_hidden_proto(sigdelset) */
+/* libc_hidden_proto(sigsuspend) */
#include "sigset-cvt-mask.h"
/* Set the mask of blocked signals to MASK,
wait for a signal to arrive, and then restore the mask. */
-libc_hidden_proto(__sigpause)
+/* libc_hidden_proto(__sigpause) */
int __sigpause (int sig_or_mask, int is_sig)
{
sigset_t set;
/* We have to provide a default version of this function since the
standards demand it. The version which is a bit more reasonable is
the BSD version. So make this the default. */
-libc_hidden_proto(sigpause)
+/* libc_hidden_proto(sigpause) */
int sigpause (int mask)
{
return __sigpause (mask, 0);
#include <signal.h>
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(sigdelset)
+/* libc_hidden_proto(sigdelset) */
int sigrelse (int sig)
{
#include "sigset-cvt-mask.h"
/* Set the mask of blocked signals to MASK, returning the old mask. */
-libc_hidden_proto(sigsetmask)
+/* libc_hidden_proto(sigsetmask) */
int
sigsetmask (int mask)
{
#include <string.h>
#if defined __UCLIBC_HAS_REALTIME__
-libc_hidden_proto(sigwaitinfo)
+/* libc_hidden_proto(sigwaitinfo) */
int __sigwait (const sigset_t *set, int *sig) attribute_hidden;
int __sigwait (const sigset_t *set, int *sig)
}
#else /* __UCLIBC_HAS_REALTIME__ */
/* variant without REALTIME extensions */
-libc_hidden_proto(sigfillset)
+/* libc_hidden_proto(sigfillset) */
/* libc_hidden_proto(sigaction) */
-libc_hidden_proto(sigsuspend)
+/* libc_hidden_proto(sigsuspend) */
static int was_sig; /* obviously not thread-safe */
static void ignore_signal(int sig)
return was_sig == -1 ? -1 : 0;
}
#endif /* __UCLIBC_HAS_REALTIME__ */
-libc_hidden_proto(sigwait)
+/* libc_hidden_proto(sigwait) */
weak_alias(__sigwait,sigwait)
libc_hidden_def(sigwait)
#include "_stdio.h"
#include <stdio_ext.h>
-libc_hidden_proto(__fsetlocking)
+/* libc_hidden_proto(__fsetlocking) */
/* Not threadsafe. */
/* libc_hidden_proto(write) */
/* libc_hidden_proto(close) */
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
#else
/* libc_hidden_proto(lseek) */
#endif
#include "_stdio.h"
#include <stdio_ext.h>
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
/* Solaris function --
* Flush all line buffered (writing) streams.
#include "_stdio.h"
-libc_hidden_proto(isatty)
+/* libc_hidden_proto(isatty) */
/* libc_hidden_proto(open) */
/* libc_hidden_proto(fcntl) */
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(ungetc)
-libc_hidden_proto(vfscanf)
-libc_hidden_proto(vsscanf)
+/* libc_hidden_proto(ungetc) */
+/* libc_hidden_proto(vfscanf) */
+/* libc_hidden_proto(vsscanf) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(getc_unlocked)
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(getc_unlocked) */
+/* libc_hidden_proto(__fgetc_unlocked) */
#ifdef __UCLIBC_HAS_WCHAR__
-libc_hidden_proto(wcslen)
-libc_hidden_proto(vfwscanf)
-libc_hidden_proto(vswscanf)
-libc_hidden_proto(mbsrtowcs)
-libc_hidden_proto(mbrtowc)
-libc_hidden_proto(wcrtomb)
-libc_hidden_proto(ungetwc)
-libc_hidden_proto(iswspace)
-libc_hidden_proto(fgetwc_unlocked)
+/* libc_hidden_proto(wcslen) */
+/* libc_hidden_proto(vfwscanf) */
+/* libc_hidden_proto(vswscanf) */
+/* libc_hidden_proto(mbsrtowcs) */
+/* libc_hidden_proto(mbrtowc) */
+/* libc_hidden_proto(wcrtomb) */
+/* libc_hidden_proto(ungetwc) */
+/* libc_hidden_proto(iswspace) */
+/* libc_hidden_proto(fgetwc_unlocked) */
#endif
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
/**********************************************************************/
#ifdef L_fscanf
-libc_hidden_proto(fscanf)
+/* libc_hidden_proto(fscanf) */
int fscanf(FILE * __restrict stream, const char * __restrict format, ...)
{
va_list arg;
#ifdef __STDIO_HAS_VSSCANF
-libc_hidden_proto(sscanf)
+/* libc_hidden_proto(sscanf) */
int sscanf(const char * __restrict str, const char * __restrict format, ...)
{
va_list arg;
/**********************************************************************/
#ifdef L_vscanf
-libc_hidden_proto(vscanf)
+/* libc_hidden_proto(vscanf) */
int vscanf(const char * __restrict format, va_list arg)
{
return vfscanf(stdin, format, arg);
#include "_stdio.h"
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(isatty)
+/* libc_hidden_proto(isatty) */
/* This is pretty much straight from uClibc, but with one important
* difference.
#include "_stdio.h"
-libc_hidden_proto(fseek)
+/* libc_hidden_proto(fseek) */
/* Function to handle transition to writing.
* Initialize or verify the stream's orientation (even if readonly).
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strnlen) */
-libc_hidden_proto(__glibc_strerror_r)
-libc_hidden_proto(fputs_unlocked)
+/* libc_hidden_proto(__glibc_strerror_r) */
+/* libc_hidden_proto(fputs_unlocked) */
/* libc_hidden_proto(abort) */
#ifdef __UCLIBC_HAS_WCHAR__
-libc_hidden_proto(wcslen)
-libc_hidden_proto(wcsnlen)
-libc_hidden_proto(mbsrtowcs)
-libc_hidden_proto(wcsrtombs)
-libc_hidden_proto(btowc)
-libc_hidden_proto(wcrtomb)
-libc_hidden_proto(fputws)
+/* libc_hidden_proto(wcslen) */
+/* libc_hidden_proto(wcsnlen) */
+/* libc_hidden_proto(mbsrtowcs) */
+/* libc_hidden_proto(wcsrtombs) */
+/* libc_hidden_proto(btowc) */
+/* libc_hidden_proto(wcrtomb) */
+/* libc_hidden_proto(fputws) */
#endif
/* Some older or broken gcc toolchains define LONG_LONG_MAX but not
#warning TODO: Fix prototype.
#endif
-libc_hidden_proto(wmemcpy)
-libc_hidden_proto(wcsnrtombs)
+/* libc_hidden_proto(wmemcpy) */
+/* libc_hidden_proto(wcsnrtombs) */
size_t attribute_hidden _wstdio_fwrite(const wchar_t *__restrict ws, size_t n,
register FILE *__restrict stream)
#include "_stdio.h"
#include <stdarg.h>
-libc_hidden_proto(asprintf)
+/* libc_hidden_proto(asprintf) */
-libc_hidden_proto(vasprintf)
+/* libc_hidden_proto(vasprintf) */
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping asprintf and __asprintf since no vsnprintf!
#include "_stdio.h"
#include <stdarg.h>
-libc_hidden_proto(vdprintf)
+/* libc_hidden_proto(vdprintf) */
int dprintf(int filedes, const char * __restrict format, ...)
{
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(close) */
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
int fclose(register FILE *stream)
{
#include "_stdio.h"
-libc_hidden_proto(fdopen)
+/* libc_hidden_proto(fdopen) */
/* libc_hidden_proto(fcntl) */
FILE *fdopen(int filedes, const char *mode)
#include "_stdio.h"
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
#ifdef __DO_UNLOCKED
libc_hidden_def(fflush_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fflush)
+/* libc_hidden_proto(fflush) */
strong_alias(fflush_unlocked,fflush)
libc_hidden_def(fflush)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fflush)
+/* libc_hidden_proto(fflush) */
int fflush(register FILE *stream)
{
int retval;
#undef getc
#undef getc_unlocked
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(__fgetc_unlocked) */
#ifdef __DO_UNLOCKED
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
int __fgetc_unlocked(FILE *stream)
{
}
libc_hidden_def(__fgetc_unlocked)
-libc_hidden_proto(fgetc_unlocked)
+/* libc_hidden_proto(fgetc_unlocked) */
strong_alias(__fgetc_unlocked,fgetc_unlocked)
libc_hidden_def(fgetc_unlocked)
//strong_alias(__fgetc_unlocked,__getc_unlocked)
//libc_hidden_def(__getc_unlocked)
-libc_hidden_proto(getc_unlocked)
+/* libc_hidden_proto(getc_unlocked) */
strong_alias(__fgetc_unlocked,getc_unlocked)
libc_hidden_def(getc_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fgetc)
+/* libc_hidden_proto(fgetc) */
strong_alias(__fgetc_unlocked,fgetc)
libc_hidden_def(fgetc)
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fgetc)
+/* libc_hidden_proto(fgetc) */
int fgetc(register FILE *stream)
{
if (stream->__user_locking != 0) {
#include "_stdio.h"
-libc_hidden_proto(fgets_unlocked)
+/* libc_hidden_proto(fgets_unlocked) */
#ifdef __DO_UNLOCKED
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(__fgetc_unlocked) */
char *fgets_unlocked(char *__restrict s, int n,
register FILE * __restrict stream)
#include "_stdio.h"
-libc_hidden_proto(fgetwc_unlocked)
+/* libc_hidden_proto(fgetwc_unlocked) */
-libc_hidden_proto(mbrtowc)
+/* libc_hidden_proto(mbrtowc) */
#ifdef __DO_UNLOCKED
strong_alias(fgetwc_unlocked,getwc_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fgetwc)
+/* libc_hidden_proto(fgetwc) */
strong_alias(fgetwc_unlocked,fgetwc)
libc_hidden_def(fgetwc)
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fgetwc)
+/* libc_hidden_proto(fgetwc) */
wint_t fgetwc(register FILE *stream)
{
wint_t retval;
#include "_stdio.h"
-libc_hidden_proto(fgetws_unlocked)
+/* libc_hidden_proto(fgetws_unlocked) */
-libc_hidden_proto(fgetwc_unlocked)
+/* libc_hidden_proto(fgetwc_unlocked) */
#ifdef __DO_UNLOCKED
#include "_stdio.h"
-libc_hidden_proto(fileno_unlocked)
+/* libc_hidden_proto(fileno_unlocked) */
#ifdef __DO_UNLOCKED
libc_hidden_def(fileno_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fileno)
+/* libc_hidden_proto(fileno) */
strong_alias(fileno_unlocked,fileno)
libc_hidden_def(fileno)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fileno)
+/* libc_hidden_proto(fileno) */
int fileno(register FILE *stream)
{
int retval;
#include "_stdio.h"
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(fopencookie)
+/* libc_hidden_proto(fopencookie) */
#ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
#error no custom streams!
/* Currently no real reentrancy issues other than a possible double close(). */
#ifndef __BCC__
-libc_hidden_proto(fopencookie)
+/* libc_hidden_proto(fopencookie) */
FILE *fopencookie(void * __restrict cookie, const char * __restrict mode,
cookie_io_functions_t io_functions)
#else
#undef putc
#undef putc_unlocked
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(__fputc_unlocked) */
#ifdef __DO_UNLOCKED
/* exposing these would be fundamentally *wrong*! fix you, instead! */
/* libc_hidden_def(fputc_unlocked) */
-libc_hidden_proto(putc_unlocked)
+/* libc_hidden_proto(putc_unlocked) */
strong_alias(__fputc_unlocked,putc_unlocked)
libc_hidden_def(putc_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fputc)
+/* libc_hidden_proto(fputc) */
strong_alias(__fputc_unlocked,fputc)
libc_hidden_def(fputc)
-libc_hidden_proto(putc)
+/* libc_hidden_proto(putc) */
strong_alias(__fputc_unlocked,putc)
libc_hidden_def(putc)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fputc)
+/* libc_hidden_proto(fputc) */
int fputc(int c, register FILE *stream)
{
if (stream->__user_locking != 0) {
}
libc_hidden_def(fputc)
-libc_hidden_proto(putc)
+/* libc_hidden_proto(putc) */
strong_alias(fputc,putc)
libc_hidden_def(putc)
#include "_stdio.h"
-libc_hidden_proto(fputs_unlocked)
+/* libc_hidden_proto(fputs_unlocked) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(fwrite_unlocked)
+/* libc_hidden_proto(fwrite_unlocked) */
/* Note: The standard says fputs returns a nonnegative number on
* success. In this implementation, we return the length of the
#include "_stdio.h"
-libc_hidden_proto(fputwc_unlocked)
+/* libc_hidden_proto(fputwc_unlocked) */
#ifdef __DO_UNLOCKED
#include "_stdio.h"
-libc_hidden_proto(fputws_unlocked)
+/* libc_hidden_proto(fputws_unlocked) */
-libc_hidden_proto(wcslen)
+/* libc_hidden_proto(wcslen) */
#ifdef __DO_UNLOCKED
libc_hidden_def(fputws_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fputws)
+/* libc_hidden_proto(fputws) */
strong_alias(fputws_unlocked,fputws)
libc_hidden_def(fputws)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fputws)
+/* libc_hidden_proto(fputws) */
int fputws(const wchar_t *__restrict ws, register FILE *__restrict stream)
{
int retval;
#include "_stdio.h"
-libc_hidden_proto(fread_unlocked)
+/* libc_hidden_proto(fread_unlocked) */
#ifdef __DO_UNLOCKED
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
size_t fread_unlocked(void * __restrict ptr, size_t size, size_t nmemb,
FILE * __restrict stream)
libc_hidden_def(fread_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fread)
+/* libc_hidden_proto(fread) */
strong_alias(fread_unlocked,fread)
libc_hidden_def(fread)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fread)
+/* libc_hidden_proto(fread) */
size_t fread(void * __restrict ptr, size_t size, size_t nmemb,
register FILE * __restrict stream)
{
#endif
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(fseeko64)
+/* libc_hidden_proto(fseeko64) */
#endif
-libc_hidden_proto(fseek)
+/* libc_hidden_proto(fseek) */
int FSEEK(register FILE *stream, OFFSET_TYPE offset, int whence)
{
#include "_stdio.h"
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(ftello64)
+/* libc_hidden_proto(ftello64) */
#endif
-libc_hidden_proto(ftell)
+/* libc_hidden_proto(ftell) */
#ifndef __DO_LARGEFILE
# define FTELL ftell
#include <stdarg.h>
#include <wchar.h>
-libc_hidden_proto(vfwprintf)
+/* libc_hidden_proto(vfwprintf) */
int fwprintf(FILE * __restrict stream, const wchar_t * __restrict format, ...)
{
#include "_stdio.h"
-libc_hidden_proto(fwrite_unlocked)
+/* libc_hidden_proto(fwrite_unlocked) */
#ifdef __DO_UNLOCKED
libc_hidden_def(fwrite_unlocked)
#ifndef __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fwrite)
+/* libc_hidden_proto(fwrite) */
strong_alias(fwrite_unlocked,fwrite)
libc_hidden_def(fwrite)
#endif
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fwrite)
+/* libc_hidden_proto(fwrite) */
size_t fwrite(const void * __restrict ptr, size_t size,
size_t nmemb, register FILE * __restrict stream)
{
#include "_stdio.h"
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(__fgetc_unlocked) */
#undef getchar
#ifdef __DO_UNLOCKED
/* the only use of the hidden getchar_unlocked is in gets.c */
#undef getchar_unlocked
-libc_hidden_proto(getchar_unlocked)
+/* libc_hidden_proto(getchar_unlocked) */
int getchar_unlocked(void)
{
register FILE *stream = stdin;
#ifdef __USE_GNU
#include "_stdio.h"
-libc_hidden_proto(getdelim)
+/* libc_hidden_proto(getdelim) */
-libc_hidden_proto(__fgetc_unlocked)
+/* libc_hidden_proto(__fgetc_unlocked) */
/* Note: There is a defect in this function. (size_t vs ssize_t). */
#ifdef __USE_GNU
#include "_stdio.h"
-libc_hidden_proto(getline)
+/* libc_hidden_proto(getline) */
-libc_hidden_proto(getdelim)
+/* libc_hidden_proto(getdelim) */
ssize_t getline(char **__restrict lineptr, size_t *__restrict n,
FILE *__restrict stream)
/* disable macro, force actual function call */
#undef getchar_unlocked
-libc_hidden_proto(getchar_unlocked)
+/* libc_hidden_proto(getchar_unlocked) */
char *gets(char *s)
{
#include "_stdio.h"
-libc_hidden_proto(fread_unlocked)
+/* libc_hidden_proto(fread_unlocked) */
/* SUSv2 Legacy function -- need not be reentrant. */
#ifdef __DO_UNLOCKED
-libc_hidden_proto(fgetwc_unlocked)
+/* libc_hidden_proto(fgetwc_unlocked) */
wint_t getwchar_unlocked(void)
{
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(fgetwc)
+/* libc_hidden_proto(fgetwc) */
wint_t getwchar(void)
{
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strnlen) */
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(putc_unlocked)
-libc_hidden_proto(__fputc_unlocked)
-libc_hidden_proto(__glibc_strerror_r)
+/* libc_hidden_proto(putc_unlocked) */
+/* libc_hidden_proto(__fputc_unlocked) */
+/* libc_hidden_proto(__glibc_strerror_r) */
/* #undef __UCLIBC_HAS_FLOATS__ */
/* #undef WANT_FLOAT_ERROR */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(memset) */
-libc_hidden_proto(fopencookie)
+/* libc_hidden_proto(fopencookie) */
#ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
#error no custom streams!
* (ie replace the FILE buffer with the cookie buffer and update FILE bufstart,
* etc. whenever we seek). */
-libc_hidden_proto(open_memstream)
+/* libc_hidden_proto(open_memstream) */
FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc)
{
register __oms_cookie *cookie;
#include "_stdio.h"
/* libc_hidden_proto(fprintf) */
-libc_hidden_proto(__glibc_strerror_r)
+/* libc_hidden_proto(__glibc_strerror_r) */
#ifdef __UCLIBC_MJN3_ONLY__
#warning CONSIDER: Increase buffer size for error message (non-%m case)?
/* libc_hidden_proto(close) */
/* libc_hidden_proto(_exit) */
-libc_hidden_proto(waitpid)
-libc_hidden_proto(execl)
-libc_hidden_proto(dup2)
-libc_hidden_proto(fdopen)
-libc_hidden_proto(pipe)
-libc_hidden_proto(vfork)
+/* libc_hidden_proto(waitpid) */
+/* libc_hidden_proto(execl) */
+/* libc_hidden_proto(dup2) */
+/* libc_hidden_proto(fdopen) */
+/* libc_hidden_proto(pipe) */
+/* libc_hidden_proto(vfork) */
/* libc_hidden_proto(fclose) */
/* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
# define vfork fork
# define VFORK_LOCK ((void) 0)
# define VFORK_UNLOCK ((void) 0)
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
#endif
#ifndef VFORK_LOCK
#include "_stdio.h"
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(__fputc_unlocked) */
#undef putchar
#ifdef __DO_UNLOCKED
#include "_stdio.h"
-libc_hidden_proto(__fputc_unlocked)
-libc_hidden_proto(fputs_unlocked)
+/* libc_hidden_proto(__fputc_unlocked) */
+/* libc_hidden_proto(fputs_unlocked) */
int puts(register const char * __restrict s)
{
#include "_stdio.h"
-libc_hidden_proto(fwrite_unlocked)
+/* libc_hidden_proto(fwrite_unlocked) */
/* SUSv2 Legacy function -- need not be reentrant. */
#ifdef __DO_UNLOCKED
-libc_hidden_proto(fputwc_unlocked)
+/* libc_hidden_proto(fputwc_unlocked) */
wint_t putwchar_unlocked(wchar_t wc)
{
#elif defined __UCLIBC_HAS_THREADS__
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(__fputc_unlocked) */
/* psm: should this be fputwc? */
-libc_hidden_proto(fputc)
+/* libc_hidden_proto(fputc) */
wint_t putwchar(wchar_t wc)
{
#include <unistd.h>
#include <errno.h>
-libc_hidden_proto(rmdir)
-libc_hidden_proto(unlink)
+/* libc_hidden_proto(rmdir) */
+/* libc_hidden_proto(unlink) */
/* SUSv3 states:
* If path does not name a directory, remove(path) shall be equivalent
* equivalent to rmdir(path).
*/
-libc_hidden_proto(remove)
+/* libc_hidden_proto(remove) */
int remove(register const char *filename)
{
int saved_errno = errno;
#include "_stdio.h"
-libc_hidden_proto(fseek)
+/* libc_hidden_proto(fseek) */
-libc_hidden_proto(rewind)
+/* libc_hidden_proto(rewind) */
void rewind(register FILE *stream)
{
__STDIO_AUTO_THREADLOCK_VAR;
#include "_stdio.h"
-libc_hidden_proto(setvbuf)
+/* libc_hidden_proto(setvbuf) */
void setbuf(FILE * __restrict stream, register char * __restrict buf)
{
#ifdef __USE_BSD
-libc_hidden_proto(setvbuf)
+/* libc_hidden_proto(setvbuf) */
/* A BSD function. The implementation matches the linux man page,
* except that we do not bother calling setvbuf if not configured
#ifdef __USE_BSD
-libc_hidden_proto(setvbuf)
+/* libc_hidden_proto(setvbuf) */
/* A BSD function. The implementation matches the linux man page,
* except that we do not bother calling setvbuf if not configured
#error Assumption violated for buffering mode flags
#endif
-libc_hidden_proto(setvbuf)
+/* libc_hidden_proto(setvbuf) */
int setvbuf(register FILE * __restrict stream, register char * __restrict buf,
int mode, size_t size)
{
#warning Skipping snprintf since no vsnprintf!
#else
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
-libc_hidden_proto(snprintf)
+/* libc_hidden_proto(snprintf) */
int snprintf(char *__restrict buf, size_t size,
const char * __restrict format, ...)
{
#warning Skipping sprintf since no vsnprintf!
#else
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
/* libc_hidden_proto(sprintf) */
int sprintf(char *__restrict buf, const char * __restrict format, ...)
#include <stdarg.h>
#include <wchar.h>
-libc_hidden_proto(vswprintf)
+/* libc_hidden_proto(vswprintf) */
#ifndef __STDIO_BUFFERS
#warning Skipping swprintf since no buffering!
#include <unistd.h>
#include "../misc/internals/tempname.h"
-libc_hidden_proto(fdopen)
-libc_hidden_proto(remove)
+/* libc_hidden_proto(fdopen) */
+/* libc_hidden_proto(remove) */
/* libc_hidden_proto(close) */
/* This returns a new stream opened on a temporary file (generated
* (See section 7.19.6.2 of the C9X rationale -- WG14/N897.)
*/
-libc_hidden_proto(ungetc)
+/* libc_hidden_proto(ungetc) */
int ungetc(int c, register FILE *stream)
{
__STDIO_AUTO_THREADLOCK_VAR;
* as reset stream->__ungot_width[1] for use by _stdio_adjpos().
*/
-libc_hidden_proto(ungetwc)
+/* libc_hidden_proto(ungetwc) */
wint_t ungetwc(wint_t c, register FILE *stream)
{
__STDIO_AUTO_THREADLOCK_VAR;
#else
#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
-libc_hidden_proto(open_memstream)
+/* libc_hidden_proto(open_memstream) */
/* libc_hidden_proto(fclose) */
/* libc_hidden_proto(vfprintf) */
#else
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
#endif
-libc_hidden_proto(vasprintf)
+/* libc_hidden_proto(vasprintf) */
int vasprintf(char **__restrict buf, const char * __restrict format,
va_list arg)
{
#ifdef __USE_OLD_VFPRINTF__
/* libc_hidden_proto(vfprintf) */
#endif
-libc_hidden_proto(fflush_unlocked)
+/* libc_hidden_proto(fflush_unlocked) */
-libc_hidden_proto(vdprintf)
+/* libc_hidden_proto(vdprintf) */
int vdprintf(int filedes, const char * __restrict format, va_list arg)
{
FILE f;
#include "_stdio.h"
#include <stdarg.h>
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
#ifdef __USE_OLD_VFPRINTF__
/* libc_hidden_proto(vfprintf) */
#warning Skipping vsprintf since no vsnprintf!
#else
-libc_hidden_proto(vsnprintf)
+/* libc_hidden_proto(vsnprintf) */
int vsprintf(char *__restrict buf, const char * __restrict format,
va_list arg)
#include <stdarg.h>
#include <wchar.h>
-libc_hidden_proto(vswprintf)
+/* libc_hidden_proto(vswprintf) */
/* NB: this file is not used if __USE_OLD_VFPRINTF__ */
#include <stdarg.h>
#include <wchar.h>
-libc_hidden_proto(vfwprintf)
+/* libc_hidden_proto(vfwprintf) */
int vwprintf(const wchar_t * __restrict format, va_list arg)
{
#include <stdarg.h>
#include <wchar.h>
-libc_hidden_proto(vfwprintf)
+/* libc_hidden_proto(vfwprintf) */
int wprintf(const wchar_t * __restrict format, ...)
{
#include <malloc.h>
/* libc_hidden_proto(_exit) */
-libc_hidden_proto(__uc_malloc)
-libc_hidden_proto(__uc_malloc_failed)
+/* libc_hidden_proto(__uc_malloc) */
+/* libc_hidden_proto(__uc_malloc_failed) */
void (*__uc_malloc_failed)(size_t size) = NULL;
/* Seemingly superfluous assigment of NULL above prevents gas error
#include <wchar.h>
#include <wctype.h>
#include <bits/uClibc_uwchar.h>
-libc_hidden_proto(iswspace)
+/* libc_hidden_proto(iswspace) */
#endif
#ifdef __UCLIBC_HAS_XLOCALE__
#include <xlocale.h>
-libc_hidden_proto(iswspace_l)
+/* libc_hidden_proto(iswspace_l) */
#endif /* __UCLIBC_HAS_XLOCALE__ */
/* Handle _STRTOD_HEXADECIMAL_FLOATS via uClibc config now. */
/* Experimentally off - libc_hidden_proto(memset) */
/* libc_hidden_proto(sigaction) */
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(raise)
+/* libc_hidden_proto(raise) */
/* libc_hidden_proto(_exit) */
/* Our last ditch effort to commit suicide */
return val;
}
-libc_hidden_proto(arc4random_stir)
+/* libc_hidden_proto(arc4random_stir) */
void
arc4random_stir(void)
{
#include <stdlib.h>
-libc_hidden_proto(erand48_r)
+/* libc_hidden_proto(erand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
#include <math.h>
#include <stdlib.h>
-libc_hidden_proto(erand48_r)
+/* libc_hidden_proto(erand48_r) */
int drand48_r (struct drand48_data *buffer, double *result)
{
#include <stdlib.h>
-libc_hidden_proto(erand48_r)
+/* libc_hidden_proto(erand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
extern int __drand48_iterate(unsigned short xsubi[3],
struct drand48_data *buffer) attribute_hidden;
-libc_hidden_proto(erand48_r)
+/* libc_hidden_proto(erand48_r) */
int erand48_r (unsigned short int xsubi[3], struct drand48_data *buffer, double *result)
{
union ieee754_double temp;
#include <stdlib.h>
-libc_hidden_proto(jrand48_r)
+/* libc_hidden_proto(jrand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
extern int __drand48_iterate(unsigned short xsubi[3],
struct drand48_data *buffer) attribute_hidden;
-libc_hidden_proto(jrand48_r)
+/* libc_hidden_proto(jrand48_r) */
int jrand48_r (unsigned short int xsubi[3], struct drand48_data *buffer, long int *result)
{
/* Compute next state. */
#include <stdlib.h>
-libc_hidden_proto(nrand48_r)
+/* libc_hidden_proto(nrand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
#include <stdlib.h>
-libc_hidden_proto(nrand48_r)
+/* libc_hidden_proto(nrand48_r) */
-libc_hidden_proto(lrand48_r)
+/* libc_hidden_proto(lrand48_r) */
int lrand48_r (struct drand48_data *buffer, long int *result)
{
/* Be generous for the arguments, detect some errors. */
/* Experimentally off - libc_hidden_proto(memcpy) */
/*libc_hidden_proto(memset)*/
/* libc_hidden_proto(mmap) */
-libc_hidden_proto(munmap)
+/* libc_hidden_proto(munmap) */
#ifdef L_malloc
void *malloc(size_t size)
#include "malloc.h"
-libc_hidden_proto(munmap)
+/* libc_hidden_proto(munmap) */
/* ------------------------- __malloc_trim -------------------------
__malloc_trim is an inverse of sorts to __malloc_alloc. It gives memory
/* libc_hidden_proto(fprintf) */
/* ------------------------------ mallinfo ------------------------------ */
-libc_hidden_proto(mallinfo)
+/* libc_hidden_proto(mallinfo) */
struct mallinfo mallinfo(void)
{
mstate av;
#include <bits/uClibc_mutex.h>
/* libc_hidden_proto(mmap) */
-libc_hidden_proto(sysconf)
+/* libc_hidden_proto(sysconf) */
/* libc_hidden_proto(sbrk) */
/* libc_hidden_proto(abort) */
#include "malloc.h"
-libc_hidden_proto(mremap)
+/* libc_hidden_proto(mremap) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* ------------------------------ realloc ------------------------------ */
#include <unistd.h>
#include <sys/mman.h>
-libc_hidden_proto(munmap)
+/* libc_hidden_proto(munmap) */
/* libc_hidden_proto(sbrk) */
#include "malloc.h"
#include <unistd.h>
#include <stdarg.h>
-libc_hidden_proto(atoi)
+/* libc_hidden_proto(atoi) */
/* libc_hidden_proto(vfprintf) */
-libc_hidden_proto(putc)
+/* libc_hidden_proto(putc) */
/* libc_hidden_proto(getenv) */
#include "malloc.h"
#include <stdlib.h>
-libc_hidden_proto(jrand48_r)
+/* libc_hidden_proto(jrand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
#include <stdlib.h>
-libc_hidden_proto(jrand48_r)
+/* libc_hidden_proto(jrand48_r) */
int mrand48_r (struct drand48_data *buffer, long int *result)
{
#include <stdlib.h>
-libc_hidden_proto(nrand48_r)
+/* libc_hidden_proto(nrand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
extern int __drand48_iterate(unsigned short xsubi[3],
struct drand48_data *buffer) attribute_hidden;
-libc_hidden_proto(nrand48_r)
+/* libc_hidden_proto(nrand48_r) */
int nrand48_r (unsigned short int xsubi[3], struct drand48_data *buffer, long int *result)
{
/* Compute next state. */
/* Experimentally off - libc_hidden_proto(strcat) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(isatty)
+/* libc_hidden_proto(isatty) */
/* libc_hidden_proto(ioctl) */
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(stat) */
/* Store at most BUFLEN characters of the pathname of the slave pseudo
terminal associated with the master FD is open on in BUF.
Return 0 on success, otherwise an error number. */
-libc_hidden_proto(ptsname_r)
+/* libc_hidden_proto(ptsname_r) */
int ptsname_r (int fd, char *buf, size_t buflen)
{
int save_errno = errno;
#include <stdlib.h>
-libc_hidden_proto(random)
+/* libc_hidden_proto(random) */
int rand (void)
{
#include <stddef.h>
#include <stdlib.h>
-libc_hidden_proto(random_r)
-libc_hidden_proto(srandom_r)
-libc_hidden_proto(setstate_r)
-libc_hidden_proto(initstate_r)
+/* libc_hidden_proto(random_r) */
+/* libc_hidden_proto(srandom_r) */
+/* libc_hidden_proto(setstate_r) */
+/* libc_hidden_proto(initstate_r) */
/* POSIX.1c requires that there is mutual exclusion for the `rand' and
`srand' functions to prevent concurrent calls from modifying common
rear pointers can't wrap on the same call by not testing the rear
pointer if the front one has wrapped. Returns a 31-bit random number. */
-libc_hidden_proto(random)
+/* libc_hidden_proto(random) */
long int random (void)
{
int32_t retval;
rear pointers can't wrap on the same call by not testing the rear
pointer if the front one has wrapped. Returns a 31-bit random number. */
-libc_hidden_proto(random_r)
+/* libc_hidden_proto(random_r) */
int random_r(struct random_data *buf, int32_t *result)
{
int32_t *state;
information a given number of times to get rid of any initial dependencies
introduced by the L.C.R.N.G. Note that the initialization of randtbl[]
for default usage relies on values produced by this routine. */
-libc_hidden_proto(srandom_r)
+/* libc_hidden_proto(srandom_r) */
int srandom_r (unsigned int seed, struct random_data *buf)
{
int type;
Note: The first thing we do is save the current state, if any, just like
setstate so that it doesn't matter when initstate is called.
Returns a pointer to the old state. */
-libc_hidden_proto(initstate_r)
+/* libc_hidden_proto(initstate_r) */
int initstate_r (unsigned int seed, char *arg_state, size_t n, struct random_data *buf)
{
int type;
to the order in which things are done, it is OK to call setstate with the
same state as the current state
Returns a pointer to the old state information. */
-libc_hidden_proto(setstate_r)
+/* libc_hidden_proto(setstate_r) */
int setstate_r (char *arg_state, struct random_data *buf)
{
int32_t *new_state = 1 + (int32_t *) arg_state;
/* Experimentally off - libc_hidden_proto(strcat) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(readlink)
-libc_hidden_proto(getcwd)
+/* libc_hidden_proto(readlink) */
+/* libc_hidden_proto(getcwd) */
#ifndef PATH_MAX
#ifdef _POSIX_VERSION
#include <stdlib.h>
-libc_hidden_proto(seed48_r)
+/* libc_hidden_proto(seed48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(seed48_r)
+/* libc_hidden_proto(seed48_r) */
int seed48_r (unsigned short int seed16v[3], struct drand48_data *buffer)
{
/* Save old value at a private place to be used as return value. */
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strncmp) */
/* Experimentally off - libc_hidden_proto(strndup) */
-libc_hidden_proto(unsetenv)
+/* libc_hidden_proto(unsetenv) */
#include <bits/uClibc_mutex.h>
__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
return rv;
}
-libc_hidden_proto(setenv)
+/* libc_hidden_proto(setenv) */
int setenv (const char *name, const char *value, int replace)
{
return __add_to_environ (name, value, NULL, replace);
}
libc_hidden_def(setenv)
-libc_hidden_proto(unsetenv)
+/* libc_hidden_proto(unsetenv) */
int unsetenv (const char *name)
{
size_t len;
#include <stdlib.h>
-libc_hidden_proto(srand48_r)
+/* libc_hidden_proto(srand48_r) */
/* Global state for non-reentrant functions. Defined in drand48-iter.c. */
extern struct drand48_data __libc_drand48_data attribute_hidden;
#include <stdlib.h>
#include <limits.h>
-libc_hidden_proto(srand48_r)
+/* libc_hidden_proto(srand48_r) */
int srand48_r (long int seedval, struct drand48_data *buffer)
{
/* The standards say we only have 32 bits. */
/**********************************************************************/
#ifdef L_atof
-libc_hidden_proto(strtod)
+/* libc_hidden_proto(strtod) */
double atof(const char *nptr)
{
#if INT_MAX < LONG_MAX
-libc_hidden_proto(strtol)
+/* libc_hidden_proto(strtol) */
-libc_hidden_proto(atoi)
+/* libc_hidden_proto(atoi) */
int atoi(const char *nptr)
{
return (int) strtol(nptr, (char **) NULL, 10);
/**********************************************************************/
#ifdef L_atol
-libc_hidden_proto(strtol)
+/* libc_hidden_proto(strtol) */
-libc_hidden_proto(atol)
+/* libc_hidden_proto(atol) */
long atol(const char *nptr)
{
return strtol(nptr, (char **) NULL, 10);
#if defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX)
-libc_hidden_proto(strtoll)
+/* libc_hidden_proto(strtoll) */
long long atoll(const char *nptr)
{
#define Wuchar __uwchar_t
#ifdef __UCLIBC_DO_XLOCALE
#define ISSPACE(C) iswspace_l((C), locale_arg)
-libc_hidden_proto(iswspace_l)
+/* libc_hidden_proto(iswspace_l) */
#else
#define ISSPACE(C) iswspace((C))
-libc_hidden_proto(iswspace)
+/* libc_hidden_proto(iswspace) */
#endif
#else /* defined(L__stdlib_wcsto_l) || defined(L__stdlib_wcsto_l_l) */
#define Wuchar unsigned char
#ifdef __UCLIBC_DO_XLOCALE
#define ISSPACE(C) isspace_l((C), locale_arg)
-libc_hidden_proto(isspace_l)
+/* libc_hidden_proto(isspace_l) */
#else
#define ISSPACE(C) isspace((C))
-libc_hidden_proto(isspace)
+/* libc_hidden_proto(isspace) */
#endif
#endif /* defined(L__stdlib_wcsto_l) || defined(L__stdlib_wcsto_l_l) */
#define Wuchar __uwchar_t
#ifdef __UCLIBC_DO_XLOCALE
#define ISSPACE(C) iswspace_l((C), locale_arg)
-libc_hidden_proto(iswspace_l)
+/* libc_hidden_proto(iswspace_l) */
#else
#define ISSPACE(C) iswspace((C))
-libc_hidden_proto(iswspace)
+/* libc_hidden_proto(iswspace) */
#endif
#else /* defined(L__stdlib_wcsto_ll) || defined(L__stdlib_wcsto_ll_l) */
#define Wuchar unsigned char
#ifdef __UCLIBC_DO_XLOCALE
#define ISSPACE(C) isspace_l((C), locale_arg)
-libc_hidden_proto(isspace_l)
+/* libc_hidden_proto(isspace_l) */
#else
#define ISSPACE(C) isspace((C))
-libc_hidden_proto(isspace)
+/* libc_hidden_proto(isspace) */
#endif
#endif /* defined(L__stdlib_wcsto_ll) || defined(L__stdlib_wcsto_ll_l) */
* calculation, as well as to reduce the generated code size with
* bcc and gcc. */
-libc_hidden_proto(qsort)
+/* libc_hidden_proto(qsort) */
void qsort(void *base,
size_t nel,
size_t width,
/**********************************************************************/
#ifdef L__stdlib_mb_cur_max
-libc_hidden_proto(_stdlib_mb_cur_max)
+/* libc_hidden_proto(_stdlib_mb_cur_max) */
size_t _stdlib_mb_cur_max(void)
{
#ifdef __CTYPE_HAS_UTF_8_LOCALES
/**********************************************************************/
#ifdef L_mblen
-libc_hidden_proto(mbrlen)
+/* libc_hidden_proto(mbrlen) */
int mblen(register const char *s, size_t n)
{
/**********************************************************************/
#ifdef L_mbtowc
-libc_hidden_proto(mbrtowc)
+/* libc_hidden_proto(mbrtowc) */
int mbtowc(wchar_t *__restrict pwc, register const char *__restrict s, size_t n)
{
/* Note: We completely ignore state in all currently supported conversions. */
-libc_hidden_proto(wcrtomb)
+/* libc_hidden_proto(wcrtomb) */
int wctomb(register char *__restrict s, wchar_t swc)
{
/**********************************************************************/
#ifdef L_mbstowcs
-libc_hidden_proto(mbsrtowcs)
+/* libc_hidden_proto(mbsrtowcs) */
size_t mbstowcs(wchar_t * __restrict pwcs, const char * __restrict s, size_t n)
{
/* Note: We completely ignore state in all currently supported conversions. */
-libc_hidden_proto(wcsrtombs)
+/* libc_hidden_proto(wcsrtombs) */
size_t wcstombs(char * __restrict s, const wchar_t * __restrict pwcs, size_t n)
{
#include <stdlib.h>
/* libc_hidden_proto(_exit) */
-libc_hidden_proto(wait4)
-libc_hidden_proto(execl)
-libc_hidden_proto(signal)
-libc_hidden_proto(vfork)
+/* libc_hidden_proto(wait4) */
+/* libc_hidden_proto(execl) */
+/* libc_hidden_proto(signal) */
+/* libc_hidden_proto(vfork) */
/* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
#include <sys/syscall.h>
#ifndef __NR_vfork
# define vfork fork
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
#endif
extern __typeof(system) __libc_system;
#include "pty-private.h"
/* Experimentally off - libc_hidden_proto(memchr) */
-libc_hidden_proto(getgid)
-libc_hidden_proto(getuid)
-libc_hidden_proto(setrlimit)
-libc_hidden_proto(waitpid)
-libc_hidden_proto(dup2)
-libc_hidden_proto(chmod)
-libc_hidden_proto(chown)
-libc_hidden_proto(vfork)
-libc_hidden_proto(fork)
+/* libc_hidden_proto(getgid) */
+/* libc_hidden_proto(getuid) */
+/* libc_hidden_proto(setrlimit) */
+/* libc_hidden_proto(waitpid) */
+/* libc_hidden_proto(dup2) */
+/* libc_hidden_proto(chmod) */
+/* libc_hidden_proto(chown) */
+/* libc_hidden_proto(vfork) */
+/* libc_hidden_proto(fork) */
/* libc_hidden_proto(stat) */
-libc_hidden_proto(ptsname_r)
-libc_hidden_proto(execle)
+/* libc_hidden_proto(ptsname_r) */
+/* libc_hidden_proto(execle) */
/* libc_hidden_proto(_exit) */
/* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
#include <unistd.h>
#include <malloc.h>
-libc_hidden_proto(getpagesize)
+/* libc_hidden_proto(getpagesize) */
static size_t pagesize;
#include <features.h>
#include <string.h>
-libc_hidden_proto(__glibc_strerror_r)
-libc_hidden_proto(__xpg_strerror_r)
+/* libc_hidden_proto(__glibc_strerror_r) */
+/* libc_hidden_proto(__xpg_strerror_r) */
char *__glibc_strerror_r(int errnum, char *strerrbuf, size_t buflen)
{
#undef strerror_r
-libc_hidden_proto(__xpg_strerror_r)
+/* libc_hidden_proto(__xpg_strerror_r) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strlcpy) */
/* Experimentally off - libc_hidden_proto(strcmp) */
#ifdef WANT_WIDE
-libc_hidden_proto(wcsxfrm)
-libc_hidden_proto(wcscmp)
+/* libc_hidden_proto(wcsxfrm) */
+/* libc_hidden_proto(wcscmp) */
#endif
#ifdef __UCLIBC_HAS_LOCALE__
#if defined(__UCLIBC_HAS_XLOCALE__) && !defined(__UCLIBC_DO_XLOCALE)
-libc_hidden_proto(wcscoll_l)
+/* libc_hidden_proto(wcscoll_l) */
-libc_hidden_proto(wcscoll)
+/* libc_hidden_proto(wcscoll) */
int wcscoll (const Wchar *s0, const Wchar *s1)
{
return wcscoll_l(s0, s1, __UCLIBC_CURLOCALE );
}
libc_hidden_def(wcscoll)
-libc_hidden_proto(wcsxfrm_l)
+/* libc_hidden_proto(wcsxfrm_l) */
-libc_hidden_proto(wcsxfrm)
+/* libc_hidden_proto(wcsxfrm) */
size_t wcsxfrm(Wchar *__restrict ws1, const Wchar *__restrict ws2, size_t n)
{
return wcsxfrm_l(ws1, ws2, n, __UCLIBC_CURLOCALE );
#ifdef WANT_WIDE
# define strcasecmp wcscasecmp
# define strcasecmp_l wcscasecmp_l
-libc_hidden_proto(wcscasecmp)
+/* libc_hidden_proto(wcscasecmp) */
# if defined(__USE_GNU) && defined(__UCLIBC_HAS_XLOCALE__)
-libc_hidden_proto(wcscasecmp_l)
+/* libc_hidden_proto(wcscasecmp_l) */
# endif
# ifdef __UCLIBC_DO_XLOCALE
-libc_hidden_proto(towlower_l)
+/* libc_hidden_proto(towlower_l) */
# define TOLOWER(C) towlower_l((C), locale_arg)
# else
-libc_hidden_proto(towlower)
+/* libc_hidden_proto(towlower) */
# define TOLOWER(C) towlower((C))
# endif
#else
/* Experimentally off - libc_hidden_proto(strcasecmp) */
/* Experimentally off - libc_hidden_proto(strcasecmp_l) */
# ifdef __UCLIBC_DO_XLOCALE
-libc_hidden_proto(tolower_l)
+/* libc_hidden_proto(tolower_l) */
# define TOLOWER(C) tolower_l((C), locale_arg)
# else
#if !defined __UCLIBC_HAS_XLOCALE__ && defined __UCLIBC_HAS_CTYPE_TABLES__
#include <stdlib.h>
#ifdef WANT_WIDE
-libc_hidden_proto(wcslen)
+/* libc_hidden_proto(wcslen) */
# define Wstrdup wcsdup
# define Wstrlen wcslen
#else
#include "_syserrmsg.h"
/* Experimentally off - libc_hidden_proto(strerror) */
-libc_hidden_proto(__xpg_strerror_r)
+/* libc_hidden_proto(__xpg_strerror_r) */
char *strerror(int errnum)
{
#ifdef WANT_WIDE
# define strncasecmp wcsncasecmp
# define strncasecmp_l wcsncasecmp_l
-libc_hidden_proto(wcsncasecmp)
+/* libc_hidden_proto(wcsncasecmp) */
# if defined(__USE_GNU) && defined(__UCLIBC_HAS_XLOCALE__)
-libc_hidden_proto(wcsncasecmp_l)
+/* libc_hidden_proto(wcsncasecmp_l) */
# endif
# ifdef __UCLIBC_DO_XLOCALE
-libc_hidden_proto(towlower_l)
+/* libc_hidden_proto(towlower_l) */
# define TOLOWER(C) towlower_l((C), locale_arg)
# else
-libc_hidden_proto(towlower)
+/* libc_hidden_proto(towlower) */
# define TOLOWER(C) towlower((C))
# endif
#else
/* Experimentally off - libc_hidden_proto(strncasecmp) */
/* Experimentally off - libc_hidden_proto(strncasecmp_l) */
# ifdef __UCLIBC_DO_XLOCALE
-libc_hidden_proto(tolower_l)
+/* libc_hidden_proto(tolower_l) */
# define TOLOWER(C) tolower_l((C), locale_arg)
# else
#if !defined __UCLIBC_HAS_XLOCALE__ && defined __UCLIBC_HAS_CTYPE_TABLES__
#include "_string.h"
#ifdef WANT_WIDE
-libc_hidden_proto(wcsspn)
-libc_hidden_proto(wcspbrk)
+/* libc_hidden_proto(wcsspn) */
+/* libc_hidden_proto(wcspbrk) */
# define Wstrtok_r wcstok
# define Wstrspn wcsspn
# define Wstrpbrk wcspbrk
#include <assert.h>
#include <stdlib.h>
-libc_hidden_proto(__assert)
+/* libc_hidden_proto(__assert) */
void
__aeabi_assert (const char *assertion, const char *file,
#include <locale.h>
-libc_hidden_proto(localeconv)
+/* libc_hidden_proto(localeconv) */
struct lconv *
__aeabi_localeconv (void)
#include <stdlib.h>
#ifdef __UCLIBC_HAS_WCHAR__
-libc_hidden_proto(_stdlib_mb_cur_max)
+/* libc_hidden_proto(_stdlib_mb_cur_max) */
#endif
int
#include <sys/sysctl.h>
#include <sys/io.h>
-libc_hidden_proto(ioperm)
+/* libc_hidden_proto(ioperm) */
-libc_hidden_proto(readlink)
+/* libc_hidden_proto(readlink) */
/* libc_hidden_proto(mmap) */
-libc_hidden_proto(sscanf)
-libc_hidden_proto(fscanf)
+/* libc_hidden_proto(sscanf) */
+/* libc_hidden_proto(fscanf) */
/* libc_hidden_proto(fprintf) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(fopen) */
#include <sys/io.h>
#include <errno.h>
-libc_hidden_proto(ioperm)
+/* libc_hidden_proto(ioperm) */
#define MAX_PORT 0x10000
#define __need_NULL
#include <stddef.h>
-libc_hidden_proto(sigwaitinfo)
-libc_hidden_proto(sigtimedwait)
+/* libc_hidden_proto(sigwaitinfo) */
+/* libc_hidden_proto(sigtimedwait) */
#ifdef __NR_rt_sigtimedwait
#define __NR___rt_sigtimedwait __NR_rt_sigtimedwait
libc_hidden_weak(fcntl)
#if ! defined __NR_fcntl64 && defined __UCLIBC_HAS_LFS__
strong_alias(__libc_fcntl,__libc_fcntl64)
-libc_hidden_proto(fcntl64)
+/* libc_hidden_proto(fcntl64) */
weak_alias(__libc_fcntl,fcntl64)
libc_hidden_weak(fcntl64)
#endif
}
libc_hidden_def(__libc_fcntl64)
-libc_hidden_proto(fcntl64)
+/* libc_hidden_proto(fcntl64) */
strong_alias(__libc_fcntl64,fcntl64)
libc_hidden_weak(fcntl64)
#endif
#include <sys/syscall.h>
#include <sys/timex.h>
-libc_hidden_proto(adjtimex)
+/* libc_hidden_proto(adjtimex) */
_syscall1(int, adjtimex, struct timex *, buf)
libc_hidden_def(adjtimex)
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(alarm)
+/* libc_hidden_proto(alarm) */
#ifdef __NR_alarm
#define __NR___alarm __NR_alarm
#else
#include <sys/time.h>
-libc_hidden_proto(setitimer)
+/* libc_hidden_proto(setitimer) */
unsigned int alarm(unsigned int seconds)
{
# ifndef __ASSEMBLER__
/* Function to get address of global `errno' variable. */
extern int *__errno_location (void) __THROW __attribute__ ((__const__));
+libc_hidden_proto(__errno_location)
# ifdef __UCLIBC_HAS_THREADS__
/* When using threads, errno is a per-thread value. */
errors, only prototype getopt for the GNU C library. */
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
__THROW;
+libc_hidden_proto(getopt)
#else /* not __GNU_LIBRARY__ */
extern int getopt ();
+libc_hidden_proto(getopt)
#endif /* __GNU_LIBRARY__ */
#if defined __UCLIBC_HAS_GNU_GETOPT__ || defined __UCLIBC_HAS_GETOPT_LONG__
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
struct cmsghdr *__cmsg) __THROW;
+libc_hidden_proto(__cmsg_nxthdr)
#ifdef __USE_EXTERN_INLINES
# ifndef _EXTERN_INLINE
# define _EXTERN_INLINE extern __inline
#endif
extern int __fgetc_unlocked(FILE *__stream);
+libc_hidden_proto(__fgetc_unlocked)
extern int __fputc_unlocked(int __c, FILE *__stream);
+libc_hidden_proto(__fputc_unlocked)
/* First define the default definitions.
They are overridden below as necessary. */
#include <unistd.h>
#include <sys/param.h>
-libc_hidden_proto(chdir)
+/* libc_hidden_proto(chdir) */
#define __NR___syscall_chdir __NR_chdir
static __inline__ _syscall1(int, __syscall_chdir, const char *, path)
#include <sys/syscall.h>
#include <sys/stat.h>
-libc_hidden_proto(chmod)
+/* libc_hidden_proto(chmod) */
#define __NR___syscall_chmod __NR_chmod
static __inline__ _syscall2(int, __syscall_chmod, const char *, path, __kernel_mode_t, mode)
#include <unistd.h>
#include <bits/wordsize.h>
-libc_hidden_proto(chown)
+/* libc_hidden_proto(chown) */
#if (__WORDSIZE == 32 && defined(__NR_chown32)) || __WORDSIZE == 64
# ifdef __NR_chown32
#ifdef __NR_clock_getres
_syscall2(int, clock_getres, clockid_t, clock_id, struct timespec*, res)
#else
-libc_hidden_proto(sysconf)
+/* libc_hidden_proto(sysconf) */
int clock_getres(clockid_t clock_id, struct timespec* res)
{
#ifdef __NR_clock_settime
_syscall2(int, clock_settime, clockid_t, clock_id, const struct timespec*, tp)
#else
-libc_hidden_proto(settimeofday)
+/* libc_hidden_proto(settimeofday) */
int clock_settime(clockid_t clock_id, const struct timespec* tp)
{
#include <features.h>
#include <sys/socket.h>
-libc_hidden_proto(__cmsg_nxthdr)
+/* libc_hidden_proto(__cmsg_nxthdr) */
struct cmsghdr *
__cmsg_nxthdr (struct msghdr *mhdr, struct cmsghdr *cmsg)
#include <sys/types.h>
extern __typeof(open64) __libc_open64;
-libc_hidden_proto(__libc_open64)
+/* libc_hidden_proto(__libc_open64) */
extern __typeof(creat64) __libc_creat64;
/* Create FILE with protections MODE. */
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(dup2)
+/* libc_hidden_proto(dup2) */
_syscall2(int, dup2, int, oldfd, int, newfd)
libc_hidden_def(dup2)
#include <string.h>
#include <sys/param.h>
-libc_hidden_proto(execve)
+/* libc_hidden_proto(execve) */
_syscall3(int, execve, const char *, filename,
char *const *, argv, char *const *, envp)
libc_hidden_def(execve)
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(fchdir)
+/* libc_hidden_proto(fchdir) */
_syscall1(int, fchdir, int, fd)
libc_hidden_def(fchdir)
extern __typeof(fork) __libc_fork;
#define __NR___libc_fork __NR_fork
_syscall0(pid_t, __libc_fork)
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
weak_alias(__libc_fork,fork)
libc_hidden_weak(fork)
#endif
__set_errno(ENOSYS);
return -1;
}
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
weak_alias(__libc_fork,fork)
libc_hidden_weak(fork)
link_warning(fork, "fork: this function is not implemented on no-mmu systems")
#if ! defined __NR_fstat64 && defined __UCLIBC_HAS_LFS__
extern __typeof(fstat) fstat64;
-libc_hidden_proto(fstat64)
+/* libc_hidden_proto(fstat64) */
strong_alias(fstat,fstat64)
libc_hidden_def(fstat64)
#endif
#include <sys/stat.h>
#include "xstatconv.h"
-libc_hidden_proto(fstat64)
+/* libc_hidden_proto(fstat64) */
#define __NR___syscall_fstat64 __NR_fstat64
static __inline__ _syscall2(int, __syscall_fstat64,
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(ftruncate)
+/* libc_hidden_proto(ftruncate) */
_syscall2(int, ftruncate, int, fd, __off_t, length)
libc_hidden_def(ftruncate)
# include <sys/types.h>
# include <sys/syscall.h>
-libc_hidden_proto(ftruncate64)
+/* libc_hidden_proto(ftruncate64) */
# ifdef __NR_ftruncate64
# else /* __NR_ftruncate64 */
-libc_hidden_proto(ftruncate)
+/* libc_hidden_proto(ftruncate) */
int ftruncate64 (int fd, __off64_t length)
{
#include <sys/param.h>
#include <sys/syscall.h>
-libc_hidden_proto(getcwd)
-libc_hidden_proto(getpagesize)
+/* libc_hidden_proto(getcwd) */
+/* libc_hidden_proto(getpagesize) */
/* Experimentally off - libc_hidden_proto(strcat) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strncpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(readdir)
-libc_hidden_proto(closedir)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(readdir) */
+/* libc_hidden_proto(closedir) */
/* libc_hidden_proto(stat) */
#ifdef __NR_getcwd
#if defined __UCLIBC_HAS_LFS__ && defined __NR_getdents64
/* Experimentally off - libc_hidden_proto(memcpy) */
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
# ifndef offsetof
# define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#include <string.h>
/* Experimentally off - libc_hidden_proto(strdup) */
-libc_hidden_proto(getcwd)
+/* libc_hidden_proto(getcwd) */
/* libc_hidden_proto(getenv) */
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(stat64) */
#else
/* libc_hidden_proto(stat) */
#endif
#if defined __USE_BSD || (defined __USE_XOPEN && !defined __USE_UNIX98)
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strcpy) */
-libc_hidden_proto(uname)
+/* libc_hidden_proto(uname) */
#if !defined __UCLIBC_BSD_SPECIFIC__
extern int getdomainname (char *__name, size_t __len)
}
libc_hidden_def(__libc_getdomainname)
#if defined __UCLIBC_BSD_SPECIFIC__
-libc_hidden_proto(getdomainname)
+/* libc_hidden_proto(getdomainname) */
weak_alias(__libc_getdomainname,getdomainname)
libc_hidden_weak(getdomainname)
#endif /* __UCLIBC_BSD_SPECIFIC__ */
/* XXX: _BSD || _XOPEN_SOURCE >= 500 */
#if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
-libc_hidden_proto(getdtablesize)
+/* libc_hidden_proto(getdtablesize) */
-libc_hidden_proto(getrlimit)
+/* libc_hidden_proto(getrlimit) */
#define __LOCAL_OPEN_MAX 256
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(getegid)
+/* libc_hidden_proto(getegid) */
#if defined(__NR_getegid32)
# undef __NR_getegid
return (__syscall_getegid());
}
#else
-libc_hidden_proto(getgid)
+/* libc_hidden_proto(getgid) */
gid_t getegid(void)
{
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(geteuid)
+/* libc_hidden_proto(geteuid) */
#if defined(__NR_geteuid32)
# undef __NR_geteuid
}
#else
-libc_hidden_proto(getuid)
+/* libc_hidden_proto(getuid) */
uid_t geteuid(void)
{
return (getuid());
# define __NR_getgid __NR_getgid32
#endif
-libc_hidden_proto(getgid)
+/* libc_hidden_proto(getgid) */
_syscall0(gid_t, getgid)
libc_hidden_def(getgid)
#include <unistd.h>
#include <grp.h>
-libc_hidden_proto(getgroups)
+/* libc_hidden_proto(getgroups) */
#if defined(__NR_getgroups32)
# undef __NR_getgroups
#else
-libc_hidden_proto(sysconf)
+/* libc_hidden_proto(sysconf) */
#define MIN(a,b) (((a)<(b))?(a):(b))
#define __NR___syscall_getgroups __NR_getgroups
#include <sys/utsname.h>
#include <errno.h>
-libc_hidden_proto(gethostname)
+/* libc_hidden_proto(gethostname) */
/* Experimentally off - libc_hidden_proto(strlen) */
/* Experimentally off - libc_hidden_proto(strcpy) */
-libc_hidden_proto(uname)
+/* libc_hidden_proto(uname) */
int
gethostname(char *name, size_t len)
#endif /* NBPG. */
#endif /* EXEC_PAGESIZE. */
}
-libc_hidden_proto(getpagesize)
+/* libc_hidden_proto(getpagesize) */
strong_alias(__getpagesize,getpagesize)
libc_hidden_def(getpagesize)
#include <sys/syscall.h>
#include <sys/resource.h>
-libc_hidden_proto(getpriority)
+/* libc_hidden_proto(getpriority) */
#define __NR___syscall_getpriority __NR_getpriority
static __inline__ _syscall2(int, __syscall_getpriority,
#include <sys/resource.h>
#undef getrlimit64
-libc_hidden_proto(getrlimit)
+/* libc_hidden_proto(getrlimit) */
/* Only wrap getrlimit if the new ugetrlimit is not present and getrlimit sucks */
#if defined __UCLIBC_HAS_LFS__ && __WORDSIZE == 32
-libc_hidden_proto(getrlimit)
+/* libc_hidden_proto(getrlimit) */
/* Put the soft and hard limits for RESOURCE in *RLIMITS.
Returns 0 if successful, -1 if not (and sets errno). */
#include <unistd.h>
#ifdef __USE_XOPEN_EXTENDED
-libc_hidden_proto(getsid)
+/* libc_hidden_proto(getsid) */
#define __NR___syscall_getsid __NR_getsid
static __inline__ _syscall1(__kernel_pid_t, __syscall_getsid, __kernel_pid_t, pid)
# define __NR_getuid __NR_getuid32
#endif
-libc_hidden_proto(getuid)
+/* libc_hidden_proto(getuid) */
_syscall0(uid_t, getuid)
libc_hidden_def(getuid)
#include <sys/syscall.h>
#include <signal.h>
-libc_hidden_proto(kill)
+/* libc_hidden_proto(kill) */
#define __NR___syscall_kill __NR_kill
static __inline__ _syscall2(int, __syscall_kill, __kernel_pid_t, pid, int, sig)
}
#else
extern __typeof(lseek) __libc_lseek;
-libc_hidden_proto(__libc_lseek)
+/* libc_hidden_proto(__libc_lseek) */
loff_t __libc_lseek64(int fd, loff_t offset, int whence)
{
return(loff_t)(__libc_lseek(fd, (off_t) (offset), whence));
}
#endif
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
weak_alias(__libc_lseek64,lseek64)
libc_hidden_weak(lseek64)
/*strong_alias(__libc_lseek64,_llseek) */
#else
extern __typeof(lseek64) __libc_lseek64;
libc_hidden_proto(__libc_lseek64)
+
__off_t __libc_lseek(int fildes, __off_t offset, int whence)
{
return __libc_lseek64(fildes, offset, whence);
#if ! defined __NR_lstat64 && defined __UCLIBC_HAS_LFS__
extern __typeof(lstat) lstat64;
-libc_hidden_proto(lstat64)
+/* libc_hidden_proto(lstat64) */
strong_alias(lstat,lstat64)
libc_hidden_def(lstat64)
#endif
# include <sys/stat.h>
# include "xstatconv.h"
-libc_hidden_proto(lstat64)
+/* libc_hidden_proto(lstat64) */
# define __NR___syscall_lstat64 __NR_lstat64
static __inline__ _syscall2(int, __syscall_lstat64, const char *, file_name,
#include <sys/syscall.h>
#include <sys/stat.h>
-libc_hidden_proto(mkdir)
+/* libc_hidden_proto(mkdir) */
#define __NR___syscall_mkdir __NR_mkdir
static __inline__ _syscall2(int, __syscall_mkdir, const char *, pathname,
#include <sys/stat.h>
#include <sys/types.h>
-libc_hidden_proto(mknod)
+/* libc_hidden_proto(mknod) */
/* Create a named pipe (FIFO) named PATH with protections MODE. */
int
#include <sys/stat.h>
#include <sys/sysmacros.h>
-libc_hidden_proto(mknod)
+/* libc_hidden_proto(mknod) */
#define __NR___syscall_mknod __NR_mknod
static __inline__ _syscall3(int, __syscall_mknod, const char *, path,
#ifdef __NR_mremap
+//vda:TODO: add comment and explain why??
+
#define mremap _hidemremap
#include <sys/mman.h>
#undef mremap
void *mremap(void *, size_t, size_t, int, void *);
-
libc_hidden_proto(mremap)
+
_syscall5(void *, mremap, void *, old_address, size_t, old_size, size_t,
new_size, int, may_move, void *, new_address)
libc_hidden_def(mremap)
#include <unistd.h>
#include <sys/mman.h>
-libc_hidden_proto(munmap)
+/* libc_hidden_proto(munmap) */
_syscall2(int, munmap, void *, start, size_t, length)
libc_hidden_def(munmap)
#define __NR___libc_nanosleep __NR_nanosleep
_syscall2(int, __libc_nanosleep, const struct timespec *, req,
struct timespec *, rem)
-libc_hidden_proto(nanosleep)
+/* libc_hidden_proto(nanosleep) */
weak_alias(__libc_nanosleep,nanosleep)
libc_hidden_weak(nanosleep)
#endif
#include <unistd.h>
#include <sys/resource.h>
-libc_hidden_proto(getpriority)
+/* libc_hidden_proto(getpriority) */
#ifdef __NR_nice
# include <limits.h>
-libc_hidden_proto(setpriority)
+/* libc_hidden_proto(setpriority) */
static __inline__ int int_add_no_wrap(int a, int b)
{
#include <sys/timex.h>
-libc_hidden_proto(adjtimex)
+/* libc_hidden_proto(adjtimex) */
int ntp_gettime(struct ntptimeval *ntv)
{
}
libc_hidden_def(__libc_open64)
-libc_hidden_proto(open64)
+/* libc_hidden_proto(open64) */
weak_alias(__libc_open64,open64)
libc_hidden_weak(open64)
#endif /* __UCLIBC_HAS_LFS__ */
_syscall0(int, __libc_pause)
#else
#include <signal.h>
-libc_hidden_proto(__sigpause)
-libc_hidden_proto(sigblock)
+/* libc_hidden_proto(__sigpause) */
+/* libc_hidden_proto(sigblock) */
int __libc_pause(void)
{
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(pipe)
+/* libc_hidden_proto(pipe) */
_syscall1(int, pipe, int *, filedes)
libc_hidden_def(pipe)
#elif defined(__NR_ppoll) && defined __UCLIBC_LINUX_SPECIFIC__
-libc_hidden_proto(ppoll)
+/* libc_hidden_proto(ppoll) */
int __libc_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
struct timespec *ts = NULL, tval;
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(memset) */
-libc_hidden_proto(getdtablesize)
-libc_hidden_proto(select)
+/* libc_hidden_proto(getdtablesize) */
+/* libc_hidden_proto(select) */
/* uClinux 2.0 doesn't have poll, emulate it using select */
#if defined __NR_ppoll && defined __UCLIBC_LINUX_SPECIFIC__
-libc_hidden_proto(ppoll)
+/* libc_hidden_proto(ppoll) */
# define __NR___libc_ppoll __NR_ppoll
static __always_inline
}
# ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
static ssize_t __fake_pread_write64(int fd, void *buf,
size_t count, off64_t offset, int do_pwrite)
extern __typeof(pselect) __libc_pselect;
/* libc_hidden_proto(sigprocmask) */
-libc_hidden_proto(select)
+/* libc_hidden_proto(select) */
/* Check the first NFDS descriptors each in READFDS (if not NULL) for read
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(readlink)
+/* libc_hidden_proto(readlink) */
_syscall3(ssize_t, readlink, const char *, path, char *, buf, size_t, bufsiz)
libc_hidden_def(readlink)
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(rmdir)
+/* libc_hidden_proto(rmdir) */
_syscall1(int, rmdir, const char *, pathname)
libc_hidden_def(rmdir)
#endif
-libc_hidden_proto(select)
+/* libc_hidden_proto(select) */
weak_alias(__libc_select,select)
libc_hidden_weak(select)
#include <sys/syscall.h>
#if (defined __NR_setresgid || defined __NR_setresgid32) && defined __USE_GNU
-libc_hidden_proto(setresgid)
+/* libc_hidden_proto(setresgid) */
#endif
-libc_hidden_proto(setregid)
+/* libc_hidden_proto(setregid) */
int setegid(gid_t gid)
{
#undef __NR_setresuid32
#endif
-libc_hidden_proto(seteuid)
+/* libc_hidden_proto(seteuid) */
#if (defined __NR_setresuid || defined __NR_setresuid32) && defined __USE_GNU
-libc_hidden_proto(setresuid)
+/* libc_hidden_proto(setresuid) */
#endif
-libc_hidden_proto(setreuid)
+/* libc_hidden_proto(setreuid) */
int seteuid(uid_t uid)
{
#ifdef __USE_BSD
-libc_hidden_proto(setgroups)
+/* libc_hidden_proto(setgroups) */
#if defined(__NR_setgroups32)
# undef __NR_setgroups
#else
-libc_hidden_proto(sysconf)
+/* libc_hidden_proto(sysconf) */
#define __NR___syscall_setgroups __NR_setgroups
static __inline__ _syscall2(int, __syscall_setgroups,
#include <sys/syscall.h>
#include <sys/time.h>
-libc_hidden_proto(setitimer)
+/* libc_hidden_proto(setitimer) */
_syscall3(int, setitimer, __itimer_which_t, which,
const struct itimerval *, new, struct itimerval *, old)
#if defined __USE_UNIX98 || defined __USE_SVID
#include <unistd.h>
-libc_hidden_proto(setpgid)
+/* libc_hidden_proto(setpgid) */
#define __NR___syscall_setpgid __NR_setpgid
static __inline__ _syscall2(int, __syscall_setpgid,
#include <syscall.h>
#include <unistd.h>
-libc_hidden_proto(setpgid)
+/* libc_hidden_proto(setpgid) */
int setpgrp(void)
{
#include <sys/syscall.h>
#include <sys/resource.h>
-libc_hidden_proto(setpriority)
+/* libc_hidden_proto(setpriority) */
_syscall3(int, setpriority, __priority_which_t, which, id_t, who, int, prio)
libc_hidden_def(setpriority)
#include <unistd.h>
#include <bits/wordsize.h>
-libc_hidden_proto(setregid)
+/* libc_hidden_proto(setregid) */
#if (__WORDSIZE == 32 && defined(__NR_setregid32)) || __WORDSIZE == 64
# ifdef __NR_setregid32
# undef __NR_setresgid
# define __NR_setresgid __NR_setresgid32
-libc_hidden_proto(setresgid)
+/* libc_hidden_proto(setresgid) */
_syscall3(int, setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
libc_hidden_def(setresgid)
static __inline__ _syscall3(int, __syscall_setresgid,
__kernel_gid_t, rgid, __kernel_gid_t, egid, __kernel_gid_t, sgid)
-libc_hidden_proto(setresgid)
+/* libc_hidden_proto(setresgid) */
int setresgid(gid_t rgid, gid_t egid, gid_t sgid)
{
if (((rgid + 1) > (gid_t) ((__kernel_gid_t) - 1U))
# undef __NR_setresuid
# define __NR_setresuid __NR_setresuid32
-libc_hidden_proto(setresuid)
+/* libc_hidden_proto(setresuid) */
_syscall3(int, setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
libc_hidden_def(setresuid)
static __inline__ _syscall3(int, __syscall_setresuid,
__kernel_uid_t, rgid, __kernel_uid_t, egid, __kernel_uid_t, sgid)
-libc_hidden_proto(setresuid)
+/* libc_hidden_proto(setresuid) */
int setresuid(uid_t ruid, uid_t euid, uid_t suid)
{
if (((ruid + 1) > (uid_t) ((__kernel_uid_t) - 1U))
#include <unistd.h>
#include <bits/wordsize.h>
-libc_hidden_proto(setreuid)
+/* libc_hidden_proto(setreuid) */
#if (__WORDSIZE == 32 && defined(__NR_setreuid32)) || __WORDSIZE == 64
# ifdef __NR_setreuid32
#include <sys/resource.h>
#undef setrlimit64
-libc_hidden_proto(setrlimit)
+/* libc_hidden_proto(setrlimit) */
/* Only wrap setrlimit if the new usetrlimit is not present and setrlimit sucks */
#if defined __UCLIBC_HAS_LFS__ && __WORDSIZE == 32
-libc_hidden_proto(setrlimit)
+/* libc_hidden_proto(setrlimit) */
/* Set the soft and hard limits for RESOURCE to *RLIMITS.
Only the super-user can increase hard limits.
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(setsid)
+/* libc_hidden_proto(setsid) */
_syscall0(pid_t, setsid)
libc_hidden_def(setsid)
#ifdef __USE_BSD
-libc_hidden_proto(settimeofday)
+/* libc_hidden_proto(settimeofday) */
_syscall2(int, settimeofday, const struct timeval *, tv,
const struct timezone *, tz)
#if defined __USE_POSIX199309
/* libc_hidden_proto(getpid) */
-libc_hidden_proto(getuid)
+/* libc_hidden_proto(getuid) */
/* Experimentally off - libc_hidden_proto(memset) */
#ifdef __NR_rt_sigqueueinfo
return __syscall_sigsuspend(0, 0, set->__val[0]);
}
#endif
-libc_hidden_proto(sigsuspend)
+/* libc_hidden_proto(sigsuspend) */
weak_alias(__libc_sigsuspend,sigsuspend)
libc_hidden_weak(sigsuspend)
#endif
#include <sys/syscall.h>
#include <fcntl.h>
-libc_hidden_proto(splice)
-
#ifdef __NR_splice
_syscall6(ssize_t, splice, int, __fdin, __off64_t *, __offin, int, __fdout,
__off64_t *, __offout, size_t, __len, unsigned int, __flags)
return -1;
}
#endif
-
-libc_hidden_def(splice)
-
#if defined __UCLIBC_HAS_SYSLOG__
#include <sys/syslog.h>
-libc_hidden_proto(openlog)
-libc_hidden_proto(syslog)
-libc_hidden_proto(closelog)
+/* libc_hidden_proto(openlog) */
+/* libc_hidden_proto(syslog) */
+/* libc_hidden_proto(closelog) */
#endif
/* libc_hidden_proto(sigaction) */
-libc_hidden_proto(sigfillset)
-libc_hidden_proto(sigdelset)
+/* libc_hidden_proto(sigfillset) */
+/* libc_hidden_proto(sigdelset) */
/* libc_hidden_proto(sigprocmask) */
/* libc_hidden_proto(write) */
-libc_hidden_proto(kill)
+/* libc_hidden_proto(kill) */
/* libc_hidden_proto(getpid) */
/* libc_hidden_proto(_exit) */
#if ! defined __NR_stat64 && defined __UCLIBC_HAS_LFS__
extern __typeof(stat) stat64;
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(stat64) */
strong_alias(stat,stat64)
libc_hidden_def(stat64)
#endif
#include <sys/stat.h>
#if defined __UCLIBC_HAS_LFS__ && defined __NR_stat64
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(stat64) */
# define __NR___syscall_stat64 __NR_stat64
# include <unistd.h>
extern __typeof(statfs) __libc_statfs;
libc_hidden_proto(__libc_statfs)
+
#define __NR___libc_statfs __NR_statfs
_syscall2(int, __libc_statfs, const char *, path, struct statfs *, buf)
#ifdef __NR_stime
_syscall1(int, stime, const time_t *, t)
#else
-libc_hidden_proto(settimeofday)
+/* libc_hidden_proto(settimeofday) */
int stime(const time_t * when)
{
#include <sys/syscall.h>
#include <sys/times.h>
-libc_hidden_proto(times)
+/* libc_hidden_proto(times) */
_syscall1(clock_t, times, struct tms *, buf)
libc_hidden_def(times)
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(truncate)
+/* libc_hidden_proto(truncate) */
_syscall2(int, truncate, const char *, path, __off_t, length)
libc_hidden_def(truncate)
#else /* __NR_truncate64 */
-libc_hidden_proto(truncate)
+/* libc_hidden_proto(truncate) */
int truncate64 (const char * path, __off64_t length)
{
#include <ulimit.h>
#include <sys/resource.h>
-libc_hidden_proto(sysconf)
-libc_hidden_proto(getrlimit)
-libc_hidden_proto(setrlimit)
+/* libc_hidden_proto(sysconf) */
+/* libc_hidden_proto(getrlimit) */
+/* libc_hidden_proto(setrlimit) */
long int ulimit(int cmd, ...)
{
#include <sys/syscall.h>
#include <sys/utsname.h>
-libc_hidden_proto(uname)
+/* libc_hidden_proto(uname) */
_syscall1(int, uname, struct utsname *, buf)
libc_hidden_def(uname)
#include <sys/syscall.h>
#include <unistd.h>
-libc_hidden_proto(unlink)
+/* libc_hidden_proto(unlink) */
_syscall1(int, unlink, const char *, pathname)
libc_hidden_def(unlink)
#include <sys/syscall.h>
#include <utime.h>
-libc_hidden_proto(utime)
+/* libc_hidden_proto(utime) */
#ifdef __NR_utime
_syscall2(int, utime, const char *, file, const struct utimbuf *, times)
#include <stdlib.h>
#include <sys/time.h>
-libc_hidden_proto(utimes)
+/* libc_hidden_proto(utimes) */
/* libc_hidden_proto(gettimeofday) */
int utime(const char *file, const struct utimbuf *times)
#include <utime.h>
#include <sys/time.h>
-libc_hidden_proto(utimes)
+/* libc_hidden_proto(utimes) */
#ifdef __NR_utimes
_syscall2(int, utimes, const char *, file, const struct timeval *, tvp)
#else
#include <stdlib.h>
-libc_hidden_proto(utime)
+/* libc_hidden_proto(utime) */
int utimes(const char *file, const struct timeval tvp[2])
{
#ifdef __ARCH_USE_MMU__
#ifdef __NR_fork
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
extern __typeof(vfork) __vfork attribute_hidden;
pid_t __vfork(void)
{
return fork();
}
-libc_hidden_proto(vfork)
+/* libc_hidden_proto(vfork) */
weak_alias(__vfork,vfork)
libc_hidden_weak(vfork)
#endif
#include <sys/syscall.h>
#include <fcntl.h>
-libc_hidden_proto(vmsplice)
-
#ifdef __NR_vmsplice
_syscall4(ssize_t, vmsplice, int, __fdout, const struct iovec *, __iov,
size_t, __count, unsigned int, __flags)
return -1;
}
#endif
-
-libc_hidden_def(vmsplice)
-
#include <sys/wait.h>
#include <sys/resource.h>
-libc_hidden_proto(wait4)
+/* libc_hidden_proto(wait4) */
extern __typeof(wait) __libc_wait;
#if defined __USE_BSD
-libc_hidden_proto(wait4)
+/* libc_hidden_proto(wait4) */
/* Wait for a child to exit. When one does, put its status in *STAT_LOC and
* return its process ID. For errors return (pid_t) -1. If USAGE is not nil,
#include <sys/wait.h>
#include <sys/resource.h>
-libc_hidden_proto(wait4)
+/* libc_hidden_proto(wait4) */
#define __NR___syscall_wait4 __NR_wait4
static __inline__ _syscall4(int, __syscall_wait4, __kernel_pid_t, pid,
_syscall4(int, waitid, idtype_t, idtype, id_t, id, siginfo_t*, infop, int, options)
# else
# include <string.h>
-libc_hidden_proto(waitpid)
+/* libc_hidden_proto(waitpid) */
int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options)
{
switch (idtype) {
#include <sys/wait.h>
#include <sys/resource.h>
-libc_hidden_proto(wait4)
+/* libc_hidden_proto(wait4) */
extern __typeof(waitpid) __libc_waitpid;
__pid_t __libc_waitpid(__pid_t pid, int *wait_stat, int options)
{
return wait4(pid, wait_stat, options, NULL);
}
-libc_hidden_proto(waitpid)
+/* libc_hidden_proto(waitpid) */
weak_alias(__libc_waitpid,waitpid)
libc_hidden_weak(waitpid)
R0&-1==R0, and the child gets R0&0==0. */
/* i dunno what the blurb above is useful for. we just return. */
__asm__("ret\n\tnop");
-libc_hidden_proto(fork)
+/* libc_hidden_proto(fork) */
weak_alias(__libc_fork,fork)
libc_hidden_weak(fork)
#define __NR___vfork __NR_vfork
attribute_hidden _syscall0(pid_t, __vfork)
-libc_hidden_proto(vfork)
+/* libc_hidden_proto(vfork) */
weak_alias(__vfork,vfork)
libc_hidden_weak(vfork)
#include <sys/stat.h>
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(fstat64)
+/* libc_hidden_proto(fstat64) */
_syscall2(int, fstat64, int, fd, struct stat64 *, buf)
libc_hidden_def(fstat64)
#endif
#include <sys/stat.h>
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(lstat64)
+/* libc_hidden_proto(lstat64) */
_syscall2(int, lstat64, const char *, file_name, struct stat64 *, buf)
libc_hidden_def(lstat64)
#endif
#include <sys/stat.h>
#ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(stat64)
+/* libc_hidden_proto(stat64) */
_syscall2(int, stat64, const char *, file_name, struct stat64 *, buf)
libc_hidden_def(stat64)
#endif
/* libc_hidden_proto(ioctl) */
-libc_hidden_proto(tcsetattr)
-libc_hidden_proto(tcgetattr)
+/* libc_hidden_proto(tcsetattr) */
+/* libc_hidden_proto(tcgetattr) */
/* The user-visible size of struct termios has changed. Catch ioctl calls
using the new-style struct termios, and translate them to old-style. */
}
# ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
static ssize_t __fake_pread_write64(int fd, void *buf,
size_t count, off64_t offset, int do_pwrite)
#include <unistd.h>
#include <syscall.h>
-libc_hidden_proto(pipe)
+/* libc_hidden_proto(pipe) */
int pipe(int *fd)
{
E.g., Linux/Alpha for Alpha PCs supports this. */
extern int ioperm (unsigned long int __from, unsigned long int __num,
int __turn_on) __THROW;
+libc_hidden_proto(ioperm)
/* Set the I/O privilege level to LEVEL. If LEVEL>3, permission to
access any I/O port is granted. This call requires root
}
# ifdef __UCLIBC_HAS_LFS__
-libc_hidden_proto(lseek64)
+/* libc_hidden_proto(lseek64) */
static ssize_t __fake_pread_write64(int fd, void *buf,
size_t count, off64_t offset, int do_pwrite)
#ifdef __USE_BSD
-libc_hidden_proto(cfsetispeed)
-libc_hidden_proto(cfsetospeed)
+/* libc_hidden_proto(cfsetispeed) */
+/* libc_hidden_proto(cfsetospeed) */
struct speed_struct
{
#include <unistd.h>
#include <termios.h>
-libc_hidden_proto(isatty)
-libc_hidden_proto(tcgetattr)
+/* libc_hidden_proto(isatty) */
+/* libc_hidden_proto(tcgetattr) */
/* Return 1 if FD is a terminal, 0 if not. */
int isatty (int fd)
#include <errno.h>
#include <termios.h>
-libc_hidden_proto(cfsetispeed)
-libc_hidden_proto(cfsetospeed)
+/* libc_hidden_proto(cfsetispeed) */
+/* libc_hidden_proto(cfsetospeed) */
/* This is a gross hack around a kernel bug. If the cfsetispeed functions
is called with the SPEED argument set to zero this means use the same
/* Experimentally off - libc_hidden_proto(memset) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(mempcpy) */
-libc_hidden_proto(tcgetattr)
+/* libc_hidden_proto(tcgetattr) */
/* The difference here is that the termios structure used in the
kernel is not the same as we use in the libc. Therefore we must
#include <unistd.h>
#include <sys/types.h>
-libc_hidden_proto(tcgetpgrp)
+/* libc_hidden_proto(tcgetpgrp) */
/* libc_hidden_proto(ioctl) */
/* Return the foreground process group ID of FD. */
#include <unistd.h>
/* libc_hidden_proto(ioctl) */
-libc_hidden_proto(getsid)
-libc_hidden_proto(tcgetpgrp)
+/* libc_hidden_proto(getsid) */
+/* libc_hidden_proto(tcgetpgrp) */
/* Return the session ID of FD. */
pid_t
#include <sys/ioctl.h>
#include <sys/types.h>
-libc_hidden_proto(tcsetattr)
+/* libc_hidden_proto(tcsetattr) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* libc_hidden_proto(ioctl) */
#include <dirent.h>
#include <sys/stat.h>
-libc_hidden_proto(ttyname_r)
+/* libc_hidden_proto(ttyname_r) */
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(lstat) */
/* Experimentally off - libc_hidden_proto(strcpy) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(opendir)
-libc_hidden_proto(closedir)
-libc_hidden_proto(readdir)
-libc_hidden_proto(isatty)
+/* libc_hidden_proto(opendir) */
+/* libc_hidden_proto(closedir) */
+/* libc_hidden_proto(readdir) */
+/* libc_hidden_proto(isatty) */
#define TTYNAME_BUFLEN 32
/* libc_hidden_proto(open) */
/* libc_hidden_proto(close) */
/* libc_hidden_proto(_exit) */
-libc_hidden_proto(dup2)
-libc_hidden_proto(setsid)
-libc_hidden_proto(chdir)
-libc_hidden_proto(fork)
+/* libc_hidden_proto(dup2) */
+/* libc_hidden_proto(setsid) */
+/* libc_hidden_proto(chdir) */
+/* libc_hidden_proto(fork) */
int daemon( int nochdir, int noclose )
{
#include <unistd.h>
#include <sys/mman.h>
-libc_hidden_proto(execl)
-libc_hidden_proto(execle)
-libc_hidden_proto(execlp)
-libc_hidden_proto(execv)
-libc_hidden_proto(execvp)
+/* libc_hidden_proto(execl) */
+/* libc_hidden_proto(execle) */
+/* libc_hidden_proto(execlp) */
+/* libc_hidden_proto(execv) */
+/* libc_hidden_proto(execvp) */
/* Experimentally off - libc_hidden_proto(memcpy) */
/* Experimentally off - libc_hidden_proto(strchr) */
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(execve)
+/* libc_hidden_proto(execve) */
/* libc_hidden_proto(mmap) */
-libc_hidden_proto(munmap)
+/* libc_hidden_proto(munmap) */
/* libc_hidden_proto(getenv) */
/**********************************************************************/
* the user specify whatever they want via the LOGNAME environment
* variable, or we return NULL if getenv() fails to find anything */
-libc_hidden_proto(getlogin)
+/* libc_hidden_proto(getlogin) */
char * getlogin(void)
{
return (getenv("LOGNAME"));
int optopt = 0;
char *optarg = NULL;
-libc_hidden_proto(getopt)
+/* libc_hidden_proto(getopt) */
int getopt(int argc, char * const argv[], const char *optstring)
{
static const char *o; /* multi opt position */
#include <getopt.h>
#include <stdio.h>
-libc_hidden_proto(getopt)
+/* libc_hidden_proto(getopt) */
static int __getopt_long(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *idx, int longonly)
{
#if defined __USE_BSD || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
/* Experimentally off - libc_hidden_proto(strlen) */
-libc_hidden_proto(tcsetattr)
-libc_hidden_proto(tcgetattr)
-libc_hidden_proto(setvbuf)
+/* libc_hidden_proto(tcsetattr) */
+/* libc_hidden_proto(tcgetattr) */
+/* libc_hidden_proto(setvbuf) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(fileno)
-libc_hidden_proto(fflush)
+/* libc_hidden_proto(fileno) */
+/* libc_hidden_proto(fflush) */
/* libc_hidden_proto(fgets) */
/* libc_hidden_proto(fputs) */
-libc_hidden_proto(fputc)
-libc_hidden_proto(putc)
-libc_hidden_proto(__fputc_unlocked)
+/* libc_hidden_proto(fputc) */
+/* libc_hidden_proto(putc) */
+/* libc_hidden_proto(__fputc_unlocked) */
/* It is desirable to use this bit on systems that have it.
The only bit of terminal state we want to twiddle is echoing, which is
#include <signal.h>
#include <unistd.h>
-libc_hidden_proto(sleep)
+/* libc_hidden_proto(sleep) */
/* libc_hidden_proto(sigaction) */
/* libc_hidden_proto(sigprocmask) */
#include <regex.h>
#endif
-libc_hidden_proto(sysconf)
+/* libc_hidden_proto(sysconf) */
-libc_hidden_proto(getpagesize)
-libc_hidden_proto(getdtablesize)
+/* libc_hidden_proto(getpagesize) */
+/* libc_hidden_proto(getdtablesize) */
#ifndef __UCLIBC_CLK_TCK_CONST
#error __UCLIBC_CLK_TCK_CONST not defined!
#include <sys/types.h>
#include <unistd.h>
-libc_hidden_proto(setitimer)
+/* libc_hidden_proto(setitimer) */
useconds_t ualarm(useconds_t value, useconds_t interval)
{
/* libc_hidden_proto(fstat) */
/* libc_hidden_proto(fopen) */
/* libc_hidden_proto(fclose) */
-libc_hidden_proto(__fsetlocking)
-libc_hidden_proto(fileno)
-libc_hidden_proto(fgets_unlocked)
+/* libc_hidden_proto(__fsetlocking) */
+/* libc_hidden_proto(fileno) */
+/* libc_hidden_proto(fgets_unlocked) */
#ifdef __UCLIBC_HAS_XLOCALE__
/* libc_hidden_proto(__ctype_b_loc) */
#elif defined __UCLIBC_HAS_CTYPE_TABLES__
return(nanosleep(&ts, NULL));
}
#else /* __UCLIBC_HAS_REALTIME__ */
-libc_hidden_proto(select)
+/* libc_hidden_proto(select) */
int usleep (__useconds_t usec)
{
struct timeval tv;
OSDN Git Service
