Remove K&R compatibility.
authordrepper <drepper>
Sat, 9 Oct 1999 21:19:32 +0000 (21:19 +0000)
committerdrepper <drepper>
Sat, 9 Oct 1999 21:19:32 +0000 (21:19 +0000)
93 files changed:
inet/netinet/in.h
intl/libintl.h
io/fcntl.h
io/fts.h
io/ftw.h
io/sys/poll.h
io/sys/stat.h
io/sys/statfs.h
io/sys/statvfs.h
io/utime.h
libio/libio.h
libio/stdio.h
linuxthreads/sysdeps/pthread/pthread.h
locale/locale.h
login/pty.h
login/utmp.h
malloc/mcheck.h
math/complex.h
math/math.h
math/math_private.h
misc/err.h
misc/fstab.h
misc/libgen.h
misc/mntent.h
misc/regexp.h
misc/search.h
misc/sgtty.h
misc/sys/cdefs.h
misc/sys/file.h
misc/sys/ioctl.h
misc/sys/mman.h
misc/sys/select.h
misc/sys/syslog.h
misc/sys/uio.h
misc/sys/ustat.h
misc/ttyent.h
nss/nss.h
posix/sched.h
posix/sys/times.h
posix/sys/utsname.h
posix/sys/wait.h
posix/unistd.h
posix/wordexp.h
pwd/pwd.h
resolv/netdb.h
resolv/resolv.h
resource/sys/resource.h
resource/sys/vlimit.h
resource/sys/vtimes.h
resource/ulimit.h
rt/aio.h
setjmp/setjmp.h
shadow/shadow.h
signal/signal.h
stdio-common/_itoa.h
stdio-common/_itowa.h
stdio-common/printf.h
stdio/stdio.h
stdlib/alloca.h
stdlib/fmtmsg.h
stdlib/monetary.h
stdlib/stdlib.h
stdlib/ucontext.h
streams/stropts.h
string/argz.h
string/bits/string2.h
string/envz.h
string/string.h
string/strings.h
sunrpc/rpc/auth.h
sunrpc/rpc/auth_des.h
sunrpc/rpc/auth_unix.h
sunrpc/rpc/clnt.h
sunrpc/rpc/des_crypt.h
sunrpc/rpc/netdb.h
sunrpc/rpc/pmap_clnt.h
sunrpc/rpc/pmap_prot.h
sunrpc/rpc/pmap_rmt.h
sunrpc/rpc/rpc_msg.h
sunrpc/rpc/svc.h
sunrpc/rpc/svc_auth.h
sunrpc/rpc/xdr.h
sysdeps/unix/sysv/linux/bits/sigstack.h
sysvipc/sys/ipc.h
sysvipc/sys/msg.h
sysvipc/sys/sem.h
sysvipc/sys/shm.h
termios/termios.h
time/sys/time.h
time/sys/timeb.h
time/time.h
wcsmbs/wchar.h
wctype/wctype.h

index e57d9e0..7d9f327 100644 (file)
@@ -231,10 +231,13 @@ struct ipv6_mreq
    this was a short-sighted decision since on different systems the types
    may have different representations but the values are always the same.  */
 
-extern uint32_t ntohl __P ((uint32_t __netlong)) __attribute__ ((__const__));
-extern uint16_t ntohs __P ((uint16_t __netshort)) __attribute__ ((__const__));
-extern uint32_t htonl __P ((uint32_t __hostlong)) __attribute__ ((__const__));
-extern uint16_t htons __P ((uint16_t __hostshort)) __attribute__ ((__const__));
+extern uint32_t ntohl (uint32_t __netlong) __THROW __attribute__ ((__const__));
+extern uint16_t ntohs (uint16_t __netshort)
+     __THROW __attribute__ ((__const__));
+extern uint32_t htonl (uint32_t __hostlong)
+     __THROW __attribute__ ((__const__));
+extern uint16_t htons (uint16_t __hostshort)
+     __THROW __attribute__ ((__const__));
 
 #include <endian.h>
 
@@ -288,7 +291,7 @@ extern uint16_t htons __P ((uint16_t __hostshort)) __attribute__ ((__const__));
         (((uint32_t *) (a))[3] == ((uint32_t *) (b))[3]))
 
 /* Bind socket to a privileged IP port.  */
-extern int bindresvport __P ((int __sockfd, struct sockaddr_in *__sock_in));
+extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) __THROW;
 
 
 
index 1d35518..aec7ea4 100644 (file)
@@ -1,6 +1,6 @@
 /* Message catalogs for internationalization.
-   Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
-   Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
+   Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1995.
    This file is derived from the file libgettext.h in the GNU gettext package.
 
    This file is part of the GNU C Library.  Its master source is NOT part of
@@ -35,32 +35,32 @@ __BEGIN_DECLS
 /* Look up MSGID in the current default message catalog for the current
    LC_MESSAGES locale.  If not found, returns MSGID itself (the default
    text).  */
-extern char *gettext __P ((__const char *__msgid));
+extern char *gettext (__const char *__msgid) __THROW;
 
 /* Look up MSGID in the DOMAINNAME message catalog for the current
    LC_MESSAGES locale.  */
-extern char *dgettext __P ((__const char *__domainname,
-                           __const char *__msgid));
-extern char *__dgettext __P ((__const char *__domainname,
-                             __const char *__msgid));
+extern char *dgettext (__const char *__domainname,
+                      __const char *__msgid) __THROW;
+extern char *__dgettext (__const char *__domainname,
+                        __const char *__msgid) __THROW;
 
 /* Look up MSGID in the DOMAINNAME message catalog for the current CATEGORY
    locale.  */
-extern char *dcgettext __P ((__const char *__domainname,
-                            __const char *__msgid, int __category));
-extern char *__dcgettext __P ((__const char *__domainname,
-                              __const char *__msgid, int __category));
+extern char *dcgettext (__const char *__domainname,
+                       __const char *__msgid, int __category) __THROW;
+extern char *__dcgettext (__const char *__domainname,
+                         __const char *__msgid, int __category) __THROW;
 
 
 /* Set the current default message catalog to DOMAINNAME.
    If DOMAINNAME is null, return the current default.
    If DOMAINNAME is "", reset to the default of "messages".  */
-extern char *textdomain __P ((__const char *__domainname));
+extern char *textdomain (__const char *__domainname) __THROW;
 
 /* Specify that the DOMAINNAME message catalog will be found
    in DIRNAME rather than in the system locale data base.  */
-extern char *bindtextdomain __P ((__const char *__domainname,
-                                 __const char *__dirname));
+extern char *bindtextdomain (__const char *__domainname,
+                            __const char *__dirname) __THROW;
 
 
 /* Optimized version of the function above.  */
index aa0796b..8706a44 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 92, 94, 95, 96, 97, 98 Free Software Foundation, Inc.
+/* Copyright (C) 1991,92,94,95,96,97,98,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -57,42 +57,42 @@ __BEGIN_DECLS
 
 /* Do the file control operation described by CMD on FD.
    The remaining arguments are interpreted depending on CMD.  */
-extern int __fcntl __P ((int __fd, int __cmd, ...));
-extern int fcntl __P ((int __fd, int __cmd, ...));
+extern int __fcntl (int __fd, int __cmd, ...) __THROW;
+extern int fcntl (int __fd, int __cmd, ...) __THROW;
 
 /* Open FILE and return a new file descriptor for it, or -1 on error.
    OFLAG determines the type of access used.  If O_CREAT is on OFLAG,
    the third argument is taken as a `mode_t', the mode of the created file.  */
-extern int __open __P ((__const char *__file, int __oflag, ...));
+extern int __open (__const char *__file, int __oflag, ...) __THROW;
 #ifndef __USE_FILE_OFFSET64
-extern int open __P ((__const char *__file, int __oflag, ...));
+extern int open (__const char *__file, int __oflag, ...) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (open, __P ((__const char *__file, int __oflag, ...)),
+extern int __REDIRECT (open, (__const char *__file, int __oflag, ...) __THROW,
                       open64);
 # else
 #  define open open64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int open64 __P ((__const char *__file, int __oflag, ...));
+extern int open64 (__const char *__file, int __oflag, ...) __THROW;
 #endif
 
 /* Create and open FILE, with mode MODE.
    This takes an `int' MODE argument because that is
    what `mode_t' will be widened to.  */
 #ifndef __USE_FILE_OFFSET64
-extern int creat __P ((__const char *__file, __mode_t __mode));
+extern int creat (__const char *__file, __mode_t __mode) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (creat, __P ((__const char *__file, __mode_t __mode)),
+extern int __REDIRECT (creat, (__const char *__file, __mode_t __mode) __THROW,
                       creat64);
 # else
 #  define creat creat64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int creat64 __P ((__const char *__file, __mode_t __mode));
+extern int creat64 (__const char *__file, __mode_t __mode) __THROW;
 #endif
 
 #if !defined F_LOCK && (defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \
@@ -111,17 +111,17 @@ extern int creat64 __P ((__const char *__file, __mode_t __mode));
 # define F_TEST  3     /* Test a region for other processes locks.  */
 
 # ifndef __USE_FILE_OFFSET64
-extern int lockf __P ((int __fd, int __cmd, __off_t __len));
+extern int lockf (int __fd, int __cmd, __off_t __len) __THROW;
 # else
 # ifdef __REDIRECT
-extern int __REDIRECT (lockf, __P ((int __fd, int __cmd, __off64_t __len)),
+extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len) __THROW,
                       lockf64);
 # else
 #  define lockf lockf64
 # endif
 # endif
 # ifdef __USE_LARGEFILE64
-extern int lockf64 __P ((int __fd, int __cmd, __off64_t __len));
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) __THROW;
 # endif
 #endif
 
index dc2b4bd..2b500e0 100644 (file)
--- a/io/fts.h
+++ b/io/fts.h
@@ -44,7 +44,7 @@ typedef struct {
        int fts_rfd;                    /* fd for root */
        int fts_pathlen;                /* sizeof(path) */
        int fts_nitems;                 /* elements in the sort array */
-       int (*fts_compar) __PMT((const void *, const void *)); /* compare fn */
+       int (*fts_compar) (const void *, const void *); /* compare fn */
 
 #define        FTS_COMFOLLOW   0x0001          /* follow command line symlinks */
 #define        FTS_LOGICAL     0x0002          /* logical walk */
@@ -113,12 +113,12 @@ typedef struct _ftsent {
 } FTSENT;
 
 __BEGIN_DECLS
-FTSENT *fts_children __P((FTS *, int));
-int     fts_close __P((FTS *));
-FTS    *fts_open __P((char * const *, int,
-           int (*)(const FTSENT **, const FTSENT **)));
-FTSENT *fts_read __P((FTS *));
-int     fts_set __P((FTS *, FTSENT *, int));
+FTSENT *fts_children (FTS *, int) __THROW;
+int     fts_close (FTS *) __THROW;
+FTS    *fts_open (char * const *, int,
+                  int (*)(const FTSENT **, const FTSENT **)) __THROW;
+FTSENT *fts_read (FTS *) __THROW;
+int     fts_set (FTS *, FTSENT *, int) __THROW;
 __END_DECLS
 
 #endif /* fts.h */
index 6ccddee..2b6f9d9 100644 (file)
--- a/io/ftw.h
+++ b/io/ftw.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1992, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -86,59 +86,57 @@ struct FTW
 
 
 /* Convenient types for callback functions.  */
-typedef int (*__ftw_func_t) __PMT ((__const char *__filename,
-                                   __const struct stat *__status,
-                                   int __flag));
+typedef int (*__ftw_func_t) (__const char *__filename,
+                            __const struct stat *__status, int __flag);
 #ifdef __USE_LARGEFILE64
-typedef int (*__ftw64_func_t) __PMT ((__const char *__filename,
-                                     __const struct stat64 *__status,
-                                     int __flag));
+typedef int (*__ftw64_func_t) (__const char *__filename,
+                              __const struct stat64 *__status, int __flag);
 #endif
 #ifdef __USE_XOPEN_EXTENDED
-typedef int (*__nftw_func_t) __PMT ((__const char *__filename,
-                                    __const struct stat *__status, int __flag,
-                                    struct FTW *__info));
+typedef int (*__nftw_func_t) (__const char *__filename,
+                             __const struct stat *__status, int __flag,
+                             struct FTW *__info);
 # ifdef __USE_LARGEFILE64
-typedef int (*__nftw64_func_t) __PMT ((__const char *__filename,
-                                      __const struct stat64 *__status,
-                                      int __flag, struct FTW *__info));
+typedef int (*__nftw64_func_t) (__const char *__filename,
+                               __const struct stat64 *__status,
+                               int __flag, struct FTW *__info);
 # endif
 #endif
 
 /* Call a function on every element in a directory tree.  */
 #ifndef __USE_FILE_OFFSET64
-extern int ftw __P ((__const char *__dir, __ftw_func_t __func,
-                    int __descriptors));
+extern int ftw (__const char *__dir, __ftw_func_t __func, int __descriptors)
+     __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (ftw, __P ((__const char *__dir, __ftw_func_t __func,
-                                 int __descriptors)), ftw64);
+extern int __REDIRECT (ftw, (__const char *__dir, __ftw_func_t __func,
+                            int __descriptors) __THROW, ftw64);
 # else
 #  define ftw ftw64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int ftw64 __P ((__const char *__dir, __ftw64_func_t __func,
-                      int __descriptors));
+extern int ftw64 (__const char *__dir, __ftw64_func_t __func,
+                 int __descriptors) __THROW;
 #endif
 
 #ifdef __USE_XOPEN_EXTENDED
 /* Call a function on every element in a directory tree.  FLAG allows
    to specify the behaviour more detailed.  */
 # ifndef __USE_FILE_OFFSET64
-extern int nftw __P ((__const char *__dir, __nftw_func_t __func,
-                     int __descriptors, int __flag));
+extern int nftw (__const char *__dir, __nftw_func_t __func, int __descriptors,
+                int __flag) __THROW;
 # else
 #  ifdef __REDIRECT
-extern int __REDIRECT (nftw, __P ((__const char *__dir, __nftw_func_t __func,
-                                  int __descriptors, int __flag)), nftw64);
+extern int __REDIRECT (nftw, (__const char *__dir, __nftw_func_t __func,
+                             int __descriptors, int __flag) __THROW, nftw64);
 #  else
 #   define nftw nftw64
 #  endif
 # endif
 # ifdef __USE_LARGEFILE64
-extern int nftw64 __P ((__const char *__dir, __nftw64_func_t __func,
-                       int __descriptors, int __flag));
+extern int nftw64 (__const char *__dir, __nftw64_func_t __func,
+                  int __descriptors, int __flag) __THROW;
 # endif
 #endif
 
index 9cb60e7..ac9c634 100644 (file)
@@ -1,5 +1,5 @@
 /* Compatibility definitions for System V `poll' interface.
-   Copyright (C) 1994, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -41,10 +41,10 @@ struct pollfd
    an event to occur; if TIMEOUT is -1, block until an event occurs.
    Returns the number of file descriptors with events, zero if timed out,
    or -1 for errors.  */
-extern int __poll __P ((struct pollfd *__fds, unsigned long int __nfds,
-                       int __timeout));
-extern int poll __P ((struct pollfd *__fds, unsigned long int __nfds,
-                     int __timeout));
+extern int __poll (struct pollfd *__fds, unsigned long int __nfds,
+                  int __timeout) __THROW;
+extern int poll (struct pollfd *__fds, unsigned long int __nfds, int __timeout)
+     __THROW;
 
 __END_DECLS
 
index 97f7897..d6175dd 100644 (file)
@@ -187,79 +187,81 @@ __BEGIN_DECLS
 
 #ifndef __USE_FILE_OFFSET64
 /* Get file attributes for FILE and put them in BUF.  */
-extern int stat __P ((__const char *__file, struct stat *__buf));
+extern int stat (__const char *__file, struct stat *__buf) __THROW;
 
 /* Get file attributes for the file, device, pipe, or socket
    that file descriptor FD is open on and put them in BUF.  */
-extern int fstat __P ((int __fd, struct stat *__buf));
+extern int fstat (int __fd, struct stat *__buf) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (stat, __P ((__const char *__file, struct stat *__buf)),
+extern int __REDIRECT (stat,
+                      (__const char *__file, struct stat *__buf) __THROW,
                       stat64);
-extern int __REDIRECT (fstat, __P ((int __fd, struct stat *__buf)), fstat64);
+extern int __REDIRECT (fstat, (int __fd, struct stat *__buf) __THROW, fstat64);
 # else
 #  define stat stat64
 #  define fstat fstat64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int stat64 __P ((__const char *__file, struct stat64 *__buf));
-extern int fstat64 __P ((int __fd, struct stat64 *__buf));
+extern int stat64 (__const char *__file, struct stat64 *__buf) __THROW;
+extern int fstat64 (int __fd, struct stat64 *__buf) __THROW;
 #endif
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 # ifndef __USE_FILE_OFFSET64
 /* Get file attributes about FILE and put them in BUF.
    If FILE is a symbolic link, do not follow it.  */
-extern int lstat __P ((__const char *__file, struct stat *__buf));
+extern int lstat (__const char *__file, struct stat *__buf) __THROW;
 # else
 #  ifdef __REDIRECT
-extern int __REDIRECT (lstat, __P ((__const char *__file, struct stat *__buf)),
+extern int __REDIRECT (lstat,
+                      (__const char *__file, struct stat *__buf) __THROW,
                       lstat64);
 #  else
 #   define lstat lstat64
 #  endif
 # endif
 # ifdef __USE_LARGEFILE64
-extern int lstat64 __P ((__const char *__file, struct stat64 *__buf));
+extern int lstat64 (__const char *__file, struct stat64 *__buf) __THROW;
 # endif
 #endif
 
 /* Set file access permissions for FILE to MODE.
    This takes an `int' MODE argument because that
    is what `mode_t's get widened to.  */
-extern int chmod __P ((__const char *__file, __mode_t __mode));
+extern int chmod (__const char *__file, __mode_t __mode) __THROW;
 
 /* Set file access permissions of the file FD is open on to MODE.  */
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
-extern int fchmod __P ((int __fd, __mode_t __mode));
+extern int fchmod (int __fd, __mode_t __mode) __THROW;
 #endif
 
 
 /* Set the file creation mask of the current process to MASK,
    and return the old creation mask.  */
-extern __mode_t umask __P ((__mode_t __mask));
+extern __mode_t umask (__mode_t __mask) __THROW;
 
 #ifdef __USE_GNU
 /* Get the current `umask' value without changing it.
    This function is only available under the GNU Hurd.  */
-extern __mode_t getumask __P ((void));
+extern __mode_t getumask (void) __THROW;
 #endif
 
 /* Create a new directory named PATH, with permission bits MODE.  */
-extern int mkdir __P ((__const char *__path, __mode_t __mode));
+extern int mkdir (__const char *__path, __mode_t __mode) __THROW;
 
 /* Create a device file named PATH, with permission and special bits MODE
    and device number DEV (which can be constructed from major and minor
    device numbers with the `makedev' macro above).  */
 #if defined __USE_MISC || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
-extern int mknod __P ((__const char *__path,
-                      __mode_t __mode, __dev_t __dev));
+extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
+     __THROW;
 #endif
 
 
 /* Create a new FIFO named PATH, with permission bits MODE.  */
-extern int mkfifo __P ((__const char *__path, __mode_t __mode));
+extern int mkfifo (__const char *__path, __mode_t __mode) __THROW;
 \f
 /* To allow the `struct stat' structure and the file type `mode_t'
    bits to vary without changing shared library major version number,
@@ -285,20 +287,21 @@ extern int mkfifo __P ((__const char *__path, __mode_t __mode));
 
 /* Wrappers for stat and mknod system calls.  */
 #ifndef __USE_FILE_OFFSET64
-extern int __fxstat __P ((int __ver, int __fildes,
-                         struct stat *__stat_buf));
-extern int __xstat __P ((int __ver, __const char *__filename,
-                        struct stat *__stat_buf));
-extern int __lxstat __P ((int __ver, __const char *__filename,
-                         struct stat *__stat_buf));
+extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) __THROW;
+extern int __xstat (int __ver, __const char *__filename,
+                   struct stat *__stat_buf) __THROW;
+extern int __lxstat (int __ver, __const char *__filename,
+                    struct stat *__stat_buf) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (__fxstat, __P ((int __ver, int __fildes,
-                                      struct stat *__stat_buf)), __fxstat64);
-extern int __REDIRECT (__xstat, __P ((int __ver, __const char *__filename,
-                                     struct stat *__stat_buf)), __xstat64);
-extern int __REDIRECT (__lxstat, __P ((int __ver, __const char *__filename,
-                                      struct stat *__stat_buf)), __lxstat64);
+extern int __REDIRECT (__fxstat, (int __ver, int __fildes,
+                                 struct stat *__stat_buf) __THROW,
+                      __fxstat64);
+extern int __REDIRECT (__xstat, (int __ver, __const char *__filename,
+                                struct stat *__stat_buf) __THROW, __xstat64);
+extern int __REDIRECT (__lxstat, (int __ver, __const char *__filename,
+                                 struct stat *__stat_buf) __THROW,
+                      __lxstat64);
 
 # else
 #  define __fxstat __fxstat64
@@ -308,15 +311,15 @@ extern int __REDIRECT (__lxstat, __P ((int __ver, __const char *__filename,
 #endif
 
 #ifdef __USE_LARGEFILE64
-extern int __fxstat64 __P ((int __ver, int __fildes,
-                           struct stat64 *__stat_buf));
-extern int __xstat64 __P ((int __ver, __const char *__filename,
-                          struct stat64 *__stat_buf));
-extern int __lxstat64 __P ((int __ver, __const char *__filename,
-                           struct stat64 *__stat_buf));
+extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
+     __THROW;
+extern int __xstat64 (int __ver, __const char *__filename,
+                     struct stat64 *__stat_buf) __THROW;
+extern int __lxstat64 (int __ver, __const char *__filename,
+                      struct stat64 *__stat_buf) __THROW;
 #endif
-extern int __xmknod __P ((int __ver, __const char *__path,
-                         __mode_t __mode, __dev_t *__dev));
+extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
+                    __dev_t *__dev) __THROW;
 
 #if defined __GNUC__ && __GNUC__ >= 2
 /* Inlined versions of the real stat and mknod functions.  */
index be93bc9..f5258f8 100644 (file)
@@ -1,5 +1,5 @@
 /* Definitions for getting information about a filesystem.
-   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -29,33 +29,34 @@ __BEGIN_DECLS
 
 /* Return information about the filesystem on which FILE resides.  */
 #ifndef __USE_FILE_OFFSET64
-extern int statfs __P ((__const char *__file, struct statfs *__buf));
+extern int statfs (__const char *__file, struct statfs *__buf) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (statfs, __P ((__const char *__file,
-                                    struct statfs *__buf)), statfs64);
+extern int __REDIRECT (statfs,
+                      (__const char *__file, struct statfs *__buf) __THROW,
+                      statfs64);
 # else
 #  define statfs statfs64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int statfs64 __P ((__const char *__file, struct statfs64 *__buf));
+extern int statfs64 (__const char *__file, struct statfs64 *__buf) __THROW;
 #endif
 
 /* Return information about the filesystem containing the file FILDES
    refers to.  */
 #ifndef __USE_FILE_OFFSET64
-extern int fstatfs __P ((int __fildes, struct statfs *__buf));
+extern int fstatfs (int __fildes, struct statfs *__buf) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (fstatfs, __P ((int __fildes, struct statfs *__buf)),
+extern int __REDIRECT (fstatfs, (int __fildes, struct statfs *__buf) __THROW,
                       fstatfs64);
 # else
 #  define fstatfs fstatfs64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int fstatfs64 __P ((int __fildes, struct statfs64 *__buf));
+extern int fstatfs64 (int __fildes, struct statfs64 *__buf) __THROW;
 #endif
 
 __END_DECLS
index 31d60df..6f497cc 100644 (file)
@@ -1,5 +1,5 @@
 /* Definitions for getting information about a filesystem.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -29,34 +29,34 @@ __BEGIN_DECLS
 
 /* Return information about the filesystem on which FILE resides.  */
 #ifndef __USE_FILE_OFFSET64
-extern int statvfs __P ((__const char *__file, struct statvfs *__buf));
+extern int statvfs (__const char *__file, struct statvfs *__buf) __THROW;
 #else
 # ifdef __REDIRECT
 extern int __REDIRECT (statvfs,
-                      __P ((__const char *__file, struct statvfs *__buf)),
+                      (__const char *__file, struct statvfs *__buf) __THROW,
                       statvfs64);
 # else
 #  define statvfs statvfs64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int statvfs64 __P ((__const char *__file, struct statvfs64 *__buf));
+extern int statvfs64 (__const char *__file, struct statvfs64 *__buf) __THROW;
 #endif
 
 /* Return information about the filesystem containing the file FILDES
    refers to.  */
 #ifndef __USE_FILE_OFFSET64
-extern int fstatvfs __P ((int __fildes, struct statvfs *__buf));
+extern int fstatvfs (int __fildes, struct statvfs *__buf) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (fstatvfs, __P ((int __fildes, struct statvfs *__buf)),
+extern int __REDIRECT (fstatvfs, (int __fildes, struct statvfs *__buf) __THROW,
                       fstatvfs64);
 # else
 #  define fstatvfs fstatvfs64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int fstatvfs64 __P ((int __fildes, struct statvfs64 *__buf));
+extern int fstatvfs64 (int __fildes, struct statvfs64 *__buf) __THROW;
 #endif
 
 __END_DECLS
index bc82bca..d86c14c 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -43,8 +43,8 @@ struct utimbuf
 
 /* Set the access and modification times of FILE to those given in
    *FILE_TIMES.  If FILE_TIMES is NULL, set them to the current time.  */
-extern int utime __P ((__const char *__file,
-                      __const struct utimbuf *__file_times));
+extern int utime (__const char *__file,
+                 __const struct utimbuf *__file_times) __THROW;
 
 __END_DECLS
 
index 9c65a02..c8f93ac 100644 (file)
@@ -201,26 +201,26 @@ enum __codecvt_result
    of the virtual functions in the libstdc++ codecvt class.  */
 struct _IO_codecvt
 {
-  void (*__codecvt_destr) __PMT ((struct _IO_codecvt *));
-  enum __codecvt_result (*__codecvt_do_out) __PMT ((struct _IO_codecvt *,
-                                                   __mbstate_t *,
-                                                   const wchar_t *,
-                                                   const wchar_t *,
-                                                   const wchar_t **, char *,
-                                                   char *, char **));
-  enum __codecvt_result (*__codecvt_do_unshift) __PMT ((struct _IO_codecvt *,
-                                                       __mbstate_t *, char *,
-                                                       char *, char **));
-  enum __codecvt_result (*__codecvt_do_in) __PMT ((struct _IO_codecvt *,
-                                                  __mbstate_t *,
-                                                  const char *, const char *,
-                                                  const char **, wchar_t *,
-                                                  wchar_t *, wchar_t **));
-  int (*__codecvt_do_encoding) __PMT ((struct _IO_codecvt *));
-  int (*__codecvt_do_always_noconv) __PMT ((struct _IO_codecvt *));
-  int (*__codecvt_do_length) __PMT ((struct _IO_codecvt *, __mbstate_t *,
-                                    const char *, const char *, _IO_size_t));
-  int (*__codecvt_do_max_length) __PMT ((struct _IO_codecvt *));
+  void (*__codecvt_destr) (struct _IO_codecvt *);
+  enum __codecvt_result (*__codecvt_do_out) (struct _IO_codecvt *,
+                                            __mbstate_t *,
+                                            const wchar_t *,
+                                            const wchar_t *,
+                                            const wchar_t **, char *,
+                                            char *, char **);
+  enum __codecvt_result (*__codecvt_do_unshift) (struct _IO_codecvt *,
+                                                __mbstate_t *, char *,
+                                                char *, char **);
+  enum __codecvt_result (*__codecvt_do_in) (struct _IO_codecvt *,
+                                           __mbstate_t *,
+                                           const char *, const char *,
+                                           const char **, wchar_t *,
+                                           wchar_t *, wchar_t **);
+  int (*__codecvt_do_encoding) (struct _IO_codecvt *);
+  int (*__codecvt_do_always_noconv) (struct _IO_codecvt *);
+  int (*__codecvt_do_length) (struct _IO_codecvt *, __mbstate_t *,
+                             const char *, const char *, _IO_size_t);
+  int (*__codecvt_do_max_length) (struct _IO_codecvt *);
 
   _IO_iconv_t __cd_in;
   _IO_iconv_t __cd_out;
@@ -329,8 +329,7 @@ extern _IO_FILE *_IO_stderr;
 
 /* Read NBYTES bytes from COOKIE into a buffer pointed to by BUF.
    Return number of bytes read.  */
-typedef __ssize_t __io_read_fn __PMT ((__ptr_t __cookie, char *__buf,
-                                      size_t __nbytes));
+typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
 
 /* Write N bytes pointed to by BUF to COOKIE.  Write all N bytes
    unless there is an error.  Return number of bytes written, or -1 if
@@ -338,8 +337,8 @@ typedef __ssize_t __io_read_fn __PMT ((__ptr_t __cookie, char *__buf,
    opened for append (__mode.__append set), then set the file pointer
    to the end of the file and then do the write; if not, just write at
    the current file pointer.  */
-typedef __ssize_t __io_write_fn __PMT ((__ptr_t __cookie, __const char *__buf,
-                                     size_t __n));
+typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
+                                size_t __n);
 
 /* Move COOKIE's file position to *POS bytes from the
    beginning of the file (if W is SEEK_SET),
@@ -347,10 +346,10 @@ typedef __ssize_t __io_write_fn __PMT ((__ptr_t __cookie, __const char *__buf,
    or the end of the file (if W is SEEK_END).
    Set *POS to the new file position.
    Returns zero if successful, nonzero if not.  */
-typedef int __io_seek_fn __PMT ((__ptr_t __cookie, _IO_off_t __pos, int __w));
+typedef int __io_seek_fn (void *__cookie, _IO_off_t __pos, int __w);
 
 /* Close COOKIE.  */
-typedef int __io_close_fn __PMT ((__ptr_t __cookie));
+typedef int __io_close_fn (void *__cookie);
 
 
 #ifdef _GNU_SOURCE
@@ -385,12 +384,12 @@ struct _IO_cookie_file
 extern "C" {
 #endif
 
-extern int __underflow __P ((_IO_FILE *));
-extern int __uflow __P ((_IO_FILE *));
-extern int __overflow __P ((_IO_FILE *, int));
-extern _IO_wint_t __wunderflow __P ((_IO_FILE *));
-extern _IO_wint_t __wuflow __P ((_IO_FILE *));
-extern _IO_wint_t __woverflow __P ((_IO_FILE *, _IO_wint_t));
+extern int __underflow (_IO_FILE *) __THROW;
+extern int __uflow (_IO_FILE *) __THROW;
+extern int __overflow (_IO_FILE *, int) __THROW;
+extern _IO_wint_t __wunderflow (_IO_FILE *) __THROW;
+extern _IO_wint_t __wuflow (_IO_FILE *) __THROW;
+extern _IO_wint_t __woverflow (_IO_FILE *, _IO_wint_t) __THROW;
 
 #define _IO_getc_unlocked(_fp) \
        ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end ? __uflow (_fp) \
@@ -415,16 +414,16 @@ extern _IO_wint_t __woverflow __P ((_IO_FILE *, _IO_wint_t));
 #define _IO_feof_unlocked(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
 #define _IO_ferror_unlocked(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
 
-extern int _IO_getc __P ((_IO_FILE *__fp));
-extern int _IO_putc __P ((int __c, _IO_FILE *__fp));
-extern _IO_wint_t _IO_getwc __P ((_IO_FILE *__fp));
-extern _IO_wint_t _IO_putwc __P ((wchar_t __wc, _IO_FILE *__fp));
-extern int _IO_feof __P ((_IO_FILE *__fp));
-extern int _IO_ferror __P ((_IO_FILE *__fp));
+extern int _IO_getc (_IO_FILE *__fp) __THROW;
+extern int _IO_putc (int __c, _IO_FILE *__fp) __THROW;
+extern _IO_wint_t _IO_getwc (_IO_FILE *__fp) __THROW;
+extern _IO_wint_t _IO_putwc (wchar_t __wc, _IO_FILE *__fp) __THROW;
+extern int _IO_feof (_IO_FILE *__fp) __THROW;
+extern int _IO_ferror (_IO_FILE *__fp) __THROW;
 
-extern int _IO_peekc_locked __P ((_IO_FILE *__fp));
+extern int _IO_peekc_locked (_IO_FILE *__fp) __THROW;
 
-extern int _IO_fwide __P ((_IO_FILE *__fp, int __mode));
+extern int _IO_fwide (_IO_FILE *__fp, int __mode) __THROW;
 #if __GNUC__ >= 2
 /* A special optimized version of the function above.  It optimizes the
    case of initializing an unoriented byte stream.  */
@@ -446,9 +445,9 @@ extern int _IO_fwide __P ((_IO_FILE *__fp, int __mode));
 #define _IO_PENDING_OUTPUT_COUNT(_fp)  \
        ((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
 
-extern void _IO_flockfile __P ((_IO_FILE *));
-extern void _IO_funlockfile __P ((_IO_FILE *));
-extern int _IO_ftrylockfile __P ((_IO_FILE *));
+extern void _IO_flockfile (_IO_FILE *) __THROW;
+extern void _IO_funlockfile (_IO_FILE *) __THROW;
+extern int _IO_ftrylockfile (_IO_FILE *) __THROW;
 
 #ifdef _IO_MTSAFE_IO
 # define _IO_peekc(_fp) _IO_peekc_locked (_fp)
@@ -461,24 +460,23 @@ extern int _IO_ftrylockfile __P ((_IO_FILE *));
 # define _IO_cleanup_region_end(_Doit) /**/
 #endif /* !_IO_MTSAFE_IO */
 
-extern int _IO_vfscanf __P ((_IO_FILE * __restrict, const char * __restrict,
-                            _IO_va_list, int *__restrict));
-extern int _IO_vfwscanf __P ((_IO_FILE * __restrict,
-                             const wchar_t * __restrict,
-                             _IO_va_list, int *__restrict));
-extern int _IO_vfprintf __P ((_IO_FILE *__restrict, const char *__restrict,
-                             _IO_va_list));
-extern int _IO_vfwprintf __P ((_IO_FILE *__restrict, const wchar_t *__restrict,
-                              _IO_va_list));
-extern _IO_ssize_t _IO_padn __P ((_IO_FILE *, int, _IO_ssize_t));
-extern _IO_ssize_t _IO_wpadn __P ((_IO_FILE *, wint_t, _IO_ssize_t));
-extern _IO_size_t _IO_sgetn __P ((_IO_FILE *, void *, _IO_size_t));
-
-extern _IO_off64_t _IO_seekoff __P ((_IO_FILE *, _IO_off64_t, int, int));
-extern _IO_off64_t _IO_seekpos __P ((_IO_FILE *, _IO_off64_t, int));
-
-extern void _IO_free_backup_area __P ((_IO_FILE *));
-extern void _IO_free_wbackup_area __P ((_IO_FILE *));
+extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
+                       _IO_va_list, int *__restrict) __THROW;
+extern int _IO_vfwscanf (_IO_FILE * __restrict, const wchar_t * __restrict,
+                        _IO_va_list, int *__restrict) __THROW;
+extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
+                        _IO_va_list) __THROW;
+extern int _IO_vfwprintf (_IO_FILE *__restrict, const wchar_t *__restrict,
+                         _IO_va_list) __THROW;
+extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t) __THROW;
+extern _IO_ssize_t _IO_wpadn (_IO_FILE *, wint_t, _IO_ssize_t) __THROW;
+extern _IO_size_t _IO_sgetn (_IO_FILE *, void *, _IO_size_t) __THROW;
+
+extern _IO_off64_t _IO_seekoff (_IO_FILE *, _IO_off64_t, int, int) __THROW;
+extern _IO_off64_t _IO_seekpos (_IO_FILE *, _IO_off64_t, int) __THROW;
+
+extern void _IO_free_backup_area (_IO_FILE *) __THROW;
+extern void _IO_free_wbackup_area (_IO_FILE *) __THROW;
 
 #ifdef __cplusplus
 }
index 7b64903..128713b 100644 (file)
@@ -120,31 +120,31 @@ extern FILE *stderr;              /* Standard error output stream.  */
 #define stderr stderr
 
 /* Remove file FILENAME.  */
-extern int remove __P ((__const char *__filename));
+extern int remove (__const char *__filename) __THROW;
 /* Rename file OLD to NEW.  */
-extern int rename __P ((__const char *__old, __const char *__new));
+extern int rename (__const char *__old, __const char *__new) __THROW;
 
 
 /* Create a temporary file and open it read/write.  */
 #ifndef __USE_FILE_OFFSET64
-extern FILE *tmpfile __P ((void));
+extern FILE *tmpfile (void) __THROW;
 #else
 # ifdef __REDIRECT
-extern FILE *__REDIRECT (tmpfile, __P ((void)), tmpfile64);
+extern FILE *__REDIRECT (tmpfile, (void) __THROW, tmpfile64);
 # else
 #  define tmpfile tmpfile64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern FILE *tmpfile64 __P ((void));
+extern FILE *tmpfile64 (void) __THROW;
 #endif
 /* Generate a temporary filename.  */
-extern char *tmpnam __P ((char *__s));
+extern char *tmpnam (char *__s) __THROW;
 
 #ifdef __USE_MISC
 /* This is the reentrant variant of `tmpnam'.  The only difference is
    that it does not allow S to be NULL.  */
-extern char *tmpnam_r __P ((char *__s));
+extern char *tmpnam_r (char *__s) __THROW;
 #endif
 
 
@@ -156,42 +156,42 @@ extern char *tmpnam_r __P ((char *__s));
    If not and if DIR is not NULL, that value is checked.  If that fails,
    P_tmpdir is tried and finally "/tmp".  The storage for the filename
    is allocated by `malloc'.  */
-extern char *tempnam __P ((__const char *__dir, __const char *__pfx));
+extern char *tempnam (__const char *__dir, __const char *__pfx) __THROW;
 #endif
 
 
 /* Close STREAM.  */
-extern int fclose __P ((FILE *__stream));
+extern int fclose (FILE *__stream) __THROW;
 /* Flush STREAM, or all streams if STREAM is NULL.  */
-extern int fflush __P ((FILE *__stream));
+extern int fflush (FILE *__stream) __THROW;
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not required.  */
-extern int fflush_unlocked __P ((FILE *__stream));
+extern int fflush_unlocked (FILE *__stream) __THROW;
 #endif
 
 #ifdef __USE_GNU
 /* Close all streams.  */
-extern int fcloseall __P ((void));
+extern int fcloseall (void) __THROW;
 #endif
 
 
 #ifndef __USE_FILE_OFFSET64
 /* Open a file and create a new stream for it.  */
-extern FILE *fopen __P ((__const char *__restrict __filename,
-                        __const char *__restrict __modes));
+extern FILE *fopen (__const char *__restrict __filename,
+                   __const char *__restrict __modes) __THROW;
 /* Open a file, replacing an existing stream with it. */
-extern FILE *freopen __P ((__const char *__restrict __filename,
-                          __const char *__restrict __modes,
-                          FILE *__restrict __stream));
+extern FILE *freopen (__const char *__restrict __filename,
+                     __const char *__restrict __modes,
+                     FILE *__restrict __stream) __THROW;
 #else
 # ifdef __REDIRECT
-extern FILE *__REDIRECT (fopen, __P ((__const char *__restrict __filename,
-                                  __const char *__restrict __modes)),
+extern FILE *__REDIRECT (fopen, (__const char *__restrict __filename,
+                                __const char *__restrict __modes) __THROW,
                         fopen64);
-extern FILE *__REDIRECT (freopen, __P ((__const char *__restrict __filename,
-                                       __const char *__restrict __modes,
-                                       FILE *__restrict __stream)),
+extern FILE *__REDIRECT (freopen, (__const char *__restrict __filename,
+                                  __const char *__restrict __modes,
+                                  FILE *__restrict __stream) __THROW,
                         freopen64);
 # else
 #  define fopen fopen64
@@ -199,146 +199,140 @@ extern FILE *__REDIRECT (freopen, __P ((__const char *__restrict __filename,
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern FILE *fopen64 __P ((__const char *__restrict __filename,
-                          __const char *__restrict __modes));
-extern FILE *freopen64 __P ((__const char *__restrict __filename,
-                            __const char *__restrict __modes,
-                            FILE *__restrict __stream));
+extern FILE *fopen64 (__const char *__restrict __filename,
+                     __const char *__restrict __modes) __THROW;
+extern FILE *freopen64 (__const char *__restrict __filename,
+                       __const char *__restrict __modes,
+                       FILE *__restrict __stream) __THROW;
 #endif
 
 #ifdef __USE_POSIX
 /* Create a new stream that refers to an existing system file descriptor.  */
-extern FILE *fdopen __P ((int __fd, __const char *__modes));
+extern FILE *fdopen (int __fd, __const char *__modes) __THROW;
 #endif
 
 #ifdef __USE_GNU
 /* Create a new stream that refers to the given magic cookie,
    and uses the given functions for input and output.  */
-extern FILE *fopencookie __P ((void *__restrict __magic_cookie,
-                              __const char *__restrict __modes,
-                              _IO_cookie_io_functions_t __io_funcs));
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+                         __const char *__restrict __modes,
+                         _IO_cookie_io_functions_t __io_funcs) __THROW;
 
 /* Open a stream that writes into a malloc'd buffer that is expanded as
    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
    and the number of characters written on fflush or fclose.  */
-extern FILE *open_memstream __P ((char **__restrict __bufloc,
-                                 size_t *__restrict __sizeloc));
+extern FILE *open_memstream (char **__restrict __bufloc,
+                            size_t *__restrict __sizeloc) __THROW;
 #endif
 
 
 /* If BUF is NULL, make STREAM unbuffered.
    Else make it use buffer BUF, of size BUFSIZ.  */
-extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __THROW;
 /* Make STREAM use buffering mode MODE.
    If BUF is not NULL, use N bytes of it for buffering;
    else allocate an internal buffer N bytes long.  */
-extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
-                        int __modes, size_t __n));
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+                   int __modes, size_t __n) __THROW;
 
 #ifdef __USE_BSD
 /* If BUF is NULL, make STREAM unbuffered.
    Else make it use SIZE bytes of BUF for buffering.  */
-extern void setbuffer __P ((FILE *__restrict __stream, char *__restrict __buf,
-                           size_t __size));
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+                      size_t __size) __THROW;
 
 /* Make STREAM line-buffered.  */
-extern void setlinebuf __P ((FILE *__stream));
+extern void setlinebuf (FILE *__stream) __THROW;
 #endif
 
 
 /* Write formatted output to STREAM.  */
-extern int fprintf __P ((FILE *__restrict __stream,
-                        __const char *__restrict __format, ...));
+extern int fprintf (FILE *__restrict __stream,
+                   __const char *__restrict __format, ...) __THROW;
 /* Write formatted output to stdout.  */
-extern int printf __P ((__const char *__restrict __format, ...));
+extern int printf (__const char *__restrict __format, ...) __THROW;
 /* Write formatted output to S.  */
-extern int sprintf __P ((char *__restrict __s,
-                        __const char *__restrict __format, ...));
+extern int sprintf (char *__restrict __s,
+                   __const char *__restrict __format, ...) __THROW;
 
 /* Write formatted output to S from argument list ARG.  */
-extern int vfprintf __P ((FILE *__restrict __s,
-                         __const char *__restrict __format,
-                         _G_va_list __arg));
+extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
+                    _G_va_list __arg) __THROW;
 /* Write formatted output to stdout from argument list ARG.  */
-extern int vprintf __P ((__const char *__restrict __format,
-                        _G_va_list __arg));
+extern int vprintf (__const char *__restrict __format, _G_va_list __arg)
+     __THROW;
 /* Write formatted output to S from argument list ARG.  */
-extern int vsprintf __P ((char *__restrict __s,
-                         __const char *__restrict __format,
-                         _G_va_list __arg));
+extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
+                    _G_va_list __arg) __THROW;
 
 #if defined __USE_BSD || defined __USE_ISOC9X || defined __USE_UNIX98
 /* Maximum chars of output to write in MAXLEN.  */
-extern int snprintf __P ((char *__restrict __s, size_t __maxlen,
-                         __const char *__restrict __format, ...))
-     __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+                    __const char *__restrict __format, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 4)));
 
-extern int __vsnprintf __P ((char *__restrict __s, size_t __maxlen,
-                            __const char *__restrict __format,
-                            _G_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 3, 0)));
-extern int vsnprintf __P ((char *__restrict __s, size_t __maxlen,
-                          __const char *__restrict __format,
-                          _G_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int __vsnprintf (char *__restrict __s, size_t __maxlen,
+                       __const char *__restrict __format, _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+                     __const char *__restrict __format, _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 0)));
 #endif
 
 #ifdef __USE_GNU
 /* Write formatted output to a string dynamically allocated with `malloc'.
    Store the address of the string in *PTR.  */
-extern int vasprintf __P ((char **__restrict __ptr,
-                          __const char *__restrict __f, _G_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int __asprintf __P ((char **__restrict __ptr,
-                           __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
-extern int asprintf __P ((char **__restrict __ptr,
-                         __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
+                     _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int __asprintf (char **__restrict __ptr,
+                      __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int asprintf (char **__restrict __ptr,
+                    __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
 
 /* Write formatted output to a file descriptor.  */
-extern int vdprintf __P ((int __fd, __const char *__restrict __fmt,
-                         _G_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int dprintf __P ((int __fd, __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int vdprintf (int __fd, __const char *__restrict __fmt,
+                    _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
 #endif
 
 
 /* Read formatted input from STREAM.  */
-extern int fscanf __P ((FILE *__restrict __stream,
-                       __const char *__restrict __format, ...));
+extern int fscanf (FILE *__restrict __stream,
+                  __const char *__restrict __format, ...) __THROW;
 /* Read formatted input from stdin.  */
-extern int scanf __P ((__const char *__restrict __format, ...));
+extern int scanf (__const char *__restrict __format, ...) __THROW;
 /* Read formatted input from S.  */
-extern int sscanf __P ((__const char *__restrict __s,
-                       __const char *__restrict __format, ...));
+extern int sscanf (__const char *__restrict __s,
+                  __const char *__restrict __format, ...) __THROW;
 
 #ifdef __USE_ISOC9X
 /* Read formatted input from S into argument list ARG.  */
-extern int vfscanf __P ((FILE *__restrict __s,
-                        __const char *__restrict __format,
-                        _G_va_list __arg))
-     __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
+                   _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__scanf__, 2, 0)));
 
 /* Read formatted input from stdin into argument list ARG.  */
-extern int vscanf __P ((__const char *__restrict __format, _G_va_list __arg))
-     __attribute__ ((__format__ (__scanf__, 1, 0)));
+extern int vscanf (__const char *__restrict __format, _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__scanf__, 1, 0)));
 
 /* Read formatted input from S into argument list ARG.  */
-extern int vsscanf __P ((__const char *__restrict __s,
-                        __const char *__restrict __format,
-                        _G_va_list __arg))
-     __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int vsscanf (__const char *__restrict __s,
+                   __const char *__restrict __format, _G_va_list __arg)
+     __THROW __attribute__ ((__format__ (__scanf__, 2, 0)));
 #endif /* Use ISO C9x.  */
 
 
 /* Read a character from STREAM.  */
-extern int fgetc __P ((FILE *__stream));
-extern int getc __P ((FILE *__stream));
+extern int fgetc (FILE *__stream) __THROW;
+extern int getc (FILE *__stream) __THROW;
 
 /* Read a character from stdin.  */
-extern int getchar __P ((void));
+extern int getchar (void) __THROW;
 
 /* The C standard explicitly says this is a macro, so we always do the
    optimization for it.  */
@@ -346,22 +340,22 @@ extern int getchar __P ((void));
 
 #if defined __USE_POSIX || defined __USE_MISC
 /* These are defined in POSIX.1:1996.  */
-extern int getc_unlocked __P ((FILE *__stream));
-extern int getchar_unlocked __P ((void));
+extern int getc_unlocked (FILE *__stream) __THROW;
+extern int getchar_unlocked (void) __THROW;
 #endif /* Use POSIX or MISC.  */
 
 #ifdef __USE_MISC
 /* Faster version when locking is not necessary.  */
-extern int fgetc_unlocked __P ((FILE *__stream));
+extern int fgetc_unlocked (FILE *__stream) __THROW;
 #endif /* Use MISC.  */
 
 
 /* Write a character to STREAM.  */
-extern int fputc __P ((int __c, FILE *__stream));
-extern int putc __P ((int __c, FILE *__stream));
+extern int fputc (int __c, FILE *__stream) __THROW;
+extern int putc (int __c, FILE *__stream) __THROW;
 
 /* Write a character to stdout.  */
-extern int putchar __P ((int __c));
+extern int putchar (int __c) __THROW;
 
 /* The C standard explicitly says this can be a macro,
    so we always do the optimization for it.  */
@@ -369,38 +363,38 @@ extern int putchar __P ((int __c));
 
 #ifdef __USE_MISC
 /* Faster version when locking is not necessary.  */
-extern int fputc_unlocked __P ((int __c, FILE *__stream));
+extern int fputc_unlocked (int __c, FILE *__stream) __THROW;
 #endif /* Use MISC.  */
 
 #if defined __USE_POSIX || defined __USE_MISC
 /* These are defined in POSIX.1:1996.  */
-extern int putc_unlocked __P ((int __c, FILE *__stream));
-extern int putchar_unlocked __P ((int __c));
+extern int putc_unlocked (int __c, FILE *__stream) __THROW;
+extern int putchar_unlocked (int __c) __THROW;
 #endif /* Use POSIX or MISC.  */
 
 
 #if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
 /* Get a word (int) from STREAM.  */
-extern int getw __P ((FILE *__stream));
+extern int getw (FILE *__stream) __THROW;
 
 /* Write a word (int) to STREAM.  */
-extern int putw __P ((int __w, FILE *__stream));
+extern int putw (int __w, FILE *__stream) __THROW;
 #endif
 
 
 /* Get a newline-terminated string of finite length from STREAM.  */
-extern char *fgets __P ((char *__restrict __s, int __n,
-                        FILE *__restrict __stream));
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __THROW;
 
 #ifdef __USE_GNU
 /* This function does the same as `fgets' but does not lock the stream.  */
-extern char *fgets_unlocked __P ((char *__restrict __s, int __n,
-                                 FILE *__restrict __stream));
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+                            FILE *__restrict __stream) __THROW;
 #endif
 
 /* Get a newline-terminated string from stdin, removing the newline.
    DO NOT USE THIS FUNCTION!!  There is no limit on how much it will read.  */
-extern char *gets __P ((char *__s));
+extern char *gets (char *__s) __THROW;
 
 
 #ifdef __USE_GNU
@@ -409,61 +403,60 @@ extern char *gets __P ((char *__s));
    NULL), pointing to *N characters of space.  It is realloc'd as
    necessary.  Returns the number of characters read (not including the
    null terminator), or -1 on error or EOF.  */
-extern _IO_ssize_t __getdelim __P ((char **__restrict __lineptr,
-                                   size_t *__restrict __n, int __delimiter,
-                                   FILE *__restrict __stream));
-extern _IO_ssize_t getdelim __P ((char **__restrict __lineptr,
-                                 size_t *__restrict __n, int __delimiter,
-                                 FILE *__restrict __stream));
+extern _IO_ssize_t __getdelim (char **__restrict __lineptr,
+                              size_t *__restrict __n, int __delimiter,
+                              FILE *__restrict __stream) __THROW;
+extern _IO_ssize_t getdelim (char **__restrict __lineptr,
+                            size_t *__restrict __n, int __delimiter,
+                            FILE *__restrict __stream) __THROW;
 
 /* Like `getdelim', but reads up to a newline.  */
-extern _IO_ssize_t getline __P ((char **__restrict __lineptr,
-                                size_t *__restrict __n,
-                                FILE *__restrict __stream));
+extern _IO_ssize_t getline (char **__restrict __lineptr,
+                           size_t *__restrict __n,
+                           FILE *__restrict __stream) __THROW;
 #endif
 
 
 /* Write a string to STREAM.  */
-extern int fputs __P ((__const char *__restrict __s,
-                      FILE *__restrict __stream));
+extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
+     __THROW;
 
 #ifdef __USE_GNU
 /* This function does the same as `fputs' but does not lock the stream.  */
-extern int fputs_unlocked __P ((__const char *__restrict __s,
-                               FILE *__restrict __stream));
+extern int fputs_unlocked (__const char *__restrict __s,
+                          FILE *__restrict __stream) __THROW;
 #endif
 
 /* Write a string, followed by a newline, to stdout.  */
-extern int puts __P ((__const char *__s));
+extern int puts (__const char *__s) __THROW;
 
 
 /* Push a character back onto the input buffer of STREAM.  */
-extern int ungetc __P ((int __c, FILE *__stream));
+extern int ungetc (int __c, FILE *__stream) __THROW;
 
 
 /* Read chunks of generic data from STREAM.  */
-extern size_t fread __P ((void *__restrict __ptr, size_t __size,
-                         size_t __n, FILE *__restrict __stream));
+extern size_t fread (void *__restrict __ptr, size_t __size,
+                    size_t __n, FILE *__restrict __stream) __THROW;
 /* Write chunks of generic data to STREAM.  */
-extern size_t fwrite __P ((__const void *__restrict __ptr, size_t __size,
-                          size_t __n, FILE *__restrict __s));
+extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
+                     size_t __n, FILE *__restrict __s) __THROW;
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not necessary.  */
-extern size_t fread_unlocked __P ((void *__restrict __ptr, size_t __size,
-                                  size_t __n, FILE *__restrict __stream));
-extern size_t fwrite_unlocked __P ((__const void *__restrict __ptr,
-                                   size_t __size, size_t __n,
-                                   FILE *__restrict __stream));
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+                             size_t __n, FILE *__restrict __stream) __THROW;
+extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
+                              size_t __n, FILE *__restrict __stream) __THROW;
 #endif
 
 
 /* Seek to a certain position on STREAM.  */
-extern int fseek __P ((FILE *__stream, long int __off, int __whence));
+extern int fseek (FILE *__stream, long int __off, int __whence) __THROW;
 /* Return the current position of STREAM.  */
-extern long int ftell __P ((FILE *__stream));
+extern long int ftell (FILE *__stream) __THROW;
 /* Rewind to the beginning of STREAM.  */
-extern void rewind __P ((FILE *__stream));
+extern void rewind (FILE *__stream) __THROW;
 
 /* The Single Unix Specification, Version 2, specifies an alternative,
    more adequate interface for the two functions above which deal with
@@ -489,27 +482,28 @@ typedef __off64_t off64_t;
 #ifndef __USE_FILE_OFFSET64
 # ifdef __USE_UNIX98
 /* Seek to a certain position on STREAM.  */
-extern int fseeko __P ((FILE *__stream, __off_t __off, int __whence));
+extern int fseeko (FILE *__stream, __off_t __off, int __whence) __THROW;
 /* Return the current position of STREAM.  */
-extern __off_t ftello __P ((FILE *__stream));
+extern __off_t ftello (FILE *__stream) __THROW;
 # endif
 
 /* Get STREAM's position.  */
-extern int fgetpos __P ((FILE *__restrict __stream,
-                        fpos_t *__restrict __pos));
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos)
+     __THROW;
 /* Set STREAM's position.  */
-extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
+extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __THROW;
 #else
 # ifdef __REDIRECT
 #  ifdef __USE_UNIX98
 extern int __REDIRECT (fseeko,
-                      __P ((FILE *__stream, __off64_t __off, int __whence)),
+                      (FILE *__stream, __off64_t __off, int __whence) __THROW,
                       fseeko64);
-extern __off64_t __REDIRECT (ftello, __P ((FILE *__stream)), ftello64);
+extern __off64_t __REDIRECT (ftello, (FILE *__stream) __THROW, ftello64);
 #  endif
-extern int __REDIRECT (fgetpos, __P ((FILE *__restrict __stream,
-                                     fpos_t *__restrict __pos)), fgetpos64);
-extern int __REDIRECT (fsetpos, __P ((FILE *__stream, __const fpos_t *__pos)),
+extern int __REDIRECT (fgetpos, (FILE *__restrict __stream,
+                                fpos_t *__restrict __pos) __THROW, fgetpos64);
+extern int __REDIRECT (fsetpos,
+                      (FILE *__stream, __const fpos_t *__pos) __THROW,
                       fsetpos64);
 # else
 #  ifdef __USE_UNIX98
@@ -523,31 +517,31 @@ extern int __REDIRECT (fsetpos, __P ((FILE *__stream, __const fpos_t *__pos)),
 
 #ifdef __USE_LARGEFILE64
 # ifdef __USE_UNIX98
-extern int fseeko64 __P ((FILE *__stream, __off64_t __off, int __whence));
-extern __off64_t ftello64 __P ((FILE *__stream));
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) __THROW;
+extern __off64_t ftello64 (FILE *__stream) __THROW;
 # endif
-extern int fgetpos64 __P ((FILE *__restrict __stream,
-                          fpos64_t *__restrict __pos));
-extern int fsetpos64 __P ((FILE *__stream, __const fpos64_t *__pos));
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos)
+     __THROW;
+extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos) __THROW;
 #endif
 
 /* Clear the error and EOF indicators for STREAM.  */
-extern void clearerr __P ((FILE *__stream));
+extern void clearerr (FILE *__stream) __THROW;
 /* Return the EOF indicator for STREAM.  */
-extern int feof __P ((FILE *__stream));
+extern int feof (FILE *__stream) __THROW;
 /* Return the error indicator for STREAM.  */
-extern int ferror __P ((FILE *__stream));
+extern int ferror (FILE *__stream) __THROW;
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not required.  */
-extern void clearerr_unlocked __P ((FILE *__stream));
-extern int feof_unlocked __P ((FILE *__stream));
-extern int ferror_unlocked __P ((FILE *__stream));
+extern void clearerr_unlocked (FILE *__stream) __THROW;
+extern int feof_unlocked (FILE *__stream) __THROW;
+extern int ferror_unlocked (FILE *__stream) __THROW;
 #endif
 
 
 /* Print a message describing the meaning of the value of errno.  */
-extern void perror __P ((__const char *__s));
+extern void perror (__const char *__s) __THROW;
 
 /* These variables normally should not be used directly.  The `strerror'
    function provides all the needed functionality.  */
@@ -563,34 +557,34 @@ extern __const char *__const _sys_errlist[];
 
 #ifdef __USE_POSIX
 /* Return the system file descriptor for STREAM.  */
-extern int fileno __P ((FILE *__stream));
+extern int fileno (FILE *__stream) __THROW;
 #endif /* Use POSIX.  */
 
 #ifdef __USE_MISC
 /* Faster version when locking is not required.  */
-extern int fileno_unlocked __P ((FILE *__stream));
+extern int fileno_unlocked (FILE *__stream) __THROW;
 #endif
 
 
 #if (defined __USE_POSIX2 || defined __USE_SVID  || defined __USE_BSD || \
      defined __USE_MISC)
 /* Create a new stream connected to a pipe running the given command.  */
-extern FILE *popen __P ((__const char *__command, __const char *__modes));
+extern FILE *popen (__const char *__command, __const char *__modes) __THROW;
 
 /* Close a stream opened by popen and return the status of its child.  */
-extern int pclose __P ((FILE *__stream));
+extern int pclose (FILE *__stream) __THROW;
 #endif
 
 
 #ifdef __USE_POSIX
 /* Return the name of the controlling terminal.  */
-extern char *ctermid __P ((char *__s));
+extern char *ctermid (char *__s) __THROW;
 #endif /* Use POSIX.  */
 
 
 #if defined __USE_XOPEN && !defined __USE_XOPEN2K
 /* Return the name of the current user.  */
-extern char *cuserid __P ((char *__s));
+extern char *cuserid (char *__s) __THROW;
 #endif /* Use X/Open, but not issue 6.  */
 
 
@@ -598,11 +592,11 @@ extern char *cuserid __P ((char *__s));
 struct obstack;                        /* See <obstack.h>.  */
 
 /* Write formatted output to an obstack.  */
-extern int obstack_printf __P ((struct obstack *__restrict __obstack,
-                               __const char *__restrict __format, ...));
-extern int obstack_vprintf __P ((struct obstack *__restrict __obstack,
-                                __const char *__restrict __format,
-                                _G_va_list __args));
+extern int obstack_printf (struct obstack *__restrict __obstack,
+                          __const char *__restrict __format, ...) __THROW;
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+                           __const char *__restrict __format,
+                           _G_va_list __args) __THROW;
 #endif /* Use GNU.  */
 
 
@@ -610,14 +604,14 @@ extern int obstack_vprintf __P ((struct obstack *__restrict __obstack,
 /* These are defined in POSIX.1:1996.  */
 
 /* Acquire ownership of STREAM.  */
-extern void flockfile __P ((FILE *__stream));
+extern void flockfile (FILE *__stream) __THROW;
 
 /* Try to acquire ownership of STREAM but do not block if it is not
    possible.  */
-extern int ftrylockfile __P ((FILE *__stream));
+extern int ftrylockfile (FILE *__stream) __THROW;
 
 /* Relinquish the ownership granted for STREAM.  */
-extern void funlockfile __P ((FILE *__stream));
+extern void funlockfile (FILE *__stream) __THROW;
 #endif /* POSIX || misc */
 
 #if defined __USE_XOPEN && !defined __USE_XOPEN2K && !defined __USE_GNU
index 4861951..21093f9 100644 (file)
@@ -107,7 +107,7 @@ enum
 
 struct _pthread_cleanup_buffer
 {
-  void (*__routine) __PMT ((void *));    /* Function to call.  */
+  void (*__routine) (void *);            /* Function to call.  */
   void *__arg;                           /* Its argument.  */
   int __canceltype;                      /* Saved cancellation type. */
   struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions.  */
@@ -137,30 +137,31 @@ enum
 /* Create a thread with given attributes ATTR (or default attributes
    if ATTR is NULL), and call function START_ROUTINE with given
    arguments ARG.  */
-extern int pthread_create __P ((pthread_t *__thread,
-                               __const pthread_attr_t *__attr,
-                               void *(*__start_routine) (void *),
-                               void *__arg));
+extern int pthread_create (pthread_t *__thread,
+                          __const pthread_attr_t *__attr,
+                          void *(*__start_routine) (void *),
+                          void *__arg) __THROW;
 
 /* Obtain the identifier of the current thread.  */
-extern pthread_t pthread_self __P ((void));
+extern pthread_t pthread_self (void) __THROW;
 
 /* Compare two thread identifiers.  */
-extern int pthread_equal __P ((pthread_t __thread1, pthread_t __thread2));
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) __THROW;
 
 /* Terminate calling thread.  */
-extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
+extern void pthread_exit (void *__retval)
+     __THROW __attribute__ ((__noreturn__));
 
 /* Make calling thread wait for termination of the thread TH.  The
    exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
    is not NULL.  */
-extern int pthread_join __P ((pthread_t __th, void **__thread_return));
+extern int pthread_join (pthread_t __th, void **__thread_return) __THROW;
 
 /* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
    The resources of TH will therefore be freed immediately when it
    terminates, instead of waiting for another thread to perform PTHREAD_JOIN
    on it. */
-extern int pthread_detach __P ((pthread_t __th));
+extern int pthread_detach (pthread_t __th) __THROW;
 
 
 /* Functions for handling attributes.  */
@@ -168,150 +169,154 @@ extern int pthread_detach __P ((pthread_t __th));
 /* Initialize thread attribute *ATTR with default attributes
    (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER,
     no user-provided stack).  */
-extern int pthread_attr_init __P ((pthread_attr_t *__attr));
+extern int pthread_attr_init (pthread_attr_t *__attr) __THROW;
 
 /* Destroy thread attribute *ATTR.  */
-extern int pthread_attr_destroy __P ((pthread_attr_t *__attr));
+extern int pthread_attr_destroy (pthread_attr_t *__attr) __THROW;
 
 /* Set the `detachstate' attribute in *ATTR according to DETACHSTATE.  */
-extern int pthread_attr_setdetachstate __P ((pthread_attr_t *__attr,
-                                            int __detachstate));
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+                                       int __detachstate) __THROW;
 
 /* Return in *DETACHSTATE the `detachstate' attribute in *ATTR.  */
-extern int pthread_attr_getdetachstate __P ((__const pthread_attr_t *__attr,
-                                            int *__detachstate));
+extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
+                                       int *__detachstate) __THROW;
 
 /* Set scheduling parameters (priority, etc) in *ATTR according to PARAM.  */
-extern int pthread_attr_setschedparam __P ((pthread_attr_t *__attr,
-                                       __const struct sched_param *__param));
+extern int pthread_attr_setschedparam (pthread_attr_t *__attr,
+                                      __const struct sched_param *__param)
+     __THROW;
 
 /* Return in *PARAM the scheduling parameters of *ATTR.  */
-extern int pthread_attr_getschedparam __P ((__const pthread_attr_t *__attr,
-                                           struct sched_param *__param));
+extern int pthread_attr_getschedparam (__const pthread_attr_t *__attr,
+                                      struct sched_param *__param) __THROW;
 
 /* Set scheduling policy in *ATTR according to POLICY.  */
-extern int pthread_attr_setschedpolicy __P ((pthread_attr_t *__attr,
-                                            int __policy));
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     __THROW;
 
 /* Return in *POLICY the scheduling policy of *ATTR.  */
-extern int pthread_attr_getschedpolicy __P ((__const pthread_attr_t *__attr,
-                                            int *__policy));
+extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__attr,
+                                       int *__policy) __THROW;
 
 /* Set scheduling inheritance mode in *ATTR according to INHERIT.  */
-extern int pthread_attr_setinheritsched __P ((pthread_attr_t *__attr,
-                                             int __inherit));
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+                                        int __inherit) __THROW;
 
 /* Return in *INHERIT the scheduling inheritance mode of *ATTR.  */
-extern int pthread_attr_getinheritsched __P ((__const pthread_attr_t *__attr,
-                                             int *__inherit));
+extern int pthread_attr_getinheritsched (__const pthread_attr_t *__attr,
+                                        int *__inherit) __THROW;
 
 /* Set scheduling contention scope in *ATTR according to SCOPE.  */
-extern int pthread_attr_setscope __P ((pthread_attr_t *__attr, int __scope));
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     __THROW;
 
 /* Return in *SCOPE the scheduling contention scope of *ATTR.  */
-extern int pthread_attr_getscope __P ((__const pthread_attr_t *__attr,
-                                      int *__scope));
+extern int pthread_attr_getscope (__const pthread_attr_t *__attr,
+                                 int *__scope) __THROW;
 
 #ifdef __USE_UNIX98
 /* Set the size of the guard area at the bottom of the thread.  */
-extern int pthread_attr_setguardsize __P ((pthread_attr_t *__attr,
-                                          size_t __guardsize));
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+                                     size_t __guardsize) __THROW;
 
 /* Get the size of the guard area at the bottom of the thread.  */
-extern int pthread_attr_getguardsize __P ((__const pthread_attr_t *__attr,
-                                          size_t *__guardsize));
+extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,
+                                     size_t *__guardsize) __THROW;
 #endif
 
 /* Set the starting address of the stack of the thread to be created.
    Depending on whether the stack grows up or doen the value must either
    be higher or lower than all the address in the memory block.  The
    minimal size of the block must be PTHREAD_STACK_SIZE.  */
-extern int pthread_attr_setstackaddr __P ((pthread_attr_t *__attr,
-                                          void *__stackaddr));
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+                                     void *__stackaddr) __THROW;
 
 /* Return the previously set address for the stack.  */
-extern int pthread_attr_getstackaddr __P ((__const pthread_attr_t *__attr,
-                                          void **__stackaddr));
+extern int pthread_attr_getstackaddr (__const pthread_attr_t *__attr,
+                                     void **__stackaddr) __THROW;
 
 /* Add information about the minimum stack size needed for the thread
    to be started.  This size must never be less than PTHREAD_STACK_SIZE
    and must also not exceed the system limits.  */
-extern int pthread_attr_setstacksize __P ((pthread_attr_t *__attr,
-                                          size_t __stacksize));
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+                                     size_t __stacksize) __THROW;
 
 /* Return the currently used minimal stack size.  */
-extern int pthread_attr_getstacksize __P ((__const pthread_attr_t *__attr,
-                                          size_t *__stacksize));
+extern int pthread_attr_getstacksize (__const pthread_attr_t *__attr,
+                                     size_t *__stacksize) __THROW;
 
 /* Functions for scheduling control. */
 
 /* Set the scheduling parameters for TARGET_THREAD according to POLICY
    and *PARAM. */
-extern int pthread_setschedparam __P ((pthread_t __target_thread, int __policy,
-                                      __const struct sched_param *__param));
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+                                 __const struct sched_param *__param)
+     __THROW;
 
 /* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */
-extern int pthread_getschedparam __P ((pthread_t __target_thread,
-                                      int *__policy,
-                                      struct sched_param *__param));
+extern int pthread_getschedparam (pthread_t __target_thread, int *__policy,
+                                 struct sched_param *__param) __THROW;
 
 #ifdef __USE_UNIX98
 /* Determine  level of concurrency.  */
-extern int pthread_getconcurrency __P ((void));
+extern int pthread_getconcurrency (void) __THROW;
 
 /* Set new concurrency level to LEVEL.  */
-extern int pthread_setconcurrency __P ((int __level));
+extern int pthread_setconcurrency (int __level) __THROW;
 #endif
 
 /* Functions for mutex handling. */
 
 /* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the
    default values if later is NULL.  */
-extern int __pthread_mutex_init __P ((pthread_mutex_t *__mutex,
-                                  __const pthread_mutexattr_t *__mutex_attr));
-extern int pthread_mutex_init __P ((pthread_mutex_t *__mutex,
-                                  __const pthread_mutexattr_t *__mutex_attr));
+extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
+                                __const pthread_mutexattr_t *__mutex_attr)
+     __THROW;
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+                              __const pthread_mutexattr_t *__mutex_attr)
+     __THROW;
 
 /* Destroy MUTEX.  */
-extern int __pthread_mutex_destroy __P ((pthread_mutex_t *__mutex));
-extern int pthread_mutex_destroy __P ((pthread_mutex_t *__mutex));
+extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex) __THROW;
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) __THROW;
 
 /* Try to lock MUTEX.  */
-extern int __pthread_mutex_trylock __P ((pthread_mutex_t *__mutex));
-extern int pthread_mutex_trylock __P ((pthread_mutex_t *__mutex));
+extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex) __THROW;
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) __THROW;
 
 /* Wait until lock for MUTEX becomes available and lock it.  */
-extern int __pthread_mutex_lock __P ((pthread_mutex_t *__mutex));
-extern int pthread_mutex_lock __P ((pthread_mutex_t *__mutex));
+extern int __pthread_mutex_lock (pthread_mutex_t *__mutex) __THROW;
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex) __THROW;
 
 /* Unlock MUTEX.  */
-extern int __pthread_mutex_unlock __P ((pthread_mutex_t *__mutex));
-extern int pthread_mutex_unlock __P ((pthread_mutex_t *__mutex));
+extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex) __THROW;
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) __THROW;
 
 
 /* Functions for handling mutex attributes.  */
 
 /* Initialize mutex attribute object ATTR with default attributes
    (kind is PTHREAD_MUTEX_FAST_NP).  */
-extern int __pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr));
-extern int pthread_mutexattr_init __P ((pthread_mutexattr_t *__attr));
+extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr) __THROW;
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) __THROW;
 
 /* Destroy mutex attribute object ATTR.  */
-extern int __pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr));
-extern int pthread_mutexattr_destroy __P ((pthread_mutexattr_t *__attr));
+extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) __THROW;
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) __THROW;
 
 #ifdef __USE_UNIX98
 /* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL,
    PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or
    PTHREAD_MUTEX_DEFAULT).  */
-extern int __pthread_mutexattr_settype __P ((pthread_mutexattr_t *__attr,
-                                            int __kind));
-extern int pthread_mutexattr_settype __P ((pthread_mutexattr_t *__attr,
-                                          int __kind));
+extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr,
+                                       int __kind) __THROW;
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     __THROW;
 
 /* Return in *KIND the mutex kind attribute in *ATTR. */
-extern int pthread_mutexattr_gettype __P ((__const pthread_mutexattr_t *__attr,
-                                          int *__kind));
+extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__attr,
+                                     int *__kind) __THROW;
 #endif
 
 
@@ -319,38 +324,38 @@ extern int pthread_mutexattr_gettype __P ((__const pthread_mutexattr_t *__attr,
 
 /* Initialize condition variable COND using attributes ATTR, or use
    the default values if later is NULL.  */
-extern int pthread_cond_init __P ((pthread_cond_t *__cond,
-                                  __const pthread_condattr_t *__cond_attr));
+extern int pthread_cond_init (pthread_cond_t *__cond,
+                             __const pthread_condattr_t *__cond_attr) __THROW;
 
 /* Destroy condition variable COND.  */
-extern int pthread_cond_destroy __P ((pthread_cond_t *__cond));
+extern int pthread_cond_destroy (pthread_cond_t *__cond) __THROW;
 
 /* Wake up one thread waiting for condition variable COND.  */
-extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
+extern int pthread_cond_signal (pthread_cond_t *__cond) __THROW;
 
 /* Wake up all threads waiting for condition variables COND.  */
-extern int pthread_cond_broadcast __P ((pthread_cond_t *__cond));
+extern int pthread_cond_broadcast (pthread_cond_t *__cond) __THROW;
 
 /* Wait for condition variable COND to be signaled or broadcast.
    MUTEX is assumed to be locked before.  */
-extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
-                                  pthread_mutex_t *__mutex));
+extern int pthread_cond_wait (pthread_cond_t *__cond,
+                             pthread_mutex_t *__mutex) __THROW;
 
 /* Wait for condition variable COND to be signaled or broadcast until
    ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an
    absolute time specification; zero is the beginning of the epoch
    (00:00:00 GMT, January 1, 1970). */
-extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
-                                       pthread_mutex_t *__mutex,
-                                       __const struct timespec *__abstime));
+extern int pthread_cond_timedwait (pthread_cond_t *__cond,
+                                  pthread_mutex_t *__mutex,
+                                  __const struct timespec *__abstime) __THROW;
 
 /* Functions for handling condition variable attributes.  */
 
 /* Initialize condition variable attribute ATTR.  */
-extern int pthread_condattr_init __P ((pthread_condattr_t *__attr));
+extern int pthread_condattr_init (pthread_condattr_t *__attr) __THROW;
 
 /* Destroy condition variable attribute ATTR.  */
-extern int pthread_condattr_destroy __P ((pthread_condattr_t *__attr));
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr) __THROW;
 
 
 #ifdef __USE_UNIX98
@@ -358,53 +363,51 @@ extern int pthread_condattr_destroy __P ((pthread_condattr_t *__attr));
 
 /* Initialize read-write lock RWLOCK using attributes ATTR, or use
    the default values if later is NULL.  */
-extern int pthread_rwlock_init __P ((pthread_rwlock_t *__rwlock,
-                                    __const pthread_rwlockattr_t *__attr));
+extern int pthread_rwlock_init (pthread_rwlock_t *__rwlock,
+                               __const pthread_rwlockattr_t *__attr) __THROW;
 
 /* Destroy read-write lock RWLOCK.  */
-extern int pthread_rwlock_destroy __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) __THROW;
 
 /* Acquire read lock for RWLOCK.  */
-extern int pthread_rwlock_rdlock __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) __THROW;
 
 /* Try to acquire read lock for RWLOCK.  */
-extern int pthread_rwlock_tryrdlock __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) __THROW;
 
 /* Acquire write lock for RWLOCK.  */
-extern int pthread_rwlock_wrlock __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) __THROW;
 
 /* Try to acquire writelock for RWLOCK.  */
-extern int pthread_rwlock_trywrlock __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) __THROW;
 
 /* Unlock RWLOCK.  */
-extern int pthread_rwlock_unlock __P ((pthread_rwlock_t *__rwlock));
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) __THROW;
 
 
 /* Functions for handling read-write lock attributes.  */
 
 /* Initialize attribute object ATTR with default values.  */
-extern int pthread_rwlockattr_init __P ((pthread_rwlockattr_t *__attr));
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) __THROW;
 
 /* Destroy attribute object ATTR.  */
-extern int pthread_rwlockattr_destroy __P ((pthread_rwlockattr_t *__attr));
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) __THROW;
 
 /* Return current setting of process-shared attribute of ATTR in PSHARED.  */
-extern int pthread_rwlockattr_getpshared __P ((__const
-                                              pthread_rwlockattr_t *__attr,
-                                              int *__pshared));
+extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *__attr,
+                                         int *__pshared) __THROW;
 
 /* Set process-shared attribute of ATTR to PSHARED.  */
-extern int pthread_rwlockattr_setpshared __P ((pthread_rwlockattr_t *__attr,
-                                              int __pshared));
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+                                         int __pshared) __THROW;
 
 /* Return current setting of reader/writer preference.  */
-extern int pthread_rwlockattr_getkind_np __P ((__const
-                                              pthread_rwlockattr_t *__attr,
-                                              int *__pref));
+extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr,
+                                         int *__pref) __THROW;
 
 /* Set reader/write preference.  */
-extern int pthread_rwlockattr_setkind_np __P ((pthread_rwlockattr_t *__attr,
-                                              int __pref));
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+                                         int __pref) __THROW;
 #endif
 
 
@@ -416,23 +419,23 @@ extern int pthread_rwlockattr_setkind_np __P ((pthread_rwlockattr_t *__attr,
    the value associated to that key when the key is destroyed.
    DESTR_FUNCTION is not called if the value associated is NULL
    when the key is destroyed. */
-extern int __pthread_key_create __P ((pthread_key_t *__key,
-                                     void (*__destr_function) (void *)));
-extern int pthread_key_create __P ((pthread_key_t *__key,
-                                   void (*__destr_function) (void *)));
+extern int __pthread_key_create (pthread_key_t *__key,
+                                void (*__destr_function) (void *)) __THROW;
+extern int pthread_key_create (pthread_key_t *__key,
+                              void (*__destr_function) (void *)) __THROW;
 
 /* Destroy KEY.  */
-extern int pthread_key_delete __P ((pthread_key_t __key));
+extern int pthread_key_delete (pthread_key_t __key) __THROW;
 
 /* Store POINTER in the thread-specific data slot identified by KEY. */
-extern int __pthread_setspecific __P ((pthread_key_t __key,
-                                      __const void *__pointer));
-extern int pthread_setspecific __P ((pthread_key_t __key,
-                                    __const void *__pointer));
+extern int __pthread_setspecific (pthread_key_t __key,
+                                 __const void *__pointer) __THROW;
+extern int pthread_setspecific (pthread_key_t __key,
+                               __const void *__pointer) __THROW;
 
 /* Return current value of the thread-specific data slot identified by KEY.  */
-extern void *__pthread_getspecific __P ((pthread_key_t __key));
-extern void *pthread_getspecific __P ((pthread_key_t __key));
+extern void *__pthread_getspecific (pthread_key_t __key) __THROW;
+extern void *pthread_getspecific (pthread_key_t __key) __THROW;
 
 
 /* Functions for handling initialization */
@@ -441,29 +444,29 @@ extern void *pthread_getspecific __P ((pthread_key_t __key));
    only once, even if pthread_once is executed several times with the
    same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
    extern variable initialized to PTHREAD_ONCE_INIT. */
-extern int __pthread_once __P ((pthread_once_t *__once_control,
-                               void (*__init_routine) (void)));
-extern int pthread_once __P ((pthread_once_t *__once_control,
-                             void (*__init_routine) (void)));
+extern int __pthread_once (pthread_once_t *__once_control,
+                          void (*__init_routine) (void)) __THROW;
+extern int pthread_once (pthread_once_t *__once_control,
+                        void (*__init_routine) (void)) __THROW;
 
 
 /* Functions for handling cancellation. */
 
 /* Set cancelability state of current thread to STATE, returning old
    state in *OLDSTATE if OLDSTATE is not NULL.  */
-extern int pthread_setcancelstate __P ((int __state, int *__oldstate));
+extern int pthread_setcancelstate (int __state, int *__oldstate) __THROW;
 
 /* Set cancellation state of current thread to TYPE, returning the old
    type in *OLDTYPE if OLDTYPE is not NULL.  */
-extern int pthread_setcanceltype __P ((int __type, int *__oldtype));
+extern int pthread_setcanceltype (int __type, int *__oldtype) __THROW;
 
 /* Cancel THREAD immediately or at the next possibility.  */
-extern int pthread_cancel __P ((pthread_t __thread));
+extern int pthread_cancel (pthread_t __thread) __THROW;
 
 /* Test for pending cancellation for the current thread and terminate
    the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
    cancelled. */
-extern void pthread_testcancel __P ((void));
+extern void pthread_testcancel (void) __THROW;
 
 
 /* Install a cleanup handler: ROUTINE will be called with arguments ARG
@@ -473,44 +476,44 @@ extern void pthread_testcancel __P ((void));
    pthread_cleanup_push and pthread_cleanup_pop are macros and must always
    be used in matching pairs at the same nesting level of braces. */
 
-#define pthread_cleanup_push(routine,arg)                                    \
+#define pthread_cleanup_push(routine,arg) \
   { struct _pthread_cleanup_buffer _buffer;                                  \
     _pthread_cleanup_push (&_buffer, (routine), (arg));
 
-extern void _pthread_cleanup_push __P ((struct _pthread_cleanup_buffer *__buffer,
-                                       void (*__routine) (void *),
-                                       void *__arg));
+extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
+                                  void (*__routine) (void *),
+                                  void *__arg) __THROW;
 
 /* Remove a cleanup handler installed by the matching pthread_cleanup_push.
    If EXECUTE is non-zero, the handler function is called. */
 
-#define pthread_cleanup_pop(execute)                                         \
+#define pthread_cleanup_pop(execute) \
     _pthread_cleanup_pop (&_buffer, (execute)); }
 
-extern void _pthread_cleanup_pop __P ((struct _pthread_cleanup_buffer *__buffer,
-                                      int __execute));
+extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
+                                 int __execute) __THROW;
 
 /* Install a cleanup handler as pthread_cleanup_push does, but also
    saves the current cancellation type and set it to deferred cancellation. */
 
 #ifdef __USE_GNU
-# define pthread_cleanup_push_defer_np(routine,arg)                          \
+# define pthread_cleanup_push_defer_np(routine,arg) \
   { struct _pthread_cleanup_buffer _buffer;                                  \
     _pthread_cleanup_push_defer (&_buffer, (routine), (arg));
 
-extern void _pthread_cleanup_push_defer __P ((struct _pthread_cleanup_buffer *__buffer,
-                                             void (*__routine) (void *),
-                                             void *__arg));
+extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
+                                        void (*__routine) (void *),
+                                        void *__arg) __THROW;
 
 /* Remove a cleanup handler as pthread_cleanup_pop does, but also
    restores the cancellation type that was in effect when the matching
    pthread_cleanup_push_defer was called. */
 
-# define pthread_cleanup_pop_restore_np(execute)                             \
+# define pthread_cleanup_pop_restore_np(execute) \
   _pthread_cleanup_pop_restore (&_buffer, (execute)); }
 
-extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *__buffer,
-                                              int __execute));
+extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
+                                         int __execute) __THROW;
 #endif
 
 /* Functions for handling signals. */
@@ -530,21 +533,21 @@ extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *_
    first called before FORK), and the PARENT and CHILD handlers are called
    in FIFO (first added, first called). */
 
-extern int __pthread_atfork __P ((void (*__prepare) (void),
-                                 void (*__parent) (void),
-                                 void (*__child) (void)));
-extern int pthread_atfork __P ((void (*__prepare) (void),
-                               void (*__parent) (void),
-                               void (*__child) (void)));
+extern int __pthread_atfork (void (*__prepare) (void),
+                            void (*__parent) (void),
+                            void (*__child) (void)) __THROW;
+extern int pthread_atfork (void (*__prepare) (void),
+                          void (*__parent) (void),
+                          void (*__child) (void)) __THROW;
 
 /* Terminate all threads in the program except the calling process.
    Should be called just before invoking one of the exec*() functions. */
 
-extern void pthread_kill_other_threads_np __P ((void));
+extern void pthread_kill_other_threads_np (void) __THROW;
 
 
 /* This function is called to initialize the pthread library. */
-extern void __pthread_initialize __P ((void));
+extern void __pthread_initialize (void) __THROW;
 
 __END_DECLS
 
index 1429328..628a9c6 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 92, 95, 96, 97, 98 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -94,10 +94,10 @@ struct lconv
 
 
 /* Set and/or return the current locale.  */
-extern char *setlocale __P ((int __category, __const char *__locale));
+extern char *setlocale (int __category, __const char *__locale) __THROW;
 
 /* Return the numeric/monetary information for the current locale.  */
-extern struct lconv *localeconv __P ((void));
+extern struct lconv *localeconv (void) __THROW;
 
 #ifdef __USE_GNU
 /* The concept of one static locale per category is not very well
@@ -120,17 +120,16 @@ extern struct lconv *localeconv __P ((void));
    I.e., 1 << LC_CTYPE means to load data for this category.  If
    BASE is non-null the appropriate category information in the BASE
    record is replaced.  */
-extern __locale_t __newlocale __P ((int __category_mask,
-                                   __const char *__locale,
-                                   __locale_t __base));
+extern __locale_t __newlocale (int __category_mask, __const char *__locale,
+                              __locale_t __base) __THROW;
 
 /* Return a duplicate of the set of locale in DATASET.  All usage
    counters are increased if necessary.  */
-extern __locale_t __duplocale __P ((__locale_t __dataset));
+extern __locale_t __duplocale (__locale_t __dataset) __THROW;
 
 /* Free the data associated with a locale dataset previously returned
    by a call to `setlocale_r'.  */
-extern void __freelocale __P ((__locale_t __dataset));
+extern void __freelocale (__locale_t __dataset) __THROW;
 #endif
 
 __END_DECLS
index bfd4530..86d927b 100644 (file)
@@ -1,5 +1,5 @@
 /* Functions for pseudo TTY handling.
-   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -31,13 +31,13 @@ __BEGIN_DECLS
 /* Create pseudo tty master slave pair with NAME and set terminal
    attributes according to TERMP and WINP and return handles for both
    ends in AMASTER and ASLAVE.  */
-extern int openpty __P ((int *__amaster, int *__aslave, char *__name,
-                        struct termios *__termp, struct winsize *__winp));
+extern int openpty (int *__amaster, int *__aslave, char *__name,
+                   struct termios *__termp, struct winsize *__winp) __THROW;
 
 /* Create child process and establish the slave pseudo terminal as the
    child's controlling terminal.  */
-extern int forkpty __P ((int *__amaster, char *__name,
-                        struct termios *__termp, struct winsize *__winp));
+extern int forkpty (int *__amaster, char *__name,
+                   struct termios *__termp, struct winsize *__winp) __THROW;
 
 __END_DECLS
 
index 21436a3..7ae4158 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1993, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1993, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -39,56 +39,56 @@ __BEGIN_DECLS
 
 /* Make FD be the controlling terminal, stdin, stdout, and stderr;
    then close FD.  Returns 0 on success, nonzero on error.  */
-extern int login_tty __P ((int __fd));
+extern int login_tty (int __fd) __THROW;
 
 
 /* Write the given entry into utmp and wtmp.  */
-extern void login __P ((__const struct utmp *__entry));
+extern void login (__const struct utmp *__entry) __THROW;
 
 /* Write the utmp entry to say the user on UT_LINE has logged out.  */
-extern int logout __P ((__const char *__ut_line));
+extern int logout (__const char *__ut_line) __THROW;
 
 /* Append to wtmp an entry for the current time and the given info.  */
-extern void logwtmp __P ((__const char *__ut_line, __const char *__ut_name,
-                         __const char *__ut_host));
+extern void logwtmp (__const char *__ut_line, __const char *__ut_name,
+                    __const char *__ut_host) __THROW;
 
 /* Append entry UTMP to the wtmp-like file WTMP_FILE.  */
-extern void updwtmp __P ((__const char *__wtmp_file,
-                         __const struct utmp *__utmp));
+extern void updwtmp (__const char *__wtmp_file, __const struct utmp *__utmp)
+     __THROW;
 
 /* Change name of the utmp file to be examined.  */
-extern int utmpname __P ((__const char *__file));
+extern int utmpname (__const char *__file) __THROW;
 
 /* Read next entry from a utmp-like file.  */
-extern struct utmp *getutent __P ((void));
+extern struct utmp *getutent (void) __THROW;
 
 /* Reset the input stream to the beginning of the file.  */
-extern void setutent __P ((void));
+extern void setutent (void) __THROW;
 
 /* Close the current open file.  */
-extern void endutent __P ((void));
+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 __P ((__const struct utmp *__id));
+extern struct utmp *getutid (__const struct utmp *__id) __THROW;
 
 /* Search forward from the current point in the utmp file until the
    next entry with a ut_line matching LINE->ut_line.  */
-extern struct utmp *getutline __P ((__const struct utmp *__line));
+extern struct utmp *getutline (__const struct utmp *__line) __THROW;
 
 /* Write out entry pointed to by UTMP_PTR into the utmp file.  */
-extern struct utmp *pututline __P ((__const struct utmp *__utmp_ptr));
+extern struct utmp *pututline (__const struct utmp *__utmp_ptr) __THROW;
 
 
 #ifdef __USE_MISC
 /* Reentrant versions of the file for handling utmp files.  */
-extern int getutent_r __P ((struct utmp *__buffer, struct utmp **__result));
+extern int getutent_r (struct utmp *__buffer, struct utmp **__result) __THROW;
 
-extern int getutid_r __P ((__const struct utmp *__id, struct utmp *__buffer,
-                          struct utmp **__result));
+extern int getutid_r (__const struct utmp *__id, struct utmp *__buffer,
+                     struct utmp **__result) __THROW;
 
-extern int getutline_r __P ((__const struct utmp *__line,
-                            struct utmp *__buffer, struct utmp **__result));
+extern int getutline_r (__const struct utmp *__line,
+                       struct utmp *__buffer, struct utmp **__result) __THROW;
 
 #endif /* Use misc.  */
 
index 3d55bd3..5cf2bcd 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -39,16 +39,16 @@ enum mcheck_status
    before `malloc' is ever called.  ABORTFUNC is called with an error code
    (see enum above) when an inconsistency is detected.  If ABORTFUNC is
    null, the standard function prints on stderr and then calls `abort'.  */
-extern int mcheck __P ((void (*__abortfunc) (enum mcheck_status)));
+extern int mcheck (void (*__abortfunc) (enum mcheck_status)) __THROW;
 
 /* Check for aberrations in a particular malloc'd block.  You must have
    called `mcheck' already.  These are the same checks that `mcheck' does
    when you free or reallocate a block.  */
-extern enum mcheck_status mprobe __P ((__ptr_t __ptr));
+extern enum mcheck_status mprobe (void *__ptr) __THROW;
 
 /* Activate a standard collection of tracing hooks.  */
-extern void mtrace __P ((void));
-extern void muntrace __P ((void));
+extern void mtrace (void) __THROW;
+extern void muntrace (void) __THROW;
 
 __END_DECLS
 
index 3bb5d1b..26cc5e2 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -59,7 +59,7 @@ __BEGIN_DECLS
   __MATHDECL_1(type, function, args); \
   __MATHDECL_1(type, __CONCAT(__,function), args)
 #define __MATHDECL_1(type, function, args) \
-  extern type __MATH_PRECNAME(function) args
+  extern type __MATH_PRECNAME(function) args __THROW
 
 #define _Mdouble_              double
 #define __MATH_PRECNAME(name)  name
index 0e2b4e7..f43def0 100644 (file)
@@ -56,7 +56,7 @@ __BEGIN_DECLS
   __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
   __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
 #define __MATHDECL_1(type, function,suffix, args) \
-  extern type __MATH_PRECNAME(function,suffix) args
+  extern type __MATH_PRECNAME(function,suffix) args __THROW
 
 #define _Mdouble_              double
 #define __MATH_PRECNAME(name,r)        __CONCAT(name,r)
@@ -269,9 +269,9 @@ struct exception
   };
 
 # ifdef __cplusplus
-extern int matherr __P ((struct __exception *__exc));
+extern int matherr (struct __exception *__exc) throw ();
 # else
-extern int matherr __P ((struct exception *__exc));
+extern int matherr (struct exception *__exc);
 # endif
 
 # define X_TLOSS       1.41484755040568800000e+16
index 29dbb46..99be167 100644 (file)
@@ -151,122 +151,120 @@ do {                                                            \
 #include <math_ldbl.h>
 
 /* ieee style elementary functions */
-extern double __ieee754_sqrt __P((double));
-extern double __ieee754_acos __P((double));
-extern double __ieee754_acosh __P((double));
-extern double __ieee754_log __P((double));
-extern double __ieee754_atanh __P((double));
-extern double __ieee754_asin __P((double));
-extern double __ieee754_atan2 __P((double,double));
-extern double __ieee754_exp __P((double));
-extern double __ieee754_exp2 __P((double));
-extern double __ieee754_exp10 __P((double));
-extern double __ieee754_cosh __P((double));
-extern double __ieee754_fmod __P((double,double));
-extern double __ieee754_pow __P((double,double));
-extern double __ieee754_lgamma_r __P((double,int *));
-extern double __ieee754_gamma_r __P((double,int *));
-extern double __ieee754_lgamma __P((double));
-extern double __ieee754_gamma __P((double));
-extern double __ieee754_log10 __P((double));
-extern double __ieee754_sinh __P((double));
-extern double __ieee754_hypot __P((double,double));
-extern double __ieee754_j0 __P((double));
-extern double __ieee754_j1 __P((double));
-extern double __ieee754_y0 __P((double));
-extern double __ieee754_y1 __P((double));
-extern double __ieee754_jn __P((int,double));
-extern double __ieee754_yn __P((int,double));
-extern double __ieee754_remainder __P((double,double));
-extern int32_t __ieee754_rem_pio2 __P((double,double*));
-extern double __ieee754_scalb __P((double,double));
+extern double __ieee754_sqrt (double);
+extern double __ieee754_acos (double);
+extern double __ieee754_acosh (double);
+extern double __ieee754_log (double);
+extern double __ieee754_atanh (double);
+extern double __ieee754_asin (double);
+extern double __ieee754_atan2 (double,double);
+extern double __ieee754_exp (double);
+extern double __ieee754_exp2 (double);
+extern double __ieee754_exp10 (double);
+extern double __ieee754_cosh (double);
+extern double __ieee754_fmod (double,double);
+extern double __ieee754_pow (double,double);
+extern double __ieee754_lgamma_r (double,int *);
+extern double __ieee754_gamma_r (double,int *);
+extern double __ieee754_lgamma (double);
+extern double __ieee754_gamma (double);
+extern double __ieee754_log10 (double);
+extern double __ieee754_sinh (double);
+extern double __ieee754_hypot (double,double);
+extern double __ieee754_j0 (double);
+extern double __ieee754_j1 (double);
+extern double __ieee754_y0 (double);
+extern double __ieee754_y1 (double);
+extern double __ieee754_jn (int,double);
+extern double __ieee754_yn (int,double);
+extern double __ieee754_remainder (double,double);
+extern int32_t __ieee754_rem_pio2 (double,double*);
+extern double __ieee754_scalb (double,double);
 
 /* fdlibm kernel function */
-extern double __kernel_standard __P((double,double,int));
-extern double __kernel_sin __P((double,double,int));
-extern double __kernel_cos __P((double,double));
-extern double __kernel_tan __P((double,double,int));
-extern int    __kernel_rem_pio2 __P((double*,double*,int,int,int,
-                                    const int32_t*));
+extern double __kernel_standard (double,double,int);
+extern double __kernel_sin (double,double,int);
+extern double __kernel_cos (double,double);
+extern double __kernel_tan (double,double,int);
+extern int    __kernel_rem_pio2 (double*,double*,int,int,int, const int32_t*);
 
 
 /* ieee style elementary float functions */
-extern float __ieee754_sqrtf __P((float));
-extern float __ieee754_acosf __P((float));
-extern float __ieee754_acoshf __P((float));
-extern float __ieee754_logf __P((float));
-extern float __ieee754_atanhf __P((float));
-extern float __ieee754_asinf __P((float));
-extern float __ieee754_atan2f __P((float,float));
-extern float __ieee754_expf __P((float));
-extern float __ieee754_exp2f __P((float));
-extern float __ieee754_exp10f __P((float));
-extern float __ieee754_coshf __P((float));
-extern float __ieee754_fmodf __P((float,float));
-extern float __ieee754_powf __P((float,float));
-extern float __ieee754_lgammaf_r __P((float,int *));
-extern float __ieee754_gammaf_r __P((float,int *));
-extern float __ieee754_lgammaf __P((float));
-extern float __ieee754_gammaf __P((float));
-extern float __ieee754_log10f __P((float));
-extern float __ieee754_sinhf __P((float));
-extern float __ieee754_hypotf __P((float,float));
-extern float __ieee754_j0f __P((float));
-extern float __ieee754_j1f __P((float));
-extern float __ieee754_y0f __P((float));
-extern float __ieee754_y1f __P((float));
-extern float __ieee754_jnf __P((int,float));
-extern float __ieee754_ynf __P((int,float));
-extern float __ieee754_remainderf __P((float,float));
-extern int32_t __ieee754_rem_pio2f __P((float,float*));
-extern float __ieee754_scalbf __P((float,float));
+extern float __ieee754_sqrtf (float);
+extern float __ieee754_acosf (float);
+extern float __ieee754_acoshf (float);
+extern float __ieee754_logf (float);
+extern float __ieee754_atanhf (float);
+extern float __ieee754_asinf (float);
+extern float __ieee754_atan2f (float,float);
+extern float __ieee754_expf (float);
+extern float __ieee754_exp2f (float);
+extern float __ieee754_exp10f (float);
+extern float __ieee754_coshf (float);
+extern float __ieee754_fmodf (float,float);
+extern float __ieee754_powf (float,float);
+extern float __ieee754_lgammaf_r (float,int *);
+extern float __ieee754_gammaf_r (float,int *);
+extern float __ieee754_lgammaf (float);
+extern float __ieee754_gammaf (float);
+extern float __ieee754_log10f (float);
+extern float __ieee754_sinhf (float);
+extern float __ieee754_hypotf (float,float);
+extern float __ieee754_j0f (float);
+extern float __ieee754_j1f (float);
+extern float __ieee754_y0f (float);
+extern float __ieee754_y1f (float);
+extern float __ieee754_jnf (int,float);
+extern float __ieee754_ynf (int,float);
+extern float __ieee754_remainderf (float,float);
+extern int32_t __ieee754_rem_pio2f (float,float*);
+extern float __ieee754_scalbf (float,float);
 
 /* float versions of fdlibm kernel functions */
-extern float __kernel_sinf __P((float,float,int));
-extern float __kernel_cosf __P((float,float));
-extern float __kernel_tanf __P((float,float,int));
-extern int   __kernel_rem_pio2f __P((float*,float*,int,int,int,
-                                    const int32_t*));
+extern float __kernel_sinf (float,float,int);
+extern float __kernel_cosf (float,float);
+extern float __kernel_tanf (float,float,int);
+extern int   __kernel_rem_pio2f (float*,float*,int,int,int, const int32_t*);
 
 
 /* ieee style elementary long double functions */
-extern long double __ieee754_sqrtl __P((long double));
-extern long double __ieee754_acosl __P((long double));
-extern long double __ieee754_acoshl __P((long double));
-extern long double __ieee754_logl __P((long double));
-extern long double __ieee754_atanhl __P((long double));
-extern long double __ieee754_asinl __P((long double));
-extern long double __ieee754_atan2l __P((long double,long double));
-extern long double __ieee754_expl __P((long double));
-extern long double __ieee754_exp2l __P((long double));
-extern long double __ieee754_exp10l __P((long double));
-extern long double __ieee754_coshl __P((long double));
-extern long double __ieee754_fmodl __P((long double,long double));
-extern long double __ieee754_powl __P((long double,long double));
-extern long double __ieee754_lgammal_r __P((long double,int *));
-extern long double __ieee754_gammal_r __P((long double,int *));
-extern long double __ieee754_lgammal __P((long double));
-extern long double __ieee754_gammal __P((long double));
-extern long double __ieee754_log10l __P((long double));
-extern long double __ieee754_sinhl __P((long double));
-extern long double __ieee754_hypotl __P((long double,long double));
-extern long double __ieee754_j0l __P((long double));
-extern long double __ieee754_j1l __P((long double));
-extern long double __ieee754_y0l __P((long double));
-extern long double __ieee754_y1l __P((long double));
-extern long double __ieee754_jnl __P((int,long double));
-extern long double __ieee754_ynl __P((int,long double));
-extern long double __ieee754_remainderl __P((long double,long double));
-extern int   __ieee754_rem_pio2l __P((long double,long double*));
-extern long double __ieee754_scalbl __P((long double,long double));
+extern long double __ieee754_sqrtl (long double);
+extern long double __ieee754_acosl (long double);
+extern long double __ieee754_acoshl (long double);
+extern long double __ieee754_logl (long double);
+extern long double __ieee754_atanhl (long double);
+extern long double __ieee754_asinl (long double);
+extern long double __ieee754_atan2l (long double,long double);
+extern long double __ieee754_expl (long double);
+extern long double __ieee754_exp2l (long double);
+extern long double __ieee754_exp10l (long double);
+extern long double __ieee754_coshl (long double);
+extern long double __ieee754_fmodl (long double,long double);
+extern long double __ieee754_powl (long double,long double);
+extern long double __ieee754_lgammal_r (long double,int *);
+extern long double __ieee754_gammal_r (long double,int *);
+extern long double __ieee754_lgammal (long double);
+extern long double __ieee754_gammal (long double);
+extern long double __ieee754_log10l (long double);
+extern long double __ieee754_sinhl (long double);
+extern long double __ieee754_hypotl (long double,long double);
+extern long double __ieee754_j0l (long double);
+extern long double __ieee754_j1l (long double);
+extern long double __ieee754_y0l (long double);
+extern long double __ieee754_y1l (long double);
+extern long double __ieee754_jnl (int,long double);
+extern long double __ieee754_ynl (int,long double);
+extern long double __ieee754_remainderl (long double,long double);
+extern int   __ieee754_rem_pio2l (long double,long double*);
+extern long double __ieee754_scalbl (long double,long double);
 
 /* long double versions of fdlibm kernel functions */
-extern long double __kernel_sinl __P((long double,long double,int));
-extern long double __kernel_cosl __P((long double,long double));
-extern long double __kernel_tanl __P((long double,long double,int));
-extern void __kernel_sincosl __P((long double,long double,
-                                 long double *,long double *, int));
-extern int   __kernel_rem_pio2l __P((long double*,long double*,int,int,
-                                    int,const int*));
+extern long double __kernel_sinl (long double,long double,int);
+extern long double __kernel_cosl (long double,long double);
+extern long double __kernel_tanl (long double,long double,int);
+extern void __kernel_sincosl (long double,long double,
+                             long double *,long double *, int);
+extern int   __kernel_rem_pio2l (long double*,long double*,int,int,
+                                int,const int*);
 
 #endif /* _MATH_PRIVATE_H_ */
index 6170006..e5d0e46 100644 (file)
@@ -1,5 +1,5 @@
 /* 4.4BSD utility functions for error messages.
-   Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -32,26 +32,26 @@ __BEGIN_DECLS
 
 /* Print "program: ", FORMAT, ": ", the standard error string for errno,
    and a newline, on stderr.  */
-extern void warn __P ((__const char *__format, ...))
-     __attribute__ ((__format__ (__printf__, 1, 2)));
-extern void vwarn __P ((__const char *__format, __gnuc_va_list))
-     __attribute__ ((__format__ (__printf__, 1, 0)));
+extern void warn (__const char *__format, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 1, 2)));
+extern void vwarn (__const char *__format, __gnuc_va_list)
+     __THROW __attribute__ ((__format__ (__printf__, 1, 0)));
 
 /* Likewise, but without ": " and the standard error string.  */
-extern void warnx __P ((__const char *__format, ...))
-     __attribute__ ((__format__ (__printf__, 1, 2)));
-extern void vwarnx __P ((__const char *__format, __gnuc_va_list))
-     __attribute__ ((__format__ (__printf__, 1, 0)));
+extern void warnx (__const char *__format, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 1, 2)));
+extern void vwarnx (__const char *__format, __gnuc_va_list)
+     __THROW __attribute__ ((__format__ (__printf__, 1, 0)));
 
 /* Likewise, and then exit with STATUS.  */
-extern void err __P ((int __status, __const char *__format, ...))
-     __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
-extern void verr __P ((int __status, __const char *__format, __gnuc_va_list))
-     __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
-extern void errx __P ((int __status, __const char *__format, ...))
-     __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
-extern void verrx __P ((int __status, __const char *, __gnuc_va_list))
-     __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
+extern void err (int __status, __const char *__format, ...)
+     __THROW __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
+extern void verr (int __status, __const char *__format, __gnuc_va_list)
+     __THROW __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
+extern void errx (int __status, __const char *__format, ...)
+     __THROW __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3)));
+extern void verrx (int __status, __const char *, __gnuc_va_list)
+     __THROW __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0)));
 
 __END_DECLS
 
index 316a4f8..24ecad7 100644 (file)
@@ -68,11 +68,11 @@ struct fstab
 
 __BEGIN_DECLS
 
-extern struct fstab *getfsent __P ((void));
-extern struct fstab *getfsspec __P ((__const char *__name));
-extern struct fstab *getfsfile __P ((__const char *__name));
-extern int setfsent __P ((void));
-extern void endfsent __P ((void));
+extern struct fstab *getfsent (void) __THROW;
+extern struct fstab *getfsspec (__const char *__name) __THROW;
+extern struct fstab *getfsfile (__const char *__name) __THROW;
+extern int setfsent (void) __THROW;
+extern void endfsent (void) __THROW;
 
 __END_DECLS
 
index b4ef9e5..948a9c3 100644 (file)
@@ -24,7 +24,7 @@
 __BEGIN_DECLS
 
 /* Return directory part of PATH or "." if none is available.  */
-extern char *dirname __P ((char *__path));
+extern char *dirname (char *__path) __THROW;
 
 /* Return final component of PATH.
 
@@ -32,7 +32,7 @@ extern char *dirname __P ((char *__path));
    modify its argument.  Therefore we normally use the GNU version (in
    <string.h>) and only if this header is included make the XPG
    version available under the real name.  */
-extern char *__xpg_basename __P ((char *__path));
+extern char *__xpg_basename (char *__path) __THROW;
 #define basename       __xpg_basename
 
 __END_DECLS
index 6acd532..decda94 100644 (file)
@@ -1,5 +1,5 @@
 /* Utilities for reading/writing fstab, mtab, etc.
-   Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -64,33 +64,33 @@ struct mntent
 
 /* Prepare to begin reading and/or writing mount table entries from the
    beginning of FILE.  MODE is as for `fopen'.  */
-extern FILE *setmntent __P ((__const char *__file, __const char *__mode));
+extern FILE *setmntent (__const char *__file, __const char *__mode) __THROW;
 
 /* 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
    check).  */
-extern struct mntent *getmntent __P ((FILE *__stream));
+extern struct mntent *getmntent (FILE *__stream) __THROW;
 
 #ifdef __USE_MISC
 /* Reentrant version of the above function.  */
-extern struct mntent *getmntent_r __P ((FILE *__restrict __stream,
-                                       struct mntent *__restrict __result,
-                                       char *__restrict __buffer,
-                                       int __bufsize));
+extern struct mntent *getmntent_r (FILE *__restrict __stream,
+                                  struct mntent *__restrict __result,
+                                  char *__restrict __buffer,
+                                  int __bufsize) __THROW;
 #endif
 
 /* Write the mount table entry described by MNT to STREAM.
    Return zero on success, nonzero on failure.  */
-extern int addmntent __P ((FILE *__restrict __stream,
-                          __const struct mntent *__restrict __mnt));
+extern int addmntent (FILE *__restrict __stream,
+                     __const struct mntent *__restrict __mnt) __THROW;
 
 /* Close a stream opened with `setmntent'.  */
-extern int endmntent __P ((FILE *__stream));
+extern int endmntent (FILE *__stream) __THROW;
 
 /* Search MNT->mnt_opts for an option matching OPT.
    Returns the address of the substring, or null if none found.  */
-extern char *hasmntopt __P ((__const struct mntent *__mnt,
-                            __const char *__opt));
+extern char *hasmntopt (__const struct mntent *__mnt,
+                       __const char *__opt) __THROW;
 
 
 __END_DECLS
index fc60d3c..a8659ae 100644 (file)
@@ -206,14 +206,14 @@ compile (char *__restrict instring, char *__restrict expbuf,
    found in the buffer starting at EXPBUF.  `loc1' will return the
    first character matched and `loc2' points to the next unmatched
    character.  */
-extern int step __P ((__const char *__restrict __string,
-                     __const char *__restrict __expbuf));
+extern int step (__const char *__restrict __string,
+                __const char *__restrict __expbuf) __THROW;
 
 /* Match the beginning of STRING with the compiled regular expression
    in EXPBUF.  If the match is successful `loc2' will contain the
    position of the first unmatched character.  */
-extern int advance __P ((__const char *__restrict __string,
-                        __const char *__restrict __expbuf));
+extern int advance (__const char *__restrict __string,
+                   __const char *__restrict __expbuf) __THROW;
 
 
 __END_DECLS
index 8fb2539..ebc525a 100644 (file)
@@ -42,17 +42,17 @@ struct qelem
 
 
 /* Insert ELEM into a doubly-linked list, after PREV.  */
-extern void insque __P ((void *__elem, void *__prev));
+extern void insque (void *__elem, void *__prev) __THROW;
 
 /* Unlink ELEM from the doubly-linked list that it is in.  */
-extern void remque __P ((void *__elem));
+extern void remque (void *__elem) __THROW;
 #endif
 
 
 /* For use with hsearch(3).  */
 #ifndef __COMPAR_FN_T
 # define __COMPAR_FN_T
-typedef int (*__compar_fn_t) __PMT ((__const __ptr_t, __const __ptr_t));
+typedef int (*__compar_fn_t) (__const void *, __const void *);
 
 # ifdef        __USE_GNU
 typedef __compar_fn_t comparison_fn_t;
@@ -85,13 +85,13 @@ struct _ENTRY;
    ACTION is `FIND' return found entry or signal error by returning
    NULL.  If ACTION is `ENTER' replace existing data (if any) with
    ITEM.data.  */
-extern ENTRY *hsearch __P ((ENTRY __item, ACTION __action));
+extern ENTRY *hsearch (ENTRY __item, ACTION __action) __THROW;
 
 /* Create a new hashing table which will at most contain NEL elements.  */
-extern int hcreate __P ((size_t __nel));
+extern int hcreate (size_t __nel) __THROW;
 
 /* Destroy current internal hashing table.  */
-extern void hdestroy __P ((void));
+extern void hdestroy (void) __THROW;
 
 #ifdef __USE_GNU
 /* Data type for reentrant functions.  */
@@ -104,10 +104,10 @@ struct hsearch_data
 
 /* Reentrant versions which can handle multiple hashing tables at the
    same time.  */
-extern int hsearch_r __P ((ENTRY __item, ACTION __action, ENTRY **__retval,
-                          struct hsearch_data *__htab));
-extern int hcreate_r __P ((size_t __nel, struct hsearch_data *__htab));
-extern void hdestroy_r __P ((struct hsearch_data *__htab));
+extern int hsearch_r (ENTRY __item, ACTION __action, ENTRY **__retval,
+                     struct hsearch_data *__htab) __THROW;
+extern int hcreate_r (size_t __nel, struct hsearch_data *__htab) __THROW;
+extern void hdestroy_r (struct hsearch_data *__htab) __THROW;
 #endif
 
 
@@ -127,50 +127,47 @@ VISIT;
 
 /* Search for an entry matching the given KEY in the tree pointed to
    by *ROOTP and insert a new element if not found.  */
-extern void *tsearch __PMT ((__const void *__key, void **__rootp,
-                            __compar_fn_t __compar));
+extern void *tsearch (__const void *__key, void **__rootp,
+                     __compar_fn_t __compar);
 
 /* 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 __PMT ((__const void *__key, void *__const *__rootp,
-                          __compar_fn_t __compar));
+extern void *tfind (__const void *__key, void *__const *__rootp,
+                   __compar_fn_t __compar);
 
 /* Remove the element matching KEY from the tree pointed to by *ROOTP.  */
-extern void *tdelete __PMT ((__const void *__key, void **__rootp,
-                            __compar_fn_t __compar));
+extern void *tdelete (__const void *__key, void **__rootp,
+                     __compar_fn_t __compar);
 
 #ifndef __ACTION_FN_T
 # define __ACTION_FN_T
-typedef void (*__action_fn_t) __PMT ((__const void *__nodep,
-                                     VISIT __value,
-                                     int __level));
+typedef void (*__action_fn_t) (__const void *__nodep, VISIT __value,
+                              int __level);
 #endif
 
 /* Walk through the whole tree and call the ACTION callback for every node
    or leaf.  */
-extern void twalk __PMT ((__const void *__root, __action_fn_t __action));
+extern void twalk (__const void *__root, __action_fn_t __action);
 
 #ifdef __USE_GNU
 /* Callback type for function to free a tree node.  If the keys are atomic
    data this function should do nothing.  */
-typedef void (*__free_fn_t) __PMT ((void *__nodep));
+typedef void (*__free_fn_t) (void *__nodep);
 
 /* Destroy the whole tree, call FREEFCT for each node or leaf.  */
-extern void tdestroy __PMT ((void *__root, __free_fn_t __freefct));
+extern void tdestroy (void *__root, __free_fn_t __freefct);
 #endif
 
 
 /* Perform linear search for KEY by comparing by COMPAR in an array
    [BASE,BASE+NMEMB*SIZE).  */
-extern void *lfind __PMT ((__const void *__key, __const void *__base,
-                          size_t *__nmemb, size_t __size,
-                          __compar_fn_t __compar));
+extern void *lfind (__const void *__key, __const void *__base,
+                   size_t *__nmemb, size_t __size, __compar_fn_t __compar);
 
 /* Perform linear search for KEY by comparing by COMPAR function in
    array [BASE,BASE+NMEMB*SIZE) and insert entry if not found.  */
-extern void *lsearch __PMT ((__const void *__key, void *__base,
-                            size_t *__nmemb, size_t __size,
-                            __compar_fn_t __compar));
+extern void *lsearch (__const void *__key, void *__base,
+                     size_t *__nmemb, size_t __size, __compar_fn_t __compar);
 
 __END_DECLS
 
index 02bbb18..6d1c5a8 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1996, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -30,10 +30,10 @@ struct sgttyb;
 __BEGIN_DECLS
 
 /* Fill in *PARAMS with terminal parameters associated with FD.  */
-extern int gtty __P ((int __fd, struct sgttyb *__params));
+extern int gtty patch(int __fd, struct sgttyb *__params) __THROW;
 
 /* Set the terminal parameters associated with FD to *PARAMS.  */
-extern int stty __P ((int __fd, __const struct sgttyb *__params));
+extern int stty (int __fd, __const struct sgttyb *__params) __THROW;
 
 
 __END_DECLS
index 6a8b870..84e24b0 100644 (file)
@@ -43,8 +43,6 @@
    functions.  */
 # define __PMT(args)   args
 
-# define __DOTS                , ...
-
 #else  /* Not GCC.  */
 
 # define __inline              /* No inline functions.  */
 
 #  define __P(args)    args
 #  define __PMT(args)  args
-#  define __const      const
-#  define __signed     signed
-#  define __volatile   volatile
-#  define __DOTS       , ...
 
 # else /* Not ANSI C or C++.  */
 
 #  define __P(args)    ()      /* No prototypes.  */
 #  define __PMT(args)  ()
-#  define __const              /* No ANSI C keywords.  */
-#  define __signed
-#  define __volatile
-#  define __DOTS
 
 # endif        /* ANSI C or C++.  */
 
+# define __const       const
+# define __signed      signed
+# define __volatile    volatile
+
 #endif /* GCC.  */
 
 /* For these things, GCC behaves the ANSI way normally,
    old programs may lose if they use the new keywords as identifiers), but
    those names are not available under -traditional.  We define them to
    their __ versions, which are taken care of above.  */
-#ifdef __USE_BSD
-# define const         __const
-# define signed                __signed
-# define volatile      __volatile
-#endif
+# ifdef        __USE_BSD
+#  define const                __const
+#  define signed               __signed
+#  define volatile     __volatile
+# endif
 
 #endif /* __STDC__ */
 
index a2e7bf0..faff35d 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -48,7 +48,7 @@ __BEGIN_DECLS
 
 /* Apply or remove an advisory lock, according to OPERATION,
    on the file FD refers to.  */
-extern int flock __P ((int __fd, int __operation));
+extern int flock (int __fd, int __operation) __THROW;
 
 
 __END_DECLS
index acb42f2..30a9155 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 92, 93, 94, 96, 98 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 96, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -39,7 +39,7 @@ __BEGIN_DECLS
 /* Perform the I/O control operation specified by REQUEST on FD.
    One argument may follow; its presence and type depend on REQUEST.
    Return value depends on REQUEST.  Usually -1 indicates error.  */
-extern int ioctl __P ((int __fd, unsigned long int __request, ...));
+extern int ioctl (int __fd, unsigned long int __request, ...) __THROW;
 
 __END_DECLS
 
index 92b4bf8..cddb451 100644 (file)
@@ -1,5 +1,5 @@
 /* Definitions for BSD-style memory management.
-   Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1994, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -28,7 +28,7 @@
 #include <bits/mman.h>
 
 /* Return value of `mmap' in case of an error.  */
-#define MAP_FAILED     ((__ptr_t) -1)
+#define MAP_FAILED     ((void *) -1)
 
 __BEGIN_DECLS
 /* Map addresses starting near ADDR and extending for LEN bytes.  from
@@ -41,60 +41,60 @@ __BEGIN_DECLS
    deallocates any previous mapping for the affected region.  */
 
 #ifndef __USE_FILE_OFFSET64
-extern __ptr_t mmap __P ((__ptr_t __addr, size_t __len, int __prot,
-                         int __flags, int __fd, __off_t __offset));
+extern void *mmap (void *__addr, size_t __len, int __prot,
+                  int __flags, int __fd, __off_t __offset) __THROW;
 #else
-extern __ptr_t mmap __P ((__ptr_t __addr, size_t __len, int __prot,
-                         int __flags, int __fd, __off_t __offset))
+extern void *mmap (void *__addr, size_t __len, int __prot,
+                  int __flags, int __fd, __off_t __offset) __THROW
      __asm__ ("mmap64");
 #endif
 #ifdef __USE_LARGEFILE64
-extern __ptr_t mmap64 __P ((__ptr_t __addr, size_t __len, int __prot,
-                           int __flags, int __fd, __off64_t __offset));
+extern void *mmap64 (void *__addr, size_t __len, int __prot,
+                    int __flags, int __fd, __off64_t __offset) __THROW;
 #endif
 
 /* 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 __P ((__ptr_t __addr, size_t __len));
+extern int munmap (void *__addr, size_t __len) __THROW;
 
 /* Change the memory protection of the region starting at ADDR and
    extending LEN bytes to PROT.  Returns 0 if successful, -1 for errors
    (and sets errno).  */
-extern int mprotect __P ((__ptr_t __addr, size_t __len, int __prot));
+extern int mprotect (void *__addr, size_t __len, int __prot) __THROW;
 
 /* Synchronize the region starting at ADDR and extending LEN bytes with the
    file it maps.  Filesystem operations on a file being mapped are
    unpredictable before this is done.  Flags are from the MS_* set.  */
-extern int msync __P ((__ptr_t __addr, size_t __len, int __flags));
+extern int msync (void *__addr, size_t __len, int __flags) __THROW;
 
 #ifdef __USE_BSD
 /* Advise the system about particular usage patterns the program follows
    for the region starting at ADDR and extending LEN bytes.  */
-extern int madvise __P ((__ptr_t __addr, size_t __len, int __advice));
+extern int madvise (void *__addr, size_t __len, int __advice) __THROW;
 #endif
 
 /* Guarantee all whole pages mapped by the range [ADDR,ADDR+LEN) to
    be memory resident.  */
-extern int mlock __P ((__const __ptr_t __addr, size_t __len));
+extern int mlock (__const void *__addr, size_t __len) __THROW;
 
 /* Unlock whole pages previously mapped by the range [ADDR,ADDR+LEN).  */
-extern int munlock __P ((__const __ptr_t __addr, size_t __len));
+extern int munlock (__const void *__addr, size_t __len) __THROW;
 
 /* Cause all currently mapped pages of the process to be memory resident
    until unlocked by a call to the `munlockall', until the process exits,
    or until the process calls `execve'.  */
-extern int mlockall __P ((int __flags));
+extern int mlockall (int __flags) __THROW;
 
 /* All currently mapped pages of the process' address space become
    unlocked.  */
-extern int munlockall __P ((void));
+extern int munlockall (void) __THROW;
 
 #ifdef __USE_MISC
 /* Remap pages mapped by the range [ADDR,ADDR+OLD_LEN) to new length
    NEW_LEN.  If MAY_MOVE is MREMAP_MAYMOVE the returned address may
    differ from ADDR.  */
-extern __ptr_t mremap __P ((__ptr_t __addr, size_t __old_len,
-                           size_t __new_len, int __may_move));
+extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
+                    int __may_move) __THROW;
 #endif
 
 __END_DECLS
index 0972560..15130cb 100644 (file)
@@ -1,5 +1,5 @@
 /* `fd_set' type and related macros, and `select'/`pselect' declarations.
-   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -71,12 +71,12 @@ typedef __fd_set fd_set;
    (if not NULL) for exceptional conditions.  If TIMEOUT is not NULL, time out
    after waiting the interval specified therein.  Returns the number of ready
    descriptors, or -1 for errors.  */
-extern int __select __P ((int __nfds, __fd_set *__readfds,
-                         __fd_set *__writefds, __fd_set *__exceptfds,
-                         struct timeval *__timeout));
-extern int select __P ((int __nfds, __fd_set *__readfds,
-                       __fd_set *__writefds, __fd_set *__exceptfds,
-                       struct timeval *__timeout));
+extern int __select (int __nfds, __fd_set *__readfds,
+                    __fd_set *__writefds, __fd_set *__exceptfds,
+                    struct timeval *__timeout) __THROW;
+extern int select (int __nfds, __fd_set *__readfds,
+                  __fd_set *__writefds, __fd_set *__exceptfds,
+                  struct timeval *__timeout) __THROW;
 
 #ifdef __USE_GNU
 /* XXX Once/if POSIX.1g gets official this prototype will be available
@@ -84,10 +84,9 @@ extern int select __P ((int __nfds, __fd_set *__readfds,
 /* Same as above only that the TIMEOUT value is given with higher
    resolution and a sigmask which is been set temporarily.  This version
    should be used.  */
-extern int pselect __P ((int __nfds, __fd_set *__readfds,
-                        __fd_set *__writefds, __fd_set *__exceptfds,
-                        const struct timespec *__timeout,
-                        const __sigset_t *__sigmask));
+extern int pselect (int __nfds, __fd_set *__readfds, __fd_set *__writefds,
+                   __fd_set *__exceptfds, const struct timespec *__timeout,
+                   const __sigset_t *__sigmask) __THROW;
 #endif
 
 __END_DECLS
index 143f946..a2b7209 100644 (file)
@@ -169,22 +169,22 @@ CODE facilitynames[] =
 __BEGIN_DECLS
 
 /* Close desriptor used to write to system logger.  */
-extern void closelog __P ((void));
+extern void closelog (void) __THROW;
 
 /* Open connection to system logger.  */
-extern void openlog __P ((__const char *__ident, int __option,
-                         int __facility));
+extern void openlog (__const char *__ident, int __option, int __facility)
+     __THROW;
 
 /* Set the log mask level.  */
-extern int setlogmask __P ((int __mask));
+extern int setlogmask (int __mask) __THROW;
 
 /* Generate a log message using FMT string and option arguments.  */
-extern void syslog __P ((int __pri, __const char *__fmt, ...));
+extern void syslog (int __pri, __const char *__fmt, ...) __THROW;
 
 #ifdef __USE_BSD
 /* Generate a log message using FMT and using arguments pointed to by AP.  */
-extern void vsyslog __P ((int __pri, __const char *__fmt,
-                         __gnuc_va_list __ap));
+extern void vsyslog (int __pri, __const char *__fmt, __gnuc_va_list __ap)
+     __THROW;
 #endif
 
 __END_DECLS
index 0be33e9..f833a52 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -34,16 +34,16 @@ __BEGIN_DECLS
    The buffers are filled in the order specified.
    Operates just like `read' (see <unistd.h>) except that data are
    put in VECTOR instead of a contiguous buffer.  */
-extern ssize_t readv __P ((int __fd, __const struct iovec *__vector,
-                          int __count));
+extern ssize_t readv (int __fd, __const struct iovec *__vector, int __count)
+     __THROW;
 
 /* Write data pointed by the buffers described by VECTOR, which
    is a vector of COUNT `struct iovec's, to file descriptor FD.
    The data is written in the order specified.
    Operates just like `write' (see <unistd.h>) except that the data
    are taken from VECTOR instead of a contiguous buffer.  */
-extern ssize_t writev __P ((int __fd, __const struct iovec *__vector,
-                           int __count));
+extern ssize_t writev (int __fd, __const struct iovec *__vector, int __count)
+     __THROW;
 
 __END_DECLS
 
index 355f28d..58862ff 100644 (file)
@@ -1,5 +1,5 @@
 /* Header describing obsolete `ustat' interface.
-   Copyright (C) 1996, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -31,7 +31,7 @@
 
 __BEGIN_DECLS
 
-extern int ustat __P ((__dev_t __dev, struct ustat *__ubuf));
+extern int ustat (__dev_t __dev, struct ustat *__ubuf) __THROW;
 
 __END_DECLS
 
index 9958d88..0b221bc 100644 (file)
@@ -55,10 +55,10 @@ struct ttyent {
 
 __BEGIN_DECLS
 
-extern struct ttyent *getttyent __P ((void));
-extern struct ttyent *getttynam __P ((__const char *__tty));
-extern int setttyent __P ((void));
-extern int endttyent __P ((void));
+extern struct ttyent *getttyent (void) __THROW;
+extern struct ttyent *getttynam (__const char *__tty) __THROW;
+extern int setttyent (void) __THROW;
+extern int endttyent (void) __THROW;
 
 __END_DECLS
 
index dc50cf7..02b9c5d 100644 (file)
--- a/nss/nss.h
+++ b/nss/nss.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -44,8 +44,8 @@ enum nss_status
    work around non-existing services (e.e., while booting).
    Attention: Using this function repeatedly will slowly eat up the
    whole memory since previous selection data cannot be freed.  */
-extern int __nss_configure_lookup __P ((__const char *__dbname,
-                                       __const char *__string));
+extern int __nss_configure_lookup (__const char *__dbname,
+                                  __const char *__string) __THROW;
 
 __END_DECLS
 
index e9c99c2..01db91c 100644 (file)
 __BEGIN_DECLS
 
 /* Set scheduling parameters for a process.  */
-extern int sched_setparam __P ((__pid_t __pid,
-                               __const struct sched_param *__param));
+extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param)
+     __THROW;
 
 /* Retrieve scheduling parameters for a particular process.  */
-extern int sched_getparam __P ((__pid_t __pid, struct sched_param *__param));
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) __THROW;
 
 /* Set scheduling algorithm and/or parameters for a process.  */
-extern int sched_setscheduler __P ((__pid_t __pid, int __policy,
-                                   __const struct sched_param *__param));
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+                              __const struct sched_param *__param) __THROW;
 
 /* Retrieve scheduling algorithm for a particular purpose.  */
-extern int sched_getscheduler __P ((__pid_t __pid));
+extern int sched_getscheduler (__pid_t __pid) __THROW;
 
 /* Yield the processor.  */
-extern int sched_yield __P ((void));
+extern int sched_yield (void) __THROW;
 
 /* Get maximum priority value for a scheduler.  */
-extern int sched_get_priority_max __P ((int __algorithm));
+extern int sched_get_priority_max (int __algorithm) __THROW;
 
 /* Get minimum priority value for a scheduler.  */
-extern int sched_get_priority_min __P ((int __algorithm));
+extern int sched_get_priority_min (int __algorithm) __THROW;
 
 /* Get the SCHED_RR interval for the named process.  */
-extern int sched_rr_get_interval __P ((__pid_t __pid, struct timespec *__t));
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) __THROW;
 
 __END_DECLS
 
index f524438..d483cbe 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1996, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -46,7 +46,7 @@ struct tms
    dead children (and their dead children) in BUFFER.
    Return the elapsed real time, or (clock_t) -1 for errors.
    All times are in CLK_TCKths of a second.  */
-extern clock_t times __P ((struct tms *__buffer));
+extern clock_t times (struct tms *__buffer) __THROW;
 
 __END_DECLS
 
index 629dd59..59940b8 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1994, 1996, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 94, 96, 97, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -66,7 +66,7 @@ struct utsname
 
 
 /* Put information about the system in NAME.  */
-extern int uname __P ((struct utsname *__name));
+extern int uname (struct utsname *__name) __THROW;
 
 
 __END_DECLS
index aba0493..5a3404d 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 92, 93, 94, 96, 97, 98 Free Software Foundation, Inc.
+/* Copyright (C) 1991,92,93,94,96,97,98,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -57,8 +57,8 @@ typedef __pid_t pid_t;
    the actual function definitions.  */
 
 # if !defined __GNUC__ || __GNUC__ < 2 || defined __cplusplus
-#  define __WAIT_STATUS                __ptr_t
-#  define __WAIT_STATUS_DEFN   __ptr_t
+#  define __WAIT_STATUS                void *
+#  define __WAIT_STATUS_DEFN   void *
 # else
 /* This works in GCC 2.6.1 and later.  */
 typedef union
@@ -107,8 +107,8 @@ typedef enum
 
 /* Wait for a child to die.  When one does, put its status in *STAT_LOC
    and return its process ID.  For errors, return (pid_t) -1.  */
-extern __pid_t __wait __P ((__WAIT_STATUS __stat_loc));
-extern __pid_t wait __P ((__WAIT_STATUS __stat_loc));
+extern __pid_t __wait (__WAIT_STATUS __stat_loc) __THROW;
+extern __pid_t wait (__WAIT_STATUS __stat_loc) __THROW;
 
 #ifdef __USE_BSD
 /* Special values for the PID argument to `waitpid' and `wait4'.  */
@@ -128,8 +128,7 @@ extern __pid_t wait __P ((__WAIT_STATUS __stat_loc));
    return PID and store the dead child's status in STAT_LOC.
    Return (pid_t) -1 for errors.  If the WUNTRACED bit is
    set in OPTIONS, return status for stopped children; otherwise don't.  */
-extern __pid_t waitpid __P ((__pid_t __pid, int *__stat_loc,
-                            int __options));
+extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options) __THROW;
 
 #if defined __USE_SVID || defined __USE_XOPEN
 # define __need_siginfo_t
@@ -142,8 +141,8 @@ extern __pid_t waitpid __P ((__pid_t __pid, int *__stat_loc,
    If the WNOHANG bit is set in OPTIONS, and that child
    is not already dead, clear *INFOP and return 0.  If successful, store
    exit code and status in *INFOP.  */
-extern int waitid __P ((idtype_t __idtype, __id_t __id, siginfo_t *__infop,
-                       int __options));
+extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
+                  int __options) __THROW;
 #endif
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
@@ -156,8 +155,8 @@ struct rusage;
    nil, store information about the child's resource usage there.  If the
    WUNTRACED bit is set in OPTIONS, return status for stopped children;
    otherwise don't.  */
-extern __pid_t wait3 __P ((__WAIT_STATUS __stat_loc,
-                          int __options, struct rusage * __usage));
+extern __pid_t wait3 (__WAIT_STATUS __stat_loc, int __options,
+                     struct rusage * __usage) __THROW;
 #endif
 
 #ifdef __USE_BSD
@@ -166,8 +165,8 @@ extern __pid_t wait3 __P ((__WAIT_STATUS __stat_loc,
 struct rusage;
 
 /* PID is like waitpid.  Other args are like wait3.  */
-extern __pid_t wait4 __P ((__pid_t __pid, __WAIT_STATUS __stat_loc,
-                          int __options, struct rusage *__usage));
+extern __pid_t wait4 (__pid_t __pid, __WAIT_STATUS __stat_loc, int __options,
+                     struct rusage *__usage) __THROW;
 #endif /* Use BSD.  */
 
 
index 3437030..d563ef9 100644 (file)
@@ -250,12 +250,12 @@ typedef __intptr_t intptr_t;
 #define        F_OK    0               /* Test for existence.  */
 
 /* Test for access to NAME using the real UID and real GID.  */
-extern int access __P ((__const char *__name, int __type));
+extern int access (__const char *__name, int __type) __THROW;
 
 #ifdef __USE_GNU
 /* Test for access to NAME using the effective UID and GID
    (as normal file operations use).  */
-extern int euidaccess __P ((__const char *__name, int __type));
+extern int euidaccess (__const char *__name, int __type) __THROW;
 #endif
 
 
@@ -279,59 +279,60 @@ extern int euidaccess __P ((__const char *__name, int __type));
    the current position (if WHENCE is SEEK_CUR),
    or the end of the file (if WHENCE is SEEK_END).
    Return the new file position.  */
-extern __off_t __lseek __P ((int __fd, __off_t __offset, int __whence));
+extern __off_t __lseek (int __fd, __off_t __offset, int __whence) __THROW;
 #ifndef __USE_FILE_OFFSET64
-extern __off_t lseek __P ((int __fd, __off_t __offset, int __whence));
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) __THROW;
 #else
 # ifdef __REDIRECT
 extern __off64_t __REDIRECT (lseek,
-                            __P ((int __fd, __off64_t __offset,
-                                  int __whence)),
+                            (int __fd, __off64_t __offset, int __whence)
+                            __THROW,
                             lseek64);
 # else
 #  define lseek lseek64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern __off64_t lseek64 __P ((int __fd, __off64_t __offset, int __whence));
+extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) __THROW;
 #endif
 
 /* Close the file descriptor FD.  */
-extern int __close __P ((int __fd));
-extern int close __P ((int __fd));
+extern int __close (int __fd) __THROW;
+extern int close (int __fd) __THROW;
 
 /* Read NBYTES into BUF from FD.  Return the
    number read, -1 for errors or 0 for EOF.  */
-extern ssize_t __read __P ((int __fd, __ptr_t __buf, size_t __nbytes));
-extern ssize_t read __P ((int __fd, __ptr_t __buf, size_t __nbytes));
+extern ssize_t __read (int __fd, void *__buf, size_t __nbytes) __THROW;
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __THROW;
 
 /* Write N bytes of BUF to FD.  Return the number written, or -1.  */
-extern ssize_t __write __P ((int __fd, __const __ptr_t __buf, size_t __n));
-extern ssize_t write __P ((int __fd, __const __ptr_t __buf, size_t __n));
+extern ssize_t __write (int __fd, __const void *__buf, size_t __n) __THROW;
+extern ssize_t write (int __fd, __const void *__buf, size_t __n) __THROW;
 
 #ifdef __USE_UNIX98
 /* Read NBYTES into BUF from FD at the given position OFFSET without
    changing the file pointer.  Return the number read, -1 for errors
    or 0 for EOF.  */
-extern ssize_t __pread64 __P ((int __fd, __ptr_t __buf, size_t __nbytes,
-                              __off64_t __offset));
+extern ssize_t __pread64 (int __fd, void *__buf, size_t __nbytes,
+                         __off64_t __offset) __THROW;
 /* Write N bytes of BUF to FD at the given position OFFSET without
    changing the file pointer.  Return the number written, or -1.  */
-extern ssize_t __pwrite64 __P ((int __fd, __const __ptr_t __buf, size_t __n,
-                               __off64_t __offset));
+extern ssize_t __pwrite64 (int __fd, __const void *__buf, size_t __n,
+                          __off64_t __offset) __THROW;
 
 # ifndef __USE_FILE_OFFSET64
-extern ssize_t pread __P ((int __fd, __ptr_t __buf, size_t __nbytes,
-                          __off_t __offset));
-extern ssize_t pwrite __P ((int __fd, __const __ptr_t __buf, size_t __n,
-                           __off_t __offset));
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
+     __THROW;
+extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
+                      __off_t __offset) __THROW;
 # else
 #  ifdef __REDIRECT
-extern ssize_t __REDIRECT (pread, __P ((int __fd, __ptr_t __buf,
-                                       size_t __nbytes,__off64_t __offset)),
+extern ssize_t __REDIRECT (pread, (int __fd, void *__buf, size_t __nbytes,
+                                  __off64_t __offset) __THROW,
                           pread64);
-extern ssize_t __REDIRECT (pwrite, __P ((int __fd, __const __ptr_t __buf,
-                                        size_t __nbytes, __off64_t __offset)),
+extern ssize_t __REDIRECT (pwrite, (int __fd, __const void *__buf,
+                                   size_t __nbytes, __off64_t __offset)
+                          __THROW,
                        pwrite64);
 #  else
 #   define pread pread64
@@ -340,10 +341,10 @@ extern ssize_t __REDIRECT (pwrite, __P ((int __fd, __const __ptr_t __buf,
 # endif
 
 # ifdef __USE_LARGEFILE64
-extern ssize_t pread64 __P ((int __fd, __ptr_t __buf, size_t __nbytes,
-                            __off64_t __offset));
-extern ssize_t pwrite64 __P ((int __fd, __const __ptr_t __buf, size_t __n,
-                             __off64_t __offset));
+extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
+                       __off64_t __offset) __THROW;
+extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
+                        __off64_t __offset) __THROW;
 # endif
 #endif
 
@@ -351,7 +352,7 @@ extern ssize_t pwrite64 __P ((int __fd, __const __ptr_t __buf, size_t __n,
    If successful, two file descriptors are stored in PIPEDES;
    bytes written on PIPEDES[1] can be read from PIPEDES[0].
    Returns 0 if successful, -1 if not.  */
-extern int pipe __P ((int __pipedes[2]));
+extern int pipe (int __pipedes[2]) __THROW;
 
 /* Schedule an alarm.  In SECONDS seconds, the process will get a SIGALRM.
    If SECONDS is zero, any currently scheduled alarm will be cancelled.
@@ -360,7 +361,7 @@ extern int pipe __P ((int __pipedes[2]));
    There is no return value to indicate an error, but you can set `errno'
    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 __P ((unsigned int __seconds));
+extern unsigned int alarm (unsigned int __seconds) __THROW;
 
 /* Make the process sleep for SECONDS seconds, or until a signal arrives
    and is not ignored.  The function returns the number of seconds less
@@ -369,49 +370,49 @@ extern unsigned int alarm __P ((unsigned int __seconds));
    SIGALRM signal while inside `sleep' call, the handling of the SIGALRM
    signal afterwards is undefined.  There is no return value to indicate
    error, but if `sleep' returns SECONDS, it probably didn't work.  */
-extern unsigned int sleep __P ((unsigned int __seconds));
+extern unsigned int sleep (unsigned int __seconds) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Set an alarm to go off (generating a SIGALRM signal) in VALUE
    microseconds.  If INTERVAL is nonzero, when the alarm goes off, the
    timer is reset to go off every INTERVAL microseconds thereafter.
    Returns the number of microseconds remaining before the alarm.  */
-extern __useconds_t ualarm __P ((__useconds_t __value,
-                                __useconds_t __interval));
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     __THROW;
 
 /* Sleep USECONDS microseconds, or until a signal arrives that is not blocked
    or ignored.  */
-extern void usleep __P ((__useconds_t __useconds));
+extern void usleep (__useconds_t __useconds) __THROW;
 #endif
 
 
 /* Suspend the process until a signal arrives.
    This always returns -1 and sets `errno' to EINTR.  */
-extern int pause __P ((void));
+extern int pause (void) __THROW;
 
 
 /* Change the owner and group of FILE.  */
-extern int chown __P ((__const char *__file, __uid_t __owner,
-                      __gid_t __group));
+extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
+     __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Change the owner and group of the file that FD is open on.  */
-extern int fchown __P ((int __fd, __uid_t __owner, __gid_t __group));
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __THROW;
 
 
 /* Change owner and group of FILE, if it is a symbolic
    link the ownership of the symbolic link is changed.  */
-extern int lchown __P ((__const char *__file, __uid_t __owner,
-                       __gid_t __group));
+extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
+     __THROW;
 
 #endif /* Use BSD || X/Open Unix.  */
 
 /* Change the process's working directory to PATH.  */
-extern int chdir __P ((__const char *__path));
+extern int chdir (__const char *__path) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Change the process's working directory to the one FD is open on.  */
-extern int fchdir __P ((int __fd));
+extern int fchdir (int __fd) __THROW;
 #endif
 
 /* Get the pathname of the current working directory,
@@ -421,28 +422,28 @@ extern int fchdir __P ((int __fd));
    an array is allocated with `malloc'; the array is SIZE
    bytes long, unless SIZE == 0, in which case it is as
    big as necessary.  */
-extern char *getcwd __P ((char *__buf, size_t __size));
+extern char *getcwd (char *__buf, size_t __size) __THROW;
 
 #ifdef __USE_GNU
 /* Return a malloc'd string containing the current directory name.
    If the environment variable `PWD' is set, and its value is correct,
    that value is used.  */
-extern char *get_current_dir_name __P ((void));
+extern char *get_current_dir_name (void) __THROW;
 #endif
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Put the absolute pathname of the current working directory in BUF.
    If successful, return BUF.  If not, put an error message in
    BUF and return NULL.  BUF should be at least PATH_MAX bytes long.  */
-extern char *getwd __P ((char *__buf));
+extern char *getwd (char *__buf) __THROW;
 #endif
 
 
 /* Duplicate FD, returning a new file descriptor on the same file.  */
-extern int dup __P ((int __fd));
+extern int dup (int __fd) __THROW;
 
 /* Duplicate FD to FD2, closing FD2 and making it open on the same file.  */
-extern int dup2 __P ((int __fd, int __fd2));
+extern int dup2 (int __fd, int __fd2) __THROW;
 
 /* NULL-terminated array of "NAME=VALUE" environment variables.  */
 extern char **__environ;
@@ -453,47 +454,46 @@ extern char **environ;
 
 /* Replace the current process, executing PATH with arguments ARGV and
    environment ENVP.  ARGV and ENVP are terminated by NULL pointers.  */
-extern int execve __P ((__const char *__path, char *__const __argv[],
-                       char *__const __envp[]));
+extern int execve (__const char *__path, char *__const __argv[],
+                  char *__const __envp[]) __THROW;
 
 #ifdef __USE_GNU
 /* Execute the file FD refers to, overlaying the running program image.
    ARGV and ENVP are passed to the new program, as for `execve'.  */
-extern int fexecve __P ((int __fd,
-                        char *__const __argv[], char *__const __envp[]));
-
+extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
+     __THROW;
 #endif
 
 
 /* Execute PATH with arguments ARGV and environment from `environ'.  */
-extern int execv __P ((__const char *__path, char *__const __argv[]));
+extern int execv (__const char *__path, char *__const __argv[]) __THROW;
 
 /* Execute PATH with all arguments after PATH until a NULL pointer,
    and the argument after that for environment.  */
-extern int execle __P ((__const char *__path, __const char *__arg, ...));
+extern int execle (__const char *__path, __const char *__arg, ...) __THROW;
 
 /* Execute PATH with all arguments after PATH until
    a NULL pointer and environment from `environ'.  */
-extern int execl __P ((__const char *__path, __const char *__arg, ...));
+extern int execl (__const char *__path, __const char *__arg, ...) __THROW;
 
 /* Execute FILE, searching in the `PATH' environment variable if it contains
    no slashes, with arguments ARGV and environment from `environ'.  */
-extern int execvp __P ((__const char *__file, char *__const __argv[]));
+extern int execvp (__const char *__file, char *__const __argv[]) __THROW;
 
 /* 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 __P ((__const char *__file, __const char *__arg, ...));
+extern int execlp (__const char *__file, __const char *__arg, ...) __THROW;
 
 
 #if defined __USE_MISC || defined __USE_XOPEN
 /* Add INC to priority of the current process.  */
-extern int nice __P ((int __inc));
+extern int nice (int __inc) __THROW;
 #endif
 
 
 /* Terminate program execution with the low-order 8 bits of STATUS.  */
-extern void _exit __PMT ((int __status)) __attribute__ ((__noreturn__));
+extern void _exit (int __status) __attribute__ ((__noreturn__));
 
 
 /* Get the `_PC_*' symbols for the NAME argument to `pathconf' and `fpathconf';
@@ -502,51 +502,51 @@ extern void _exit __PMT ((int __status)) __attribute__ ((__noreturn__));
 #include <bits/confname.h>
 
 /* Get file-specific configuration information about PATH.  */
-extern long int pathconf __P ((__const char *__path, int __name));
+extern long int pathconf (__const char *__path, int __name) __THROW;
 
 /* Get file-specific configuration about descriptor FD.  */
-extern long int fpathconf __P ((int __fd, int __name));
+extern long int fpathconf (int __fd, int __name) __THROW;
 
 /* Get the value of the system variable NAME.  */
-extern long int sysconf __P ((int __name));
+extern long int sysconf (int __name) __THROW;
 
 #ifdef __USE_POSIX2
 /* Get the value of the string-valued system variable NAME.  */
-extern size_t confstr __P ((int __name, char *__buf, size_t __len));
+extern size_t confstr (int __name, char *__buf, size_t __len) __THROW;
 #endif
 
 
 /* Get the process ID of the calling process.  */
-extern __pid_t __getpid __P ((void));
-extern __pid_t getpid __P ((void));
+extern __pid_t __getpid (void) __THROW;
+extern __pid_t getpid (void) __THROW;
 
 /* Get the process ID of the calling process's parent.  */
-extern __pid_t getppid __P ((void));
+extern __pid_t getppid (void) __THROW;
 
 /* Get the process group ID of the calling process.
    This function is different on old BSD. */
 #ifndef __FAVOR_BSD
-extern __pid_t getpgrp __P ((void));
+extern __pid_t getpgrp (void) __THROW;
 #else
 # ifdef __REDIRECT
-extern __pid_t __REDIRECT (getpgrp, __P ((__pid_t __pid)), __getpgid);
+extern __pid_t __REDIRECT (getpgrp, (__pid_t __pid) __THROW, __getpgid);
 # else
 #  define getpgrp __getpgid
 # endif
 #endif
 
 /* Get the process group ID of process PID.  */
-extern __pid_t __getpgid __P ((__pid_t __pid));
+extern __pid_t __getpgid (__pid_t __pid) __THROW;
 #ifdef __USE_XOPEN_EXTENDED
-extern __pid_t getpgid __P ((__pid_t __pid));
+extern __pid_t getpgid (__pid_t __pid) __THROW;
 #endif
 
 
 /* Set the process group ID of the process matching PID to PGID.
    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 __P ((__pid_t __pid, __pid_t __pgid));
-extern int setpgid __P ((__pid_t __pid, __pid_t __pgid));
+extern int __setpgid (__pid_t __pid, __pid_t __pgid) __THROW;
+extern int setpgid (__pid_t __pid, __pid_t __pgid) __THROW;
 
 #if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Both System V and BSD have `setpgrp' functions, but with different
@@ -563,13 +563,13 @@ extern int setpgid __P ((__pid_t __pid, __pid_t __pgid));
 
 /* Set the process group ID of the calling process to its own PID.
    This is exactly the same as `setpgid (0, 0)'.  */
-extern int setpgrp __P ((void));
+extern int setpgrp (void) __THROW;
 
 # else
 
 /* Another name for `setpgid' (above).  */
 #  ifdef __REDIRECT
-extern int __REDIRECT (setpgrp, __P ((__pid_t __pid, __pid_t __pgrp)),
+extern int __REDIRECT (setpgrp, (__pid_t __pid, __pid_t __pgrp) __THROW,
                       setpgid);
 #  else
 #   define setpgrp setpgid
@@ -581,143 +581,143 @@ extern int __REDIRECT (setpgrp, __P ((__pid_t __pid, __pid_t __pgrp)),
 /* Create a new session with the calling process as its leader.
    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 __P ((void));
+extern __pid_t setsid (void) __THROW;
 
 #ifdef __USE_XOPEN_EXTENDED
 /* Return the session ID of the given process.  */
-extern __pid_t getsid __P ((__pid_t __pid));
+extern __pid_t getsid (__pid_t __pid) __THROW;
 #endif
 
 /* Get the real user ID of the calling process.  */
-extern __uid_t getuid __P ((void));
+extern __uid_t getuid (void) __THROW;
 
 /* Get the effective user ID of the calling process.  */
-extern __uid_t geteuid __P ((void));
+extern __uid_t geteuid (void) __THROW;
 
 /* Get the real group ID of the calling process.  */
-extern __gid_t getgid __P ((void));
+extern __gid_t getgid (void) __THROW;
 
 /* Get the effective group ID of the calling process.  */
-extern __gid_t getegid __P ((void));
+extern __gid_t getegid (void) __THROW;
 
 /* 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 __P ((int __size, __gid_t __list[]));
+extern int getgroups (int __size, __gid_t __list[]) __THROW;
 
 #ifdef __USE_GNU
 /* Return nonzero iff the calling process is in group GID.  */
-extern int group_member __P ((__gid_t __gid));
+extern int group_member (__gid_t __gid) __THROW;
 #endif
 
 /* Set the user ID of the calling process to UID.
    If the calling process is the super-user, set the real
    and effective user IDs, and the saved set-user-ID to UID;
    if not, the effective user ID is set to UID.  */
-extern int setuid __P ((__uid_t __uid));
+extern int setuid (__uid_t __uid) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* 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 __P ((__uid_t __ruid, __uid_t __euid));
+extern int setreuid (__uid_t __ruid, __uid_t __euid) __THROW;
 #endif
 
 #ifdef __USE_BSD
 /* Set the effective user ID of the calling process to UID.  */
-extern int seteuid __P ((__uid_t __uid));
+extern int seteuid (__uid_t __uid) __THROW;
 #endif /* Use BSD.  */
 
 /* Set the group ID of the calling process to GID.
    If the calling process is the super-user, set the real
    and effective group IDs, and the saved set-group-ID to GID;
    if not, the effective group ID is set to GID.  */
-extern int setgid __P ((__gid_t __gid));
+extern int setgid (__gid_t __gid) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* 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 __P ((__gid_t __rgid, __gid_t __egid));
+extern int setregid (__gid_t __rgid, __gid_t __egid) __THROW;
 #endif
 
 #ifdef __USE_BSD
 /* Set the effective group ID of the calling process to GID.  */
-extern int setegid __P ((__gid_t __gid));
+extern int setegid (__gid_t __gid) __THROW;
 #endif /* Use BSD.  */
 
 
 /* Clone the calling process, creating an exact copy.
    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 __P ((void));
-extern __pid_t fork __P ((void));
+extern __pid_t __fork (void) __THROW;
+extern __pid_t fork (void) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Clone the calling process, but without copying the whole address space.
    The calling process is suspended until the new process exits or is
    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 __P ((void));
+extern __pid_t vfork (void) __THROW;
 #endif /* Use BSD. */
 
 
 /* Return the pathname of the terminal FD is open on, or NULL on errors.
    The returned storage is good only until the next call to this function.  */
-extern char *ttyname __P ((int __fd));
+extern char *ttyname (int __fd) __THROW;
 
 /* Store at most BUFLEN characters of the pathname of the terminal FD is
    open on in BUF.  Return 0 on success, otherwise an error number.  */
-extern int ttyname_r __P ((int __fd, char *__buf, size_t __buflen));
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen) __THROW;
 
 /* Return 1 if FD is a valid descriptor associated
    with a terminal, zero if not.  */
-extern int isatty __P ((int __fd));
+extern int isatty (int __fd) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Return the index into the active-logins file (utmp) for
    the controlling terminal.  */
-extern int ttyslot __P ((void));
+extern int ttyslot (void) __THROW;
 #endif
 
 
 /* Make a link to FROM named TO.  */
-extern int link __P ((__const char *__from, __const char *__to));
+extern int link (__const char *__from, __const char *__to) __THROW;
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Make a symbolic link to FROM named TO.  */
-extern int symlink __P ((__const char *__from, __const char *__to));
+extern int symlink (__const char *__from, __const char *__to) __THROW;
 
 /* Read the contents of the symbolic link PATH into no more than
    LEN bytes of BUF.  The contents are not null-terminated.
    Returns the number of characters read, or -1 for errors.  */
-extern int readlink __P ((__const char *__path, char *__buf, size_t __len));
+extern int readlink (__const char *__path, char *__buf, size_t __len) __THROW;
 #endif /* Use BSD.  */
 
 /* Remove the link NAME.  */
-extern int unlink __P ((__const char *__name));
+extern int unlink (__const char *__name) __THROW;
 
 /* Remove the directory PATH.  */
-extern int rmdir __P ((__const char *__path));
+extern int rmdir (__const char *__path) __THROW;
 
 
 /* Return the foreground process group ID of FD.  */
-extern __pid_t tcgetpgrp __P ((int __fd));
+extern __pid_t tcgetpgrp (int __fd) __THROW;
 
 /* Set the foreground process group ID of FD set PGRP_ID.  */
-extern int tcsetpgrp __P ((int __fd, __pid_t __pgrp_id));
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __THROW;
 
 
 /* Return the login name of the user.  */
-extern char *getlogin __P ((void));
+extern char *getlogin (void) __THROW;
 #ifdef __USE_REENTRANT
 /* 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
    code.  Otherwise return 0.  */
-extern int getlogin_r __P ((char *__name, size_t __name_len));
+extern int getlogin_r (char *__name, size_t __name_len) __THROW;
 #endif
 
 #ifdef __USE_BSD
 /* Set the login name returned by `getlogin'.  */
-extern int setlogin __P ((__const char *__name));
+extern int setlogin (__const char *__name) __THROW;
 #endif
 
 
@@ -735,35 +735,35 @@ extern int setlogin __P ((__const char *__name));
 /* Put the name of the current host in no more than LEN bytes of NAME.
    The result is null-terminated if LEN is large enough for the full
    name and the terminator.  */
-extern int gethostname __P ((char *__name, size_t __len));
+extern int gethostname (char *__name, size_t __len) __THROW;
 
 /* Set the name of the current host to NAME, which is LEN bytes long.
    This call is restricted to the super-user.  */
-extern int sethostname __P ((__const char *__name, size_t __len));
+extern int sethostname (__const char *__name, size_t __len) __THROW;
 
 /* Set the current machine's Internet number to ID.
    This call is restricted to the super-user.  */
-extern int sethostid __P ((long int __id));
+extern int sethostid (long int __id) __THROW;
 
 
 /* Get and set the NIS (aka YP) domain name, if any.
    Called just like `gethostname' and `sethostname'.
    The NIS domain name is usually the empty string when not using NIS.  */
-extern int getdomainname __P ((char *__name, size_t __len));
-extern int setdomainname __P ((__const char *__name, size_t __len));
+extern int getdomainname (char *__name, size_t __len) __THROW;
+extern int setdomainname (__const char *__name, size_t __len) __THROW;
 
 
 /* Make all changes done to FD actually appear on disk.  */
-extern int fsync __P ((int __fd));
+extern int fsync (int __fd) __THROW;
 
 
 /* Revoke access permissions to all processes currently communicating
    with the control terminal, and then send a SIGHUP signal to the process
    group of the control terminal.  */
-extern int vhangup __P ((void));
+extern int vhangup (void) __THROW;
 
 /* Revoke the access of all descriptors currently open on FILE.  */
-extern int revoke __P ((__const char *__file));
+extern int revoke (__const char *__file) __THROW;
 
 
 /* Enable statistical profiling, writing samples of the PC into at most
@@ -771,34 +771,34 @@ extern int revoke __P ((__const char *__file));
    is enabled, the system examines the user PC and increments
    SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536].  If SCALE is zero,
    disable profiling.  Returns zero on success, -1 on error.  */
-extern int profil __P ((unsigned short int *__sample_buffer, size_t __size,
-                       size_t __offset, unsigned int __scale));
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+                  size_t __offset, unsigned int __scale) __THROW;
 
 
 /* Turn accounting on if NAME is an existing file.  The system will then write
    a record for each process as it terminates, to this file.  If NAME is NULL,
    turn accounting off.  This call is restricted to the super-user.  */
-extern int acct __P ((__const char *__name));
+extern int acct (__const char *__name) __THROW;
 
 /* Make PATH be the root directory (the starting point for absolute paths).
    This call is restricted to the super-user.  */
-extern int chroot __P ((__const char *__path));
+extern int chroot (__const char *__path) __THROW;
 
 
 /* Successive calls return the shells listed in `/etc/shells'.  */
-extern char *getusershell __P ((void));
-extern void endusershell __P ((void)); /* Discard cached info.  */
-extern void setusershell __P ((void)); /* Rewind and re-read the file.  */
+extern char *getusershell (void) __THROW;
+extern void endusershell (void) __THROW; /* Discard cached info.  */
+extern void setusershell (void) __THROW; /* Rewind and re-read the file.  */
 
 
 /* Prompt with PROMPT and read a string from the terminal without echoing.
    Uses /dev/tty if possible; otherwise stderr and stdin.  */
-extern char *getpass __P ((__const char *__prompt));
+extern char *getpass (__const char *__prompt) __THROW;
 
 /* Put the program in the background, and dissociate from the controlling
    terminal.  If NOCHDIR is zero, do `chdir ("/")'.  If NOCLOSE is zero,
    redirects stdin, stdout, and stderr to /dev/null.  */
-extern int daemon __P ((int __nochdir, int __noclose));
+extern int daemon (int __nochdir, int __noclose) __THROW;
 
 #endif /* Use BSD || X/Open.  */
 
@@ -806,54 +806,54 @@ extern int daemon __P ((int __nochdir, int __noclose));
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 
 /* Return the current machine's Internet number.  */
-extern long int gethostid __P ((void));
+extern long int gethostid (void) __THROW;
 
 /* Make all changes done to all files actually appear on disk.  */
-extern int sync __P ((void));
+extern int sync (void) __THROW;
 
 
 /* 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 __P ((void));
-extern int getpagesize __P ((void));
+extern int __getpagesize (void) __THROW;
+extern int getpagesize (void) __THROW;
 
 
 /* Truncate FILE to LENGTH bytes.  */
 #ifndef __USE_FILE_OFFSET64
-extern int truncate __P ((__const char *__file, __off_t __length));
+extern int truncate (__const char *__file, __off_t __length) __THROW;
 #else
 # ifdef __REDIRECT
 extern int __REDIRECT (truncate,
-                      __P ((__const char *__file, __off64_t __length)),
+                      (__const char *__file, __off64_t __length) __THROW,
                       truncate64);
 # else
 #  define truncate truncate64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int truncate64 __P ((__const char *__file, __off64_t __length));
+extern int truncate64 (__const char *__file, __off64_t __length) __THROW;
 #endif
 
 /* Truncate the file FD is open on to LENGTH bytes.  */
-extern int __ftruncate __P ((int __fd, __off_t __length));
+extern int __ftruncate (int __fd, __off_t __length) __THROW;
 #ifndef __USE_FILE_OFFSET64
-extern int ftruncate __P ((int __fd, __off_t __length));
+extern int ftruncate (int __fd, __off_t __length) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (ftruncate, __P ((int __fd, __off64_t __length)),
+extern int __REDIRECT (ftruncate, (int __fd, __off64_t __length) __THROW,
                       ftruncate64);
 # else
 #  define ftruncate ftruncate64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int ftruncate64 __P ((int __fd, __off64_t __length));
+extern int ftruncate64 (int __fd, __off64_t __length) __THROW;
 #endif
 
 
 /* Return the maximum number of file descriptors
    the current process could possibly have.  */
-extern int getdtablesize __P ((void));
+extern int getdtablesize (void) __THROW;
 
 #endif /* Use BSD || X/Open Unix.  */
 
@@ -862,7 +862,7 @@ extern int getdtablesize __P ((void));
 
 /* Set the end of accessible data space (aka "the break") to ADDR.
    Returns zero on success and -1 for errors (with errno set).  */
-extern int brk __P ((__ptr_t __addr));
+extern int brk (void *__addr) __THROW;
 
 # define __need_ptrdiff_t
 # include <stddef.h>
@@ -871,8 +871,8 @@ extern int brk __P ((__ptr_t __addr));
    If successful, returns the address the previous end of data space
    (i.e. the beginning of the new space, if DELTA > 0);
    returns (void *) -1 for errors (with errno set).  */
-extern __ptr_t __sbrk __P ((ptrdiff_t __delta));
-extern __ptr_t sbrk __P ((ptrdiff_t __delta));
+extern void *__sbrk (ptrdiff_t __delta) __THROW;
+extern void *sbrk (ptrdiff_t __delta) __THROW;
 #endif
 
 
@@ -887,7 +887,7 @@ extern __ptr_t sbrk __P ((ptrdiff_t __delta));
 
    In Mach, all system calls take normal arguments and always return an
    error code (zero for success).  */
-extern long int syscall __P ((long int __sysno, ...));
+extern long int syscall (long int __sysno, ...) __THROW;
 
 #endif /* Use misc.  */
 
@@ -907,17 +907,17 @@ extern long int syscall __P ((long int __sysno, ...));
 # define F_TEST  3     /* Test a region for other processes locks.  */
 
 # ifndef __USE_FILE_OFFSET64
-extern int lockf __P ((int __fd, int __cmd, __off_t __len));
+extern int lockf (int __fd, int __cmd, __off_t __len) __THROW;
 # else
 #  ifdef __REDIRECT
-extern int __REDIRECT (lockf, __P ((int __fd, int __cmd, __off64_t __len)),
+extern int __REDIRECT (lockf, (int __fd, int __cmd, __off64_t __len) __THROW,
                       lockf64);
 #  else
 #   define lockf lockf64
 #  endif
 # endif
 # ifdef __USE_LARGEFILE64
-extern int lockf64 __P ((int __fd, int __cmd, __off64_t __len));
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) __THROW;
 # endif
 #endif /* Use misc and F_LOCK not already defined.  */
 
@@ -938,7 +938,7 @@ extern int lockf64 __P ((int __fd, int __cmd, __off64_t __len));
 #if defined __USE_POSIX199309 || defined __USE_UNIX98
 /* Synchronize at least the data part of a file with the underlying
    media.  */
-extern int fdatasync __P ((int __fildes));
+extern int fdatasync (int __fildes) __THROW;
 #endif /* Use POSIX199309 */
 
 
@@ -946,21 +946,21 @@ extern int fdatasync __P ((int __fildes));
    be defined here.  */
 #ifdef __USE_XOPEN
 /* Encrypt at most 8 characters from KEY using salt to perturb DES.  */
-extern char *crypt __P ((__const char *__key, __const char *__salt));
+extern char *crypt (__const char *__key, __const char *__salt) __THROW;
 
 /* Setup DES tables according KEY.  */
-extern void setkey __P ((__const char *__key));
+extern void setkey (__const char *__key) __THROW;
 
 /* Encrypt data in BLOCK in place if EDFLAG is zero; otherwise decrypt
    block in place.  */
-extern void encrypt __P ((char *__block, int __edflag));
+extern void encrypt (char *__block, int __edflag) __THROW;
 
 
 /* Swab pairs bytes in the first N bytes of the area pointed to by
    FROM and copy the result to TO.  The value of TO must not be in the
    range [FROM - N + 1, FROM - 1].  If N is odd the first byte in FROM
    is without partner.  */
-extern void swab __P ((__const __ptr_t __from, __ptr_t __to, ssize_t __n));
+extern void swab (__const void *__from, void *__to, ssize_t __n) __THROW;
 #endif
 
 
@@ -968,14 +968,14 @@ extern void swab __P ((__const __ptr_t __from, __ptr_t __to, ssize_t __n));
    to be here.  They are also found in <stdio.h>.  */
 #ifdef __USE_XOPEN
 /* Return the name of the controlling terminal.  */
-extern char *ctermid __P ((char *__s));
+extern char *ctermid (char *__s) __THROW;
 
 /* Return the name of the current user.  This function should not be
    used and might go away some time.  */
-extern char *cuserid __P ((char *__s));
+extern char *cuserid (char *__s) __THROW;
 
 /* Rename file OLD to NEW.  */
-extern int rename __P ((__const char *__old, __const char *__new));
+extern int rename (__const char *__old, __const char *__new) __THROW;
 #endif
 
 
@@ -992,9 +992,9 @@ extern int rename __P ((__const char *__old, __const char *__new));
    handlers are called in LIFO order (last added with PTHREAD_ATFORK,
    first called before FORK), and the PARENT and CHILD handlers are called
    in FIFO (first added, first called). */
-extern int pthread_atfork __P ((void (*__prepare) (void),
-                               void (*__parent) (void),
-                               void (*__child) (void)));
+extern int pthread_atfork (void (*__prepare) (void),
+                          void (*__parent) (void),
+                          void (*__child) (void)) __THROW;
 #endif
 
 __END_DECLS
index 32c2a3f..14840f6 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -58,11 +58,11 @@ enum
   };
 
 /* Do word expansion of WORDS into PWORDEXP.  */
-extern int wordexp __P ((__const char *__restrict __words,
-                        wordexp_t *__restrict __pwordexp, int __flags));
+extern int wordexp (__const char *__restrict __words,
+                   wordexp_t *__restrict __pwordexp, int __flags) __THROW;
 
 /* Free the storage allocated by a `wordexp' call.  */
-extern void wordfree __P ((wordexp_t *__wordexp));
+extern void wordfree (wordexp_t *__wordexp) __THROW;
 
 __END_DECLS
 
index a528a51..651b9da 100644 (file)
--- a/pwd/pwd.h
+++ b/pwd/pwd.h
@@ -67,29 +67,29 @@ struct passwd
 
 #if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN_EXTENDED
 /* Rewind the password-file stream.  */
-extern void setpwent __P ((void));
+extern void setpwent (void) __THROW;
 
 /* Close the password-file stream.  */
-extern void endpwent __P ((void));
+extern void endpwent (void) __THROW;
 
 /* Read an entry from the password-file stream, opening it if necessary.  */
-extern struct passwd *getpwent __P ((void));
+extern struct passwd *getpwent (void) __THROW;
 #endif
 
 #ifdef __USE_SVID
 /* Read an entry from STREAM.  */
-extern struct passwd *fgetpwent __P ((FILE *__stream));
+extern struct passwd *fgetpwent (FILE *__stream) __THROW;
 
 /* Write the given entry onto the given stream.  */
-extern int putpwent __P ((__const struct passwd *__restrict __p,
-                         FILE *__restrict __f));
+extern int putpwent (__const struct passwd *__restrict __p,
+                    FILE *__restrict __f) __THROW;
 #endif
 
 /* Search for an entry with a matching user ID.  */
-extern struct passwd *getpwuid __P ((__uid_t __uid));
+extern struct passwd *getpwuid (__uid_t __uid) __THROW;
 
 /* Search for an entry with a matching username.  */
-extern struct passwd *getpwnam __P ((__const char *__name));
+extern struct passwd *getpwnam (__const char *__name) __THROW;
 
 #if defined __USE_POSIX || defined __USE_MISC
 
@@ -108,29 +108,29 @@ extern struct passwd *getpwnam __P ((__const char *__name));
    POSIX people would choose.  */
 
 # if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN_EXTENDED
-extern int getpwent_r __P ((struct passwd *__restrict __resultbuf,
-                           char *__restrict __buffer, size_t __buflen,
-                           struct passwd **__restrict __result));
+extern int getpwent_r (struct passwd *__restrict __resultbuf,
+                      char *__restrict __buffer, size_t __buflen,
+                      struct passwd **__restrict __result) __THROW;
 # endif
 
-extern int getpwuid_r __P ((__uid_t __uid,
-                           struct passwd *__restrict __resultbuf,
-                           char *__restrict __buffer, size_t __buflen,
-                           struct passwd **__restrict __result));
+extern int getpwuid_r (__uid_t __uid,
+                      struct passwd *__restrict __resultbuf,
+                      char *__restrict __buffer, size_t __buflen,
+                      struct passwd **__restrict __result) __THROW;
 
-extern int getpwnam_r __P ((__const char *__restrict __name,
-                           struct passwd *__restrict __resultbuf,
-                           char *__restrict __buffer, size_t __buflen,
-                           struct passwd **__restrict __result));
+extern int getpwnam_r (__const char *__restrict __name,
+                      struct passwd *__restrict __resultbuf,
+                      char *__restrict __buffer, size_t __buflen,
+                      struct passwd **__restrict __result) __THROW;
 
 
 # ifdef        __USE_SVID
 /* Read an entry from STREAM.  This function is not standardized and
    probably never will.  */
-extern int fgetpwent_r __P ((FILE *__restrict __stream,
-                            struct passwd *__restrict __resultbuf,
-                            char *__restrict __buffer, size_t __buflen,
-                            struct passwd **__restrict __result));
+extern int fgetpwent_r (FILE *__restrict __stream,
+                       struct passwd *__restrict __resultbuf,
+                       char *__restrict __buffer, size_t __buflen,
+                       struct passwd **__restrict __result) __THROW;
 # endif
 
 #endif /* POSIX or reentrant */
@@ -139,7 +139,7 @@ extern int fgetpwent_r __P ((FILE *__restrict __stream,
 /* Re-construct the password-file line for the given uid
    in the given buffer.  This knows the format that the caller
    will expect, but this need not be the format of the password file.  */
-extern int getpw __P ((__uid_t __uid, char *__buffer));
+extern int getpw (__uid_t __uid, char *__buffer) __THROW;
 #endif
 
 __END_DECLS
index 0dd5917..45a80dc 100644 (file)
@@ -47,7 +47,7 @@ __BEGIN_DECLS
 extern int h_errno;
 
 /* Function to get address of global `h_errno' variable.  */
-extern int *__h_errno_location __P ((void)) __attribute__ ((__const__));
+extern int *__h_errno_location (void) __THROW __attribute__ ((__const__));
 
 #ifdef _LIBC
 # ifdef _LIBC_REENTRANT
@@ -82,10 +82,10 @@ __set_h_errno (int __err)
 
 /* Print error indicated by `h_errno' variable on standard error.  STR
    if non-null is printed before the error string.  */
-extern void herror __P ((__const char *__str));
+extern void herror (__const char *__str) __THROW;
 
 /* Return string associated with error ERR_NUM.  */
-extern __const char *hstrerror __P ((int __err_num));
+extern __const char *hstrerror (int __err_num) __THROW;
 
 
 
@@ -102,39 +102,38 @@ struct hostent
 
 /* Open host data base files and mark them as staying open even after
    a later search if STAY_OPEN is non-zero.  */
-extern void sethostent __P ((int __stay_open));
+extern void sethostent (int __stay_open) __THROW;
 
 /* Close host data base files and clear `stay open' flag.  */
-extern void endhostent __P ((void));
+extern void endhostent (void) __THROW;
 
 /* Get next entry from host data base file.  Open data base if
    necessary.  */
-extern struct hostent *gethostent __P ((void));
+extern struct hostent *gethostent (void) __THROW;
 
 /* Return entry from host data base which address match ADDR with
    length LEN and type TYPE.  */
-extern struct hostent *gethostbyaddr __P ((__const char *__addr, size_t __len,
-                                          int __type));
+extern struct hostent *gethostbyaddr (__const char *__addr, size_t __len,
+                                     int __type) __THROW;
 
 /* Return entry from host data base for host with NAME.  */
-extern struct hostent *gethostbyname __P ((__const char *__name));
+extern struct hostent *gethostbyname (__const char *__name) __THROW;
 
 /* Return entry from host data base for host with NAME.  AF must be
    set to the address type which is `AF_INET' for IPv4 or `AF_INET6'
    for IPv6.  */
-extern struct hostent *gethostbyname2 __P ((__const char *__name, int __af));
+extern struct hostent *gethostbyname2 (__const char *__name, int __af) __THROW;
 
 #ifdef __USE_UNIX98
 /* Return entry from host data base which address match ADDR with
    length LEN and type TYPE in newly allocated buffer.  */
-extern struct hostent *getipnodebyaddr __P ((__const char *__addr,
-                                            size_t __len, int __type,
-                                            int *__error_num));
+extern struct hostent *getipnodebyaddr (__const char *__addr, size_t __len,
+                                       int __type, int *__error_num) __THROW;
 
 /* Return entry from host data base for host with NAME and newly allocated
    buffer.  FLAGS is some combination of the following AI_* values.  */
-extern struct hostent *getipnodebyname __P ((__const char *__name, int __type,
-                                            int __flags, int *__error_num));
+extern struct hostent *getipnodebyname (__const char *__name, int __type,
+                                       int __flags, int *__error_num) __THROW;
 
 # define AI_V4MAPPED   1       /* IPv4-mapped addresses are acceptable.  */
 # define AI_ALL                2       /* Return both IPv4 and IPv6 addresses.  */
@@ -144,7 +143,7 @@ extern struct hostent *getipnodebyname __P ((__const char *__name, int __type,
 
 /* Free structure returned by previous `getipnodebyaddr' or `getipnodebyname'
    call.  */
-extern void freehostent __P ((struct hostent *__ptr));
+extern void freehostent (struct hostent *__ptr) __THROW;
 
 #endif
 
@@ -154,29 +153,29 @@ extern void freehostent __P ((struct hostent *__ptr));
    argument is a pointer to a variable which gets the value which
    would be stored in the global variable `herrno' by the
    non-reentrant functions.  */
-extern int gethostent_r __P ((struct hostent *__restrict __result_buf,
-                             char *__restrict __buf, size_t __buflen,
-                             struct hostent **__restrict __result,
-                             int *__restrict __h_errnop));
-
-extern int gethostbyaddr_r __P ((__const char *__restrict __addr, size_t __len,
-                                int __type,
-                                struct hostent *__restrict __result_buf,
-                                char *__restrict __buf, size_t __buflen,
-                                struct hostent **__restrict __result,
-                                int *__restrict __h_errnop));
-
-extern int gethostbyname_r __P ((__const char *__restrict __name,
-                                struct hostent *__restrict __result_buf,
-                                char *__restrict __buf, size_t __buflen,
-                                struct hostent **__restrict __result,
-                                int *__restrict __h_errnop));
-
-extern int gethostbyname2_r __P ((__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));
+extern int gethostent_r (struct hostent *__restrict __result_buf,
+                        char *__restrict __buf, size_t __buflen,
+                        struct hostent **__restrict __result,
+                        int *__restrict __h_errnop) __THROW;
+
+extern int gethostbyaddr_r (__const char *__restrict __addr, size_t __len,
+                           int __type,
+                           struct hostent *__restrict __result_buf,
+                           char *__restrict __buf, size_t __buflen,
+                           struct hostent **__restrict __result,
+                           int *__restrict __h_errnop) __THROW;
+
+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) __THROW;
+
+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) __THROW;
 #endif /* misc */
 
 
@@ -193,22 +192,22 @@ struct netent
 
 /* Open network data base files and mark them as staying open even
    after a later search if STAY_OPEN is non-zero.  */
-extern void setnetent __P ((int __stay_open));
+extern void setnetent (int __stay_open) __THROW;
 
 /* Close network data base files and clear `stay open' flag.  */
-extern void endnetent __P ((void));
+extern void endnetent (void) __THROW;
 
 /* Get next entry from network data base file.  Open data base if
    necessary.  */
-extern struct netent *getnetent __P ((void));
+extern struct netent *getnetent (void) __THROW;
 
 /* Return entry from network data base which address match NET and
    type TYPE.  */
-extern struct netent *getnetbyaddr __P ((unsigned long int __net,
-                                        int __type));
+extern struct netent *getnetbyaddr (unsigned long int __net, int __type)
+     __THROW;
 
 /* Return entry from network data base for network with NAME.  */
-extern struct netent *getnetbyname __P ((__const char *__name));
+extern struct netent *getnetbyname (__const char *__name) __THROW;
 
 #ifdef __USE_MISC
 /* Reentrant versions of the functions above.  The additional
@@ -216,22 +215,22 @@ extern struct netent *getnetbyname __P ((__const char *__name));
    argument is a pointer to a variable which gets the value which
    would be stored in the global variable `herrno' by the
    non-reentrant functions.  */
-extern int getnetent_r __P ((struct netent *__restrict __result_buf,
-                            char *__restrict __buf, size_t __buflen,
-                            struct netent **__restrict __result,
-                            int *__restrict __h_errnop));
-
-extern int getnetbyaddr_r __P ((unsigned long int __net, int __type,
-                               struct netent *__restrict __result_buf,
-                               char *__restrict __buf, size_t __buflen,
-                               struct netent **__restrict __result,
-                               int *__restrict __h_errnop));
-
-extern int getnetbyname_r __P ((__const char *__restrict __name,
-                               struct netent *__restrict __result_buf,
-                               char *__restrict __buf, size_t __buflen,
-                               struct netent **__restrict __result,
-                               int *__restrict __h_errnop));
+extern int getnetent_r (struct netent *__restrict __result_buf,
+                       char *__restrict __buf, size_t __buflen,
+                       struct netent **__restrict __result,
+                       int *__restrict __h_errnop) __THROW;
+
+extern int getnetbyaddr_r (unsigned long int __net, int __type,
+                          struct netent *__restrict __result_buf,
+                          char *__restrict __buf, size_t __buflen,
+                          struct netent **__restrict __result,
+                          int *__restrict __h_errnop) __THROW;
+
+extern int getnetbyname_r (__const char *__restrict __name,
+                          struct netent *__restrict __result_buf,
+                          char *__restrict __buf, size_t __buflen,
+                          struct netent **__restrict __result,
+                          int *__restrict __h_errnop) __THROW;
 #endif /* misc */
 
 
@@ -246,42 +245,43 @@ struct servent
 
 /* Open service data base files and mark them as staying open even
    after a later search if STAY_OPEN is non-zero.  */
-extern void setservent __P ((int __stay_open));
+extern void setservent (int __stay_open) __THROW;
 
 /* Close service data base files and clear `stay open' flag.  */
-extern void endservent __P ((void));
+extern void endservent (void) __THROW;
 
 /* Get next entry from service data base file.  Open data base if
    necessary.  */
-extern struct servent *getservent __P ((void));
+extern struct servent *getservent (void) __THROW;
 
 /* Return entry from network data base for network with NAME and
    protocol PROTO.  */
-extern struct servent *getservbyname __P ((__const char *__name,
-                                          __const char *__proto));
+extern struct servent *getservbyname (__const char *__name,
+                                     __const char *__proto) __THROW;
 
 /* Return entry from service data base which matches port PORT and
    protocol PROTO.  */
-extern struct servent *getservbyport __P ((int __port, __const char *__proto));
+extern struct servent *getservbyport (int __port, __const char *__proto)
+     __THROW;
 
 
 #ifdef __USE_MISC
 /* Reentrant versions of the functions above.  The additional
    arguments specify a buffer of BUFLEN starting at BUF.  */
-extern int getservent_r __P ((struct servent *__restrict __result_buf,
-                             char *__restrict __buf, size_t __buflen,
-                             struct servent **__restrict __result));
-
-extern int getservbyname_r __P ((__const char *__restrict __name,
-                                __const char *__restrict __proto,
-                                struct servent *__restrict __result_buf,
-                                char *__restrict __buf, size_t __buflen,
-                                struct servent **__restrict __result));
-
-extern int getservbyport_r __P ((int __port, __const char *__restrict __proto,
-                                struct servent *__restrict __result_buf,
-                                char *__restrict __buf, size_t __buflen,
-                                struct servent **__restrict __result));
+extern int getservent_r (struct servent *__restrict __result_buf,
+                        char *__restrict __buf, size_t __buflen,
+                        struct servent **__restrict __result) __THROW;
+
+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) __THROW;
+
+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) __THROW;
 #endif /* misc */
 
 
@@ -295,63 +295,63 @@ struct protoent
 
 /* Open protocol data base files and mark them as staying open even
    after a later search if STAY_OPEN is non-zero.  */
-extern void setprotoent __P ((int __stay_open));
+extern void setprotoent (int __stay_open) __THROW;
 
 /* Close protocol data base files and clear `stay open' flag.  */
-extern void endprotoent __P ((void));
+extern void endprotoent (void) __THROW;
 
 /* Get next entry from protocol data base file.  Open data base if
    necessary.  */
-extern struct protoent *getprotoent __P ((void));
+extern struct protoent *getprotoent (void) __THROW;
 
 /* Return entry from protocol data base for network with NAME.  */
-extern struct protoent *getprotobyname __P ((__const char *__name));
+extern struct protoent *getprotobyname (__const char *__name) __THROW;
 
 /* Return entry from protocol data base which number is PROTO.  */
-extern struct protoent *getprotobynumber __P ((int __proto));
+extern struct protoent *getprotobynumber (int __proto) __THROW;
 
 
 #ifdef __USE_MISC
 /* Reentrant versions of the functions above.  The additional
    arguments specify a buffer of BUFLEN starting at BUF.  */
-extern int getprotoent_r __P ((struct protoent *__restrict __result_buf,
-                              char *__restrict __buf, size_t __buflen,
-                              struct protoent **__restrict __result));
+extern int getprotoent_r (struct protoent *__restrict __result_buf,
+                         char *__restrict __buf, size_t __buflen,
+                         struct protoent **__restrict __result) __THROW;
 
-extern int getprotobyname_r __P ((__const char *__restrict __name,
-                                 struct protoent *__restrict __result_buf,
-                                 char *__restrict __buf, size_t __buflen,
-                                 struct protoent **__restrict __result));
+extern int getprotobyname_r (__const char *__restrict __name,
+                            struct protoent *__restrict __result_buf,
+                            char *__restrict __buf, size_t __buflen,
+                            struct protoent **__restrict __result) __THROW;
 
-extern int getprotobynumber_r __P ((int __proto,
-                                   struct protoent *__restrict __result_buf,
-                                   char *__restrict __buf, size_t __buflen,
-                                   struct protoent **__restrict __result));
+extern int getprotobynumber_r (int __proto,
+                              struct protoent *__restrict __result_buf,
+                              char *__restrict __buf, size_t __buflen,
+                              struct protoent **__restrict __result) __THROW;
 #endif /* misc */
 
 
 /* Establish network group NETGROUP for enumeration.  */
-extern int setnetgrent __P ((__const char *__netgroup));
+extern int setnetgrent (__const char *__netgroup) __THROW;
 
 /* Free all space allocated by previous `setnetgrent' call.  */
-extern void endnetgrent __P ((void));
+extern void endnetgrent (void) __THROW;
 
 /* Get next member of netgroup established by last `setnetgrent' call
    and return pointers to elements in HOSTP, USERP, and DOMAINP.  */
-extern int getnetgrent __P ((char **__restrict __hostp,
-                            char **__restrict __userp,
-                            char **__restrict __domainp));
+extern int getnetgrent (char **__restrict __hostp,
+                       char **__restrict __userp,
+                       char **__restrict __domainp) __THROW;
 
 /* Test whether NETGROUP contains the triple (HOST,USER,DOMAIN).  */
-extern int innetgr __P ((__const char *__netgroup, __const char *__host,
-                        __const char *__user, __const char *domain));
+extern int innetgr (__const char *__netgroup, __const char *__host,
+                   __const char *__user, __const char *domain) __THROW;
 
 #ifdef __USE_MISC
 /* Reentrant version of `getnetgrent' where result is placed in BUFFER.  */
-extern int getnetgrent_r __P ((char **__restrict __hostp,
-                              char **__restrict __userp,
-                              char **__restrict __domainp,
-                              char *__restrict __buffer, size_t __buflen));
+extern int getnetgrent_r (char **__restrict __hostp,
+                         char **__restrict __userp,
+                         char **__restrict __domainp,
+                         char *__restrict __buffer, size_t __buflen) __THROW;
 #endif /* misc */
 
 
@@ -362,32 +362,33 @@ extern int getnetgrent_r __P ((char **__restrict __hostp,
    connection is returned.  The caller must have the right to use a
    reserved port.  When the function returns *AHOST contains the
    official host name.  */
-extern int rcmd __P ((char **__restrict __ahost, unsigned short int __rport,
-                     __const char *__restrict __locuser,
-                     __const char *__restrict __remuser,
-                     __const char *__restrict __cmd, int *__restrict __fd2p));
+extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
+                __const char *__restrict __locuser,
+                __const char *__restrict __remuser,
+                __const char *__restrict __cmd, int *__restrict __fd2p)
+     __THROW;
 
 /* Call `rexecd' at port RPORT on remote machine *AHOST to execute
    CMD.  The process runs at the remote machine using the ID of user
    NAME whose cleartext password is PASSWD.  In *FD2P the descriptor
    to the socket for the connection is returned.  When the function
    returns *AHOST contains the official host name.  */
-extern int rexec __P ((char **__restrict __ahost, int __rport,
-                      __const char *__restrict __name,
-                      __const char *__restrict __pass,
-                      __const char *__restrict __cmd,
-                      int *__restrict __fd2p));
+extern int rexec (char **__restrict __ahost, int __rport,
+                 __const char *__restrict __name,
+                 __const char *__restrict __pass,
+                 __const char *__restrict __cmd, int *__restrict __fd2p)
+     __THROW;
 
 /* 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
    it is possible.  */
-extern int ruserok __P ((__const char *__rhost, int __suser,
-                        __const char *__remuser, __const char *__locuser));
+extern int ruserok (__const char *__rhost, int __suser,
+                   __const char *__remuser, __const char *__locuser) __THROW;
 
 /* Try to allocate reserved port, returning a descriptor for a socket opened
    at this port or -1 if unsuccessful.  The search for an available port
    will start at ALPORT and continues with lower numbers.  */
-extern int rresvport __P ((int *__alport));
+extern int rresvport (int *__alport) __THROW;
 #endif
 
 
@@ -435,23 +436,22 @@ struct addrinfo
 
 /* Translate name of a service location and/or a service name to set of
    socket addresses.  */
-extern int getaddrinfo __P ((__const char *__restrict __name,
-                            __const char *__restrict __service,
-                            __const struct addrinfo *__restrict __req,
-                            struct addrinfo **__restrict __pai));
+extern int getaddrinfo (__const char *__restrict __name,
+                       __const char *__restrict __service,
+                       __const struct addrinfo *__restrict __req,
+                       struct addrinfo **__restrict __pai) __THROW;
 
 /* Free `addrinfo' structure AI including associated storage.  */
-extern void freeaddrinfo __P ((struct addrinfo *__ai));
+extern void freeaddrinfo (struct addrinfo *__ai) __THROW;
 
 /* Convert error return from getaddrinfo() to a string.  */
-extern char *gai_strerror __P  ((int __ecode));
+extern char *gai_strerror (int __ecode) __THROW;
 
 /* Translate a socket address to a location and service name.  */
-extern int getnameinfo __P ((__const struct sockaddr *__restrict __sa,
-                            socklen_t __salen,
-                            char *__restrict __host, size_t __hostlen,
-                            char *__restrict __serv, size_t __servlen,
-                            int __flags));
+extern int getnameinfo (__const struct sockaddr *__restrict __sa,
+                       socklen_t __salen, char *__restrict __host,
+                       size_t __hostlen, char *__restrict __serv,
+                       size_t __servlen, int __flags) __THROW;
 
 #endif /* POSIX */
 
index fe0e5b9..58742e9 100644 (file)
@@ -166,19 +166,15 @@ struct __res_state {
 typedef enum { res_goahead, res_nextns, res_modified, res_done, res_error }
        res_sendhookact;
 
-typedef res_sendhookact (*res_send_qhook)__PMT((struct sockaddr_in * const *ns,
-                                               const u_char **query,
-                                               int *querylen,
-                                               u_char *ans,
-                                               int anssiz,
-                                               int *resplen));
+typedef res_sendhookact (*res_send_qhook) (struct sockaddr_in * const *ns,
+                                          const u_char **query, int *querylen,
+                                          u_char *ans, int anssiz,
+                                          int *resplen);
 
-typedef res_sendhookact (*res_send_rhook)__PMT((const struct sockaddr_in *ns,
-                                               const u_char *query,
-                                               int querylen,
-                                               u_char *ans,
-                                               int anssiz,
-                                               int *resplen));
+typedef res_sendhookact (*res_send_rhook) (const struct sockaddr_in *ns,
+                                          const u_char *query, int querylen,
+                                          u_char *ans, int anssiz,
+                                          int *resplen);
 
 struct res_sym {
        int     number;         /* Identifying number, like T_MX */
@@ -239,56 +235,57 @@ extern const struct res_sym __p_type_syms[];
 #endif
 
 __BEGIN_DECLS
-int            res_hnok __P((const char *));
-int            res_ownok __P((const char *));
-int            res_mailok __P((const char *));
-int            res_dnok __P((const char *));
-int            sym_ston __P((const struct res_sym *, char *, int *));
-const char *   sym_ntos __P((const struct res_sym *, int, int *));
-const char *   sym_ntop __P((const struct res_sym *, int, int *));
-int            b64_ntop __P((u_char const *, size_t, char *, size_t));
-int            b64_pton __P((char const *, u_char *, size_t));
-int            loc_aton __P((const char *, u_char *));
-const char *   loc_ntoa __P((const u_char *, char *));
-int            dn_skipname __P((const u_char *, const u_char *));
-void           fp_resstat __P((struct __res_state *, FILE *));
-void           fp_query __P((const u_char *, FILE *));
-void           fp_nquery __P((const u_char *, int, FILE *));
-const char *   hostalias __P((const char *));
-void           putlong __P((u_int32_t, u_char *));
-void           putshort __P((u_int16_t, u_char *));
-const char *   p_class __P((int));
-const char *   p_time __P((u_int32_t));
-const char *   p_type __P((int));
-void           p_query __P((const u_char *));
-const u_char * p_cdnname __P((const u_char *, const u_char *, int, FILE *));
-const u_char * p_cdname __P((const u_char *, const u_char *, FILE *));
-const u_char * p_fqnname __P((const u_char *cp, const u_char *msg,
-                              int, char *, int));
-const u_char * p_fqname __P((const u_char *, const u_char *, FILE *));
-const u_char * p_rr __P((const u_char *, const u_char *, FILE *));
-const char *   p_option __P((u_long option));
-char *         p_secstodate __P((u_long));
-int            dn_count_labels __P((char *));
-int            dn_comp __P((const char *, u_char *, int,
-                            u_char **, u_char **));
-int            dn_expand __P((const u_char *, const u_char *, const u_char *,
-                              char *, int));
-int            res_init __P((void));
-u_int          res_randomid __P((void));
-int            res_query __P((const char *, int, int, u_char *, int));
-int            res_search __P((const char *, int, int, u_char *, int));
-int            res_querydomain __P((const char *, const char *, int, int,
-                                    u_char *, int));
-int            res_mkquery __P((int, const char *, int, int, const u_char *, int,
-                                const u_char *, u_char *, int));
-int            res_send __P((const u_char *, int, u_char *, int));
-int            res_isourserver __P((const struct sockaddr_in *));
-int            res_nameinquery __P((const char *, int, int,
-                                    const u_char *, const u_char *));
-int            res_queriesmatch __P((const u_char *, const u_char *,
-                                     const u_char *, const u_char *));
-void           res_close __P((void));
+int            res_hnok (const char *) __THROW;
+int            res_ownok (const char *) __THROW;
+int            res_mailok (const char *) __THROW;
+int            res_dnok (const char *) __THROW;
+int            sym_ston (const struct res_sym *, char *, int *) __THROW;
+const char *   sym_ntos (const struct res_sym *, int, int *) __THROW;
+const char *   sym_ntop (const struct res_sym *, int, int *) __THROW;
+int            b64_ntop (u_char const *, size_t, char *, size_t) __THROW;
+int            b64_pton (char const *, u_char *, size_t) __THROW;
+int            loc_aton (const char *, u_char *) __THROW;
+const char *   loc_ntoa (const u_char *, char *) __THROW;
+int            dn_skipname (const u_char *, const u_char *) __THROW;
+void           fp_resstat (struct __res_state *, FILE *) __THROW;
+void           fp_query (const u_char *, FILE *) __THROW;
+void           fp_nquery (const u_char *, int, FILE *) __THROW;
+const char *   hostalias (const char *) __THROW;
+void           putlong (u_int32_t, u_char *) __THROW;
+void           putshort (u_int16_t, u_char *) __THROW;
+const char *   p_class (int) __THROW;
+const char *   p_time (u_int32_t) __THROW;
+const char *   p_type (int) __THROW;
+void           p_query (const u_char *) __THROW;
+const u_char * p_cdnname (const u_char *, const u_char *, int, FILE *)
+     __THROW;
+const u_char * p_cdname (const u_char *, const u_char *, FILE *) __THROW;
+const u_char * p_fqnname (const u_char *cp, const u_char *msg,
+                          int, char *, int) __THROW;
+const u_char * p_fqname (const u_char *, const u_char *, FILE *) __THROW;
+const u_char * p_rr (const u_char *, const u_char *, FILE *) __THROW;
+const char *   p_option (u_long option) __THROW;
+char *         p_secstodate (u_long) __THROW;
+int            dn_count_labels (char *) __THROW;
+int            dn_comp (const char *, u_char *, int,
+                            u_char **, u_char **) __THROW;
+int            dn_expand (const u_char *, const u_char *, const u_char *,
+                          char *, int) __THROW;
+int            res_init (void) __THROW;
+u_int          res_randomid (void) __THROW;
+int            res_query (const char *, int, int, u_char *, int) __THROW;
+int            res_search (const char *, int, int, u_char *, int) __THROW;
+int            res_querydomain (const char *, const char *, int, int,
+                                u_char *, int) __THROW;
+int            res_mkquery (int, const char *, int, int, const u_char *, int,
+                            const u_char *, u_char *, int) __THROW;
+int            res_send (const u_char *, int, u_char *, int) __THROW;
+int            res_isourserver (const struct sockaddr_in *) __THROW;
+int            res_nameinquery (const char *, int, int,
+                                const u_char *, const u_char *) __THROW;
+int            res_queriesmatch (const u_char *, const u_char *,
+                                 const u_char *, const u_char *) __THROW;
+void           res_close (void) __THROW;
 __END_DECLS
 
 #endif /* resolv.h */
index e44193b..9eca167 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992, 1994, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1992, 94, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -29,56 +29,56 @@ __BEGIN_DECLS
 /* Put the soft and hard limits for RESOURCE in *RLIMITS.
    Returns 0 if successful, -1 if not (and sets errno).  */
 #ifndef __USE_FILE_OFFSET64
-extern int getrlimit __P ((enum __rlimit_resource __resource,
-                          struct rlimit *__rlimits));
+extern int getrlimit (enum __rlimit_resource __resource,
+                     struct rlimit *__rlimits) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (getrlimit, __P ((enum __rlimit_resource __resource,
-                                       struct rlimit *__rlimits)),
+extern int __REDIRECT (getrlimit, (enum __rlimit_resource __resource,
+                                  struct rlimit *__rlimits) __THROW,
                       getrlimit64);
 # else
 #  define getrlimit getrlimit64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int getrlimit64 __P ((enum __rlimit_resource __resource,
-                            struct rlimit64 *__rlimits));
+extern int getrlimit64 (enum __rlimit_resource __resource,
+                       struct rlimit64 *__rlimits) __THROW;
 #endif
 
 /* Set the soft and hard limits for RESOURCE to *RLIMITS.
    Only the super-user can increase hard limits.
    Return 0 if successful, -1 if not (and sets errno).  */
 #ifndef __USE_FILE_OFFSET64
-extern int setrlimit __P ((enum __rlimit_resource __resource,
-                          __const struct rlimit *__rlimits));
+extern int setrlimit (enum __rlimit_resource __resource,
+                     __const struct rlimit *__rlimits) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (setrlimit, __P ((enum __rlimit_resource __resource,
-                                       __const struct rlimit *__rlimits)),
+extern int __REDIRECT (setrlimit, (enum __rlimit_resource __resource,
+                                  __const struct rlimit *__rlimits) __THROW,
                       setrlimit64);
 # else
 #  define setrlimit setrlimit64
 # endif
 #endif
 #ifdef __USE_LARGEFILE64
-extern int setrlimit64 __P ((enum __rlimit_resource __resource,
-                            __const struct rlimit64 *__rlimits));
+extern int setrlimit64 (enum __rlimit_resource __resource,
+                       __const struct rlimit64 *__rlimits) __THROW;
 #endif
 
 /* Return resource usage information on process indicated by WHO
    and put it in *USAGE.  Returns 0 for success, -1 for failure.  */
-extern int getrusage __P ((enum __rusage_who __who, struct rusage *__usage));
+extern int getrusage (enum __rusage_who __who, struct rusage *__usage) __THROW;
 
 /* Return the highest priority of any process specified by WHICH and WHO
    (see above); if WHO is zero, the current process, process group, or user
    (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 __P ((enum __priority_which __which, int __who));
+extern int getpriority (enum __priority_which __which, int __who) __THROW;
 
 /* 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 __P ((enum __priority_which __which, int __who,
-                            int __prio));
+extern int setpriority (enum __priority_which __which, int __who, int __prio)
+     __THROW;
 
 __END_DECLS
 
index d66368a..3af27b7 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1996, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -60,7 +60,7 @@ enum __vlimit_resource
 
 /* Set the soft limit for RESOURCE to be VALUE.
    Returns 0 for success, -1 for failure.  */
-extern int vlimit __P ((enum __vlimit_resource __resource, int __value));
+extern int vlimit (enum __vlimit_resource __resource, int __value) __THROW;
 
 
 __END_DECLS
index 51117d4..d8fa3b4 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991, 1992, 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1996, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -62,7 +62,7 @@ struct vtimes
 /* If CURRENT is not NULL, write statistics for the current process into
    *CURRENT.  If CHILD is not NULL, write statistics for all terminated child
    processes into *CHILD.  Returns 0 for success, -1 for failure.  */
-extern int vtimes __P ((struct vtimes * __current, struct vtimes * __child));
+extern int vtimes (struct vtimes * __current, struct vtimes * __child) __THROW;
 
 __END_DECLS
 
index 19bffcc..2ad9230 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -41,7 +41,7 @@ enum
 __BEGIN_DECLS
 
 /* Control process limits according to CMD.  */
-extern long int ulimit __P ((int __cmd, ...));
+extern long int ulimit (int __cmd, ...) __THROW;
 
 __END_DECLS
 
index cbfbe66..0190ce9 100644 (file)
--- a/rt/aio.h
+++ b/rt/aio.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -132,67 +132,65 @@ enum
 
 /* Allow user to specify optimization.  */
 #ifdef __USE_GNU
-extern void aio_init __P ((__const struct aioinit *__init));
+extern void aio_init (__const struct aioinit *__init) __THROW;
 #endif
 
 
 #ifndef __USE_FILE_OFFSET64
 /* Enqueue read request for given number of bytes and the given priority.  */
-extern int aio_read __P ((struct aiocb *__aiocbp));
+extern int aio_read (struct aiocb *__aiocbp) __THROW;
 /* Enqueue write request for given number of bytes and the given priority.  */
-extern int aio_write __P ((struct aiocb *__aiocbp));
+extern int aio_write (struct aiocb *__aiocbp) __THROW;
 
 /* Initiate list of I/O requests.  */
-extern int lio_listio __P ((int __mode,
-                           struct aiocb *__const __list[],
-                           int __nent, struct sigevent *__restrict __sig));
+extern int lio_listio (int __mode, struct aiocb *__const __list[],
+                      int __nent, struct sigevent *__restrict __sig) __THROW;
 
 /* Retrieve error status associated with AIOCBP.  */
-extern int aio_error __P ((__const struct aiocb *__aiocbp));
+extern int aio_error (__const struct aiocb *__aiocbp) __THROW;
 /* Return status associated with AIOCBP.  */
-extern __ssize_t aio_return __P ((struct aiocb *__aiocbp));
+extern __ssize_t aio_return (struct aiocb *__aiocbp) __THROW;
 
 /* Try to cancel asynchronous I/O requests outstanding against file
    descriptor FILDES.  */
-extern int aio_cancel __P ((int __fildes, struct aiocb *__aiocbp));
+extern int aio_cancel (int __fildes, struct aiocb *__aiocbp) __THROW;
 
 /* Suspend calling thread until at least one of the asynchronous I/O
    operations referenced by LIST has completed.  */
-extern int aio_suspend __P ((__const struct aiocb *__const __list[],
-                            int __nent,
-                            __const struct timespec *__restrict __timeout));
+extern int aio_suspend (__const struct aiocb *__const __list[], int __nent,
+                       __const struct timespec *__restrict __timeout) __THROW;
 
 /* Force all operations associated with file desriptor described by
    `aio_fildes' member of AIOCBP.  */
-extern int aio_fsync __P ((int __operation, struct aiocb *__aiocbp));
+extern int aio_fsync (int __operation, struct aiocb *__aiocbp) __THROW;
 #else
 # ifdef __REDIRECT
-extern int __REDIRECT (aio_read, __P ((struct aiocb *__aiocbp)), aio_read64);
-extern int __REDIRECT (aio_write, __P ((struct aiocb *__aiocbp)), aio_write64);
+extern int __REDIRECT (aio_read, (struct aiocb *__aiocbp) __THROW, aio_read64);
+extern int __REDIRECT (aio_write, (struct aiocb *__aiocbp) __THROW,
+                      aio_write64);
 
 extern int __REDIRECT (lio_listio,
-                      __P ((int __mode,
-                            struct aiocb *__const __restrict __list[],
-                            int __nent, struct sigevent *__restrict __sig)),
+                      (int __mode, struct aiocb *__const __restrict __list[],
+                       int __nent, struct sigevent *__restrict __sig) __THROW,
                       lio_listio64);
 
-extern int __REDIRECT (aio_error, __P ((__const struct aiocb *__aiocbp)),
+extern int __REDIRECT (aio_error, (__const struct aiocb *__aiocbp) __THROW,
                       aio_error64);
-extern __ssize_t __REDIRECT (aio_return, __P ((struct aiocb *__aiocbp)),
+extern __ssize_t __REDIRECT (aio_return, (struct aiocb *__aiocbp) __THROW,
                             aio_return64);
 
-extern int __REDIRECT (aio_cancel, __P ((int __fildes,
-                                        struct aiocb *__aiocbp)),
+extern int __REDIRECT (aio_cancel,
+                      (int __fildes, struct aiocb *__aiocbp) __THROW,
                       aio_cancel64);
 
 extern int __REDIRECT (aio_suspend,
-                      __P ((__const struct aiocb *__const __restrict __list[],
-                            int __nent,
-                            __const struct timespec *__restrict __timeout)),
+                      (__const struct aiocb *__const __restrict __list[],
+                       int __nent,
+                       __const struct timespec *__restrict __timeout) __THROW,
                       aio_suspend64);
 
-extern int __REDIRECT (aio_fsync __P ((int __operation,
-                                      struct aiocb *__aiocbp)),
+extern int __REDIRECT (aio_fsync,
+                      (int __operation, struct aiocb *__aiocbp) __THROW,
                       aio_fsync64);
 
 # else
@@ -208,23 +206,23 @@ extern int __REDIRECT (aio_fsync __P ((int __operation,
 #endif
 
 #ifdef __USE_LARGEFILE64
-extern int aio_read64 __P ((struct aiocb64 *__aiocbp));
-extern int aio_write64 __P ((struct aiocb64 *__aiocbp));
+extern int aio_read64 (struct aiocb64 *__aiocbp) __THROW;
+extern int aio_write64 (struct aiocb64 *__aiocbp) __THROW;
 
-extern int lio_listio64 __P ((int __mode,
-                             struct aiocb64 *__const __list[], int __nent,
-                             struct sigevent *__restrict __sig));
+extern int lio_listio64 (int __mode, struct aiocb64 *__const __list[],
+                        int __nent, struct sigevent *__restrict __sig)
+     __THROW;
 
-extern int aio_error64 __P ((__const struct aiocb64 *__aiocbp));
-extern __ssize_t aio_return64 __P ((struct aiocb64 *__aiocbp));
+extern int aio_error64 (__const struct aiocb64 *__aiocbp) __THROW;
+extern __ssize_t aio_return64 (struct aiocb64 *__aiocbp) __THROW;
 
-extern int aio_cancel64 __P ((int __fildes, struct aiocb64 *__aiocbp));
+extern int aio_cancel64 (int __fildes, struct aiocb64 *__aiocbp) __THROW;
 
-extern int aio_suspend64 __P ((__const struct aiocb64 *__const __list[],
-                              int __nent,
-                              __const struct timespec *__restrict __timeout));
+extern int aio_suspend64 (__const struct aiocb64 *__const __list[], int __nent,
+                         __const struct timespec *__restrict __timeout)
+     __THROW;
 
-extern int aio_fsync64 __P ((int __operation, struct aiocb64 *__aiocbp));
+extern int aio_fsync64 (int __operation, struct aiocb64 *__aiocbp) __THROW;
 #endif
 
 __END_DECLS
index 73d06c9..0052571 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
+/* Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -45,7 +45,7 @@ typedef struct __jmp_buf_tag  /* C++ doesn't like tagless structs.  */
 /* Store the calling environment in ENV, also saving the
    signal mask if SAVEMASK is nonzero.  Return 0.
    This is the internal name for `sigsetjmp'.  */
-extern int __sigsetjmp __P ((jmp_buf __env, int __savemask));
+extern int __sigsetjmp (jmp_buf __env, int __savemask) __THROW;
 
 #ifndef        __FAVOR_BSD
 /* Set ENV to the current position and return 0, not saving the signal mask.
@@ -67,14 +67,14 @@ extern int __sigsetjmp __P ((jmp_buf __env, int __savemask));
 
 /* Jump to the environment saved in ENV, making the
    `setjmp' call there return VAL, or 1 if VAL is 0.  */
-extern void longjmp __P ((jmp_buf __env, int __val))
-     __attribute__ ((__noreturn__));
+extern void longjmp (jmp_buf __env, int __val)
+     __THROW __attribute__ ((__noreturn__));
 #if defined __USE_BSD || defined __USE_XOPEN
 /* Same.  Usually `_longjmp' is used with `_setjmp', which does not save
    the signal mask.  But it is how ENV was saved that determines whether
    `longjmp' restores the mask; `_longjmp' is just an alias.  */
-extern void _longjmp __P ((jmp_buf __env, int __val))
-     __attribute__ ((__noreturn__));
+extern void _longjmp (jmp_buf __env, int __val)
+     __THROW __attribute__ ((__noreturn__));
 #endif
 
 
@@ -92,8 +92,8 @@ typedef jmp_buf sigjmp_buf;
    sigsetjmp call there return VAL, or 1 if VAL is 0.
    Restore the signal mask if that sigsetjmp call saved it.
    This is just an alias `longjmp'.  */
-extern void siglongjmp __P ((sigjmp_buf __env, int __val))
-     __attribute__ ((__noreturn__));
+extern void siglongjmp (sigjmp_buf __env, int __val)
+     __THROW __attribute__ ((__noreturn__));
 #endif /* Use POSIX.  */
 
 __END_DECLS
index 1ebb0ae..1f9ad1a 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -55,50 +55,50 @@ struct spwd
 
 
 /* Open database for reading.  */
-extern void setspent __P ((void));
+extern void setspent (void) __THROW;
 
 /* Close database.  */
-extern void endspent __P ((void));
+extern void endspent (void) __THROW;
 
 /* Get next entry from database, perhaps after opening the file.  */
-extern struct spwd *getspent __P ((void));
+extern struct spwd *getspent (void) __THROW;
 
 /* Get shadow entry matching NAME.  */
-extern struct spwd *getspnam __P ((__const char *__name));
+extern struct spwd *getspnam (__const char *__name) __THROW;
 
 /* Read shadow entry from STRING.  */
-extern struct spwd *sgetspent __P ((__const char *__string));
+extern struct spwd *sgetspent (__const char *__string) __THROW;
 
 /* Read next shadow entry from STREAM.  */
-extern struct spwd *fgetspent __P ((FILE *__stream));
+extern struct spwd *fgetspent (FILE *__stream) __THROW;
 
 /* Write line containing shadow password entry to stream.  */
-extern int putspent __P ((__const struct spwd *__p, FILE *__stream));
+extern int putspent (__const struct spwd *__p, FILE *__stream) __THROW;
 
 
 #ifdef __USE_MISC
 /* Reentrant versions of some of the functions above.  */
-extern int getspent_r __P ((struct spwd *__result_buf, char *__buffer,
-                           size_t __buflen, struct spwd **__result));
+extern int getspent_r (struct spwd *__result_buf, char *__buffer,
+                      size_t __buflen, struct spwd **__result) __THROW;
 
-extern int getspnam_r __P ((__const char *__name, struct spwd *__result_buf,
-                           char *__buffer, size_t __buflen,
-                           struct spwd **__result));
+extern int getspnam_r (__const char *__name, struct spwd *__result_buf,
+                      char *__buffer, size_t __buflen,
+                      struct spwd **__result)__THROW;
 
-extern int sgetspent_r __P ((__const char *__string, struct spwd *__result_buf,
-                            char *__buffer, size_t __buflen,
-                            struct spwd **__result));
+extern int sgetspent_r (__const char *__string, struct spwd *__result_buf,
+                       char *__buffer, size_t __buflen,
+                       struct spwd **__result) __THROW;
 
-extern int fgetspent_r __P ((FILE *__stream, struct spwd *__result_buf,
-                            char *__buffer, size_t __buflen,
-                            struct spwd **__result));
+extern int fgetspent_r (FILE *__stream, struct spwd *__result_buf,
+                       char *__buffer, size_t __buflen,
+                       struct spwd **__result) __THROW;
 #endif /* misc */
 
 /* Protect password file against multi writers.  */
-extern int lckpwdf __P ((void));
+extern int lckpwdf (void) __THROW;
 
 /* Unlock password file.  */
-extern int ulckpwdf __P ((void));
+extern int ulckpwdf (void) __THROW;
 
 __END_DECLS
 
index 02d7a79..12019f0 100644 (file)
@@ -62,27 +62,29 @@ typedef __pid_t pid_t;
 
 
 /* Type of a signal handler.  */
-typedef void (*__sighandler_t) __PMT ((int));
+typedef void (*__sighandler_t) (int);
 
 /* The X/Open definition of `signal' specifies the SVID semantic.  Use
    the additional function `sysv_signal' when X/Open compatibility is
    requested.  */
-extern __sighandler_t __sysv_signal __P ((int __sig,
-                                         __sighandler_t __handler));
+extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
+     __THROW;
 #ifdef __USE_GNU
-extern __sighandler_t sysv_signal __P ((int __sig, __sighandler_t __handler));
+extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
+     __THROW;
 #endif
 
 /* Set the handler for the signal SIG to HANDLER, returning the old
    handler, or SIG_ERR on error.
    By default `signal' has the BSD semantic.  */
 #ifdef __USE_BSD
-extern __sighandler_t signal __P ((int __sig, __sighandler_t __handler));
+extern __sighandler_t signal (int __sig, __sighandler_t __handler) __THROW;
 #else
 /* Make sure the used `signal' implementation is the SVID version. */
 # ifdef __REDIRECT
 extern __sighandler_t __REDIRECT (signal,
-                                 __P ((int __sig, __sighandler_t __handler)),
+                                 (int __sig,
+                                  __sighandler_t __handler) __THROW,
                                  __sysv_signal);
 # else
 #  define signal __sysv_signal
@@ -92,35 +94,35 @@ extern __sighandler_t __REDIRECT (signal,
 #ifdef __USE_XOPEN
 /* The X/Open definition of `signal' conflicts with the BSD version.
    So they defined another function `bsd_signal'.  */
-extern __sighandler_t bsd_signal __P ((int __sig, __sighandler_t __handler));
+extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler) __THROW;
 #endif
 
 /* Send signal SIG to process number PID.  If PID is zero,
    send SIG to all processes in the current process's process group.
    If PID is < -1, send SIG to all processes in process group - PID.  */
 #ifdef __USE_POSIX
-extern int kill __P ((__pid_t __pid, int __sig));
+extern int kill (__pid_t __pid, int __sig) __THROW;
 #endif /* Use POSIX.  */
 
 #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
 /* Send SIG to all processes in process group PGRP.
    If PGRP is zero, send SIG to all processes in
    the current process's process group.  */
-extern int killpg __P ((__pid_t __pgrp, int __sig));
+extern int killpg (__pid_t __pgrp, int __sig) __THROW;
 #endif /* Use BSD || X/Open Unix.  */
 
 /* Raise signal SIG, i.e., send SIG to yourself.  */
-extern int raise __P ((int __sig));
+extern int raise (int __sig) __THROW;
 
 #ifdef __USE_SVID
 /* SVID names for the same things.  */
-extern __sighandler_t ssignal __P ((int __sig, __sighandler_t __handler));
-extern int gsignal __P ((int __sig));
+extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) __THROW;
+extern int gsignal (int __sig) __THROW;
 #endif /* Use SVID.  */
 
 #ifdef __USE_MISC
 /* Print a message describing the meaning of the given signal number.  */
-extern void psignal __P ((int __sig, __const char *__s));
+extern void psignal (int __sig, __const char *__s) __THROW;
 #endif /* Use misc.  */
 
 
@@ -129,12 +131,12 @@ extern void psignal __P ((int __sig, __const char *__s));
    the more modern interface in X/Open defines it as the signal
    number.  We go with the BSD version unless the user explicitly
    selects the X/Open version.  */
-extern int __sigpause __P ((int __sig_or_mask, int __is_sig));
+extern int __sigpause (int __sig_or_mask, int __is_sig) __THROW;
 
 #ifdef __USE_BSD
 /* Set the mask of blocked signals to MASK,
    wait for a signal to arrive, and then restore the mask.  */
-extern int sigpause __P ((int __mask));
+extern int sigpause (int __mask) __THROW;
 # define sigpause(mask) __sigpause ((mask), 0)
 #else
 # ifdef __USE_XOPEN
@@ -154,13 +156,13 @@ extern int sigpause __P ((int __mask));
 # define sigmask(sig)  __sigmask(sig)
 
 /* Block signals in MASK, returning the old mask.  */
-extern int sigblock __P ((int __mask));
+extern int sigblock (int __mask) __THROW;
 
 /* Set the mask of blocked signals to MASK, returning the old mask.  */
-extern int sigsetmask __P ((int __mask));
+extern int sigsetmask (int __mask) __THROW;
 
 /* Return currently selected signal mask.  */
-extern int siggetmask __P ((void));
+extern int siggetmask (void) __THROW;
 #endif /* Use BSD.  */
 
 
@@ -189,31 +191,31 @@ typedef __sighandler_t sig_t;
 # endif
 
 /* Clear all signals from SET.  */
-extern int sigemptyset __P ((sigset_t *__set));
+extern int sigemptyset (sigset_t *__set) __THROW;
 
 /* Set all signals in SET.  */
-extern int sigfillset __P ((sigset_t *__set));
+extern int sigfillset (sigset_t *__set) __THROW;
 
 /* Add SIGNO to SET.  */
-extern int sigaddset __P ((sigset_t *__set, int __signo));
+extern int sigaddset (sigset_t *__set, int __signo) __THROW;
 
 /* Remove SIGNO from SET.  */
-extern int sigdelset __P ((sigset_t *__set, int __signo));
+extern int sigdelset (sigset_t *__set, int __signo) __THROW;
 
 /* Return 1 if SIGNO is in SET, 0 if not.  */
-extern int sigismember __P ((__const sigset_t *__set, int __signo));
+extern int sigismember (__const sigset_t *__set, int __signo) __THROW;
 
 # ifdef __USE_GNU
 /* Return non-empty value is SET is not empty.  */
-extern int sigisemptyset __P ((__const sigset_t *__set));
+extern int sigisemptyset (__const sigset_t *__set) __THROW;
 
 /* Build new signal set by combining the two inputs set using logical AND.  */
-extern int sigandset __P ((sigset_t *__set, __const sigset_t *__left,
-                          __const sigset_t *__right));
+extern int sigandset (sigset_t *__set, __const sigset_t *__left,
+                     __const sigset_t *__right) __THROW;
 
 /* Build new signal set by combining the two inputs set using logical OR.  */
-extern int sigorset __P ((sigset_t *__set, __const sigset_t *__left,
-                         __const sigset_t *__right));
+extern int sigorset (sigset_t *__set, __const sigset_t *__left,
+                    __const sigset_t *__right) __THROW;
 # endif /* GNU */
 
 /* Get the system-specific definitions of `struct sigaction'
@@ -221,39 +223,39 @@ extern int sigorset __P ((sigset_t *__set, __const sigset_t *__left,
 # include <bits/sigaction.h>
 
 /* Get and/or change the set of blocked signals.  */
-extern int sigprocmask __P ((int __how,
-                            __const sigset_t *__set, sigset_t *__oset));
+extern int sigprocmask (int __how, __const sigset_t *__set, sigset_t *__oset)
+     __THROW;
 
 /* Change the set of blocked signals to SET,
    wait until a signal arrives, and restore the set of blocked signals.  */
-extern int sigsuspend __P ((__const sigset_t *__set));
+extern int sigsuspend (__const sigset_t *__set) __THROW;
 
 /* Get and/or set the action for signal SIG.  */
-extern int __sigaction __P ((int __sig, __const struct sigaction *__act,
-                            struct sigaction *__oact));
-extern int sigaction __P ((int __sig, __const struct sigaction *__act,
-                          struct sigaction *__oact));
+extern int __sigaction (int __sig, __const struct sigaction *__act,
+                       struct sigaction *__oact) __THROW;
+extern int sigaction (int __sig, __const struct sigaction *__act,
+                     struct sigaction *__oact) __THROW;
 
 /* Put in SET all signals that are blocked and waiting to be delivered.  */
-extern int sigpending __P ((sigset_t *__set));
+extern int sigpending (sigset_t *__set) __THROW;
 
 
 /* Select any of pending signals from SET or wait for any to arrive.  */
-extern int sigwait __P ((__const sigset_t *__set, int *__sig));
+extern int sigwait (__const sigset_t *__set, int *__sig) __THROW;
 
 # ifdef __USE_POSIX199309
 /* Select any of pending signals from SET and place information in INFO.  */
-extern int sigwaitinfo __P ((__const sigset_t *__set, siginfo_t *__info));
+extern int sigwaitinfo (__const sigset_t *__set, siginfo_t *__info) __THROW;
 
 /* Select any of pending signals from SET and place information in INFO.
    Wait the imte specified by TIMEOUT if no signal is pending.  */
-extern int sigtimedwait __P ((__const sigset_t *__set, siginfo_t *__info,
-                             __const struct timespec *__timeout));
+extern int sigtimedwait (__const sigset_t *__set, siginfo_t *__info,
+                        __const struct timespec *__timeout) __THROW;
 
 /* Send signal SIG to the process PID.  Associate data in VAL with the
    signal.  */
-extern int sigqueue __P ((__pid_t __pid, int __sig,
-                         __const union sigval __val));
+extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
+     __THROW;
 # endif        /* Use POSIX 199306.  */
 
 #endif /* Use POSIX.  */
@@ -286,15 +288,15 @@ struct sigvec
    If the SV_RESETHAND bit is set in `sv_flags', the handler for SIG will be
    reset to SIG_DFL before `sv_handler' is entered.  If OVEC is non-NULL,
    it is filled in with the old information for SIG.  */
-extern int sigvec __P ((int __sig, __const struct sigvec *__vec,
-                       struct sigvec *__ovec));
+extern int sigvec (int __sig, __const struct sigvec *__vec,
+                  struct sigvec *__ovec) __THROW;
 
 
 /* Get machine-dependent `struct sigcontext' and signal subcodes.  */
 # include <bits/sigcontext.h>
 
 /* Restore the state saved in SCP.  */
-extern int sigreturn __P ((struct sigcontext *__scp));
+extern int sigreturn (struct sigcontext *__scp) __THROW;
 
 #endif /*  use BSD.  */
 
@@ -304,20 +306,20 @@ extern int sigreturn __P ((struct sigcontext *__scp));
 /* If INTERRUPT is nonzero, make signal SIG interrupt system calls
    (causing them to fail with EINTR); if INTERRUPT is zero, make system
    calls be restarted after signal SIG.  */
-extern int siginterrupt __P ((int __sig, int __interrupt));
+extern int siginterrupt (int __sig, int __interrupt) __THROW;
 
 # include <bits/sigstack.h>
 
 /* Run signals handlers on the stack specified by SS (if not NULL).
    If OSS is not NULL, it is filled in with the old signal stack status.
    This interface is obsolete and on many platform not implemented.  */
-extern int sigstack __P ((__const struct sigstack *__ss,
-                         struct sigstack *__oss));
+extern int sigstack (__const struct sigstack *__ss,
+                    struct sigstack *__oss) __THROW;
 
 /* Alternate signal handler stack interface.
    This interface should always be preferred over `sigstack'.  */
-extern int sigaltstack __P ((__const struct sigaltstack *__ss,
-                            struct sigaltstack *__oss));
+extern int sigaltstack (__const struct sigaltstack *__ss,
+                       struct sigaltstack *__oss) __THROW;
 
 #endif /* use BSD or X/Open Unix.  */
 
@@ -325,16 +327,16 @@ extern int sigaltstack __P ((__const struct sigaltstack *__ss,
 /* Simplified interface for signal management.  */
 
 /* Add SIG to the calling process' signal mask.  */
-extern int sighold __P ((int __sig));
+extern int sighold (int __sig) __THROW;
 
 /* Remove SIG from the calling process' signal mask.  */
-extern int sigrelse __P ((int __sig));
+extern int sigrelse (int __sig) __THROW;
 
 /* Set the disposition of SIG to SIG_IGN.  */
-extern int sigignore __P ((int __sig));
+extern int sigignore (int __sig) __THROW;
 
 /* Set the disposition of SIG.  */
-extern __sighandler_t sigset __P ((int __sig, __sighandler_t __disp));
+extern __sighandler_t sigset (int __sig, __sighandler_t __disp) __THROW;
 
 /* Some of the functions for handling signals in threaded programs must
    be defined here.  */
@@ -345,9 +347,9 @@ extern __sighandler_t sigset __P ((int __sig, __sighandler_t __disp));
    other code which need deep insights.  */
 
 /* Return number of available real-time signal with highest priority.  */
-extern int __libc_current_sigrtmin __P ((void));
+extern int __libc_current_sigrtmin (void) __THROW;
 /* Return number of available real-time signal with lowest priority.  */
-extern int __libc_current_sigrtmax __P ((void));
+extern int __libc_current_sigrtmax (void) __THROW;
 
 #endif /* signal.h  */
 
index 9766369..f7e5e6d 100644 (file)
@@ -1,5 +1,5 @@
 /* Internal function for converting integers to ASCII.
-   Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1994, 95, 96, 97, 98, 99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -26,8 +26,8 @@
    Return the address of the first (left-to-right) character in the number.
    Use upper case letters iff UPPER_CASE is nonzero.  */
 
-extern char *_itoa __P ((unsigned long long int value, char *buflim,
-                        unsigned int base, int upper_case));
+extern char *_itoa (unsigned long long int value, char *buflim,
+                   unsigned int base, int upper_case);
 
 static inline char * __attribute__ ((unused))
 _itoa_word (unsigned long value, char *buflim,
index e219f29..7ce5e4d 100644 (file)
@@ -27,8 +27,8 @@
    Return the address of the first (left-to-right) character in the number.
    Use upper case letters iff UPPER_CASE is nonzero.  */
 
-extern wchar_t *_itowa __P ((unsigned long long int value, wchar_t *buflim,
-                            unsigned int base, int upper_case));
+extern wchar_t *_itowa (unsigned long long int value, wchar_t *buflim,
+                       unsigned int base, int upper_case);
 
 static inline wchar_t *
 __attribute__ ((unused))
index 66ac5d0..755f652 100644 (file)
@@ -60,25 +60,24 @@ struct printf_info
    The function should return the number of characters written,
    or -1 for errors.  */
 
-typedef int printf_function __PMT ((FILE *__stream,
-                                   __const struct printf_info *__info,
-                                   __const void *__const *__args));
+typedef int printf_function (FILE *__stream,
+                            __const struct printf_info *__info,
+                            __const void *__const *__args);
 
 /* Type of a printf specifier-arginfo function.
    INFO gives information about the format specification.
    N, ARGTYPES, and return value are as for printf_parse_format.  */
 
-typedef int printf_arginfo_function __PMT ((__const struct printf_info *__info,
-                                           size_t __n,
-                                           int *__argtypes));
+typedef int printf_arginfo_function (__const struct printf_info *__info,
+                                    size_t __n, int *__argtypes);
 
 
 /* Register FUNC to be called to format SPEC specifiers; ARGINFO must be
    specified to determine how many arguments a SPEC conversion requires and
    what their types are.  */
 
-extern int register_printf_function __P ((int __spec, printf_function __func,
-                                         printf_arginfo_function __arginfo));
+extern int register_printf_function (int __spec, printf_function __func,
+                                    printf_arginfo_function __arginfo);
 
 
 /* Parse FMT, and fill in N elements of ARGTYPES with the
@@ -92,9 +91,8 @@ extern int register_printf_function __P ((int __spec, printf_function __func,
    array it is passed with the types of the arguments it wants, and return
    the number of arguments it wants.  */
 
-extern size_t parse_printf_format __P ((__const char *__restrict __fmt,
-                                       size_t __n,
-                                       int *__restrict __argtypes));
+extern size_t parse_printf_format (__const char *__restrict __fmt, size_t __n,
+                                  int *__restrict __argtypes) __THROW;
 
 
 /* Codes returned by `parse_printf_format' for basic types.
@@ -131,14 +129,14 @@ enum
    of magnitude used for numbers ('k' for kilo, 'm' for mega etc).  If
    the format specifier is a uppercase character powers of 1000 are
    used.  Otherwise powers of 1024.  */
-extern int printf_size __P ((FILE *__restrict __fp,
-                            __const struct printf_info *__info,
-                            __const void *__const *__restrict __args));
+extern int printf_size (FILE *__restrict __fp,
+                       __const struct printf_info *__info,
+                       __const void *__const *__restrict __args) __THROW;
 
 /* This is the appropriate argument information function for `printf_size'.  */
-extern int printf_size_info __P ((__const struct printf_info *__restrict
-                                 __info, size_t __n,
-                                 int *__restrict __argtypes));
+extern int printf_size_info (__const struct printf_info *__restrict
+                            __info, size_t __n, int *__restrict __argtypes)
+     __THROW;
 
 
 __END_DECLS
index 9045727..465a80d 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
+/* Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -74,8 +74,8 @@ typedef struct
 
 /* Read NBYTES bytes from COOKIE into a buffer pointed to by BUF.
    Return number of bytes read.  */
-typedef __ssize_t __io_read_fn __PMT ((__ptr_t __cookie, char *__buf,
-                                      size_t __nbytes));
+typedef __ssize_t __io_read_fn (__ptr_t __cookie, char *__buf,
+                               size_t __nbytes);
 
 /* Write N bytes pointed to by BUF to COOKIE.  Write all N bytes
    unless there is an error.  Return number of bytes written, or -1 if
@@ -83,8 +83,8 @@ typedef __ssize_t __io_read_fn __PMT ((__ptr_t __cookie, char *__buf,
    opened for append (__mode.__append set), then set the file pointer
    to the end of the file and then do the write; if not, just write at
    the current file pointer.  */
-typedef __ssize_t __io_write_fn __PMT ((__ptr_t __cookie, __const char *__buf,
-                                     size_t __n));
+typedef __ssize_t __io_write_fn (__ptr_t __cookie, __const char *__buf,
+                                size_t __n);
 
 /* Move COOKIE's file position to *POS bytes from the
    beginning of the file (if W is SEEK_SET),
@@ -92,14 +92,14 @@ typedef __ssize_t __io_write_fn __PMT ((__ptr_t __cookie, __const char *__buf,
    or the end of the file (if W is SEEK_END).
    Set *POS to the new file position.
    Returns zero if successful, nonzero if not.  */
-typedef int __io_seek_fn __PMT ((__ptr_t __cookie, fpos_t *__pos, int __w));
+typedef int __io_seek_fn (__ptr_t __cookie, fpos_t *__pos, int __w);
 
 /* Close COOKIE.  */
-typedef int __io_close_fn __PMT ((__ptr_t __cookie));
+typedef int __io_close_fn (__ptr_t __cookie);
 
 /* Return the file descriptor associated with COOKIE,
    or -1 on error.  There need not be any associated file descriptor.  */
-typedef int __io_fileno_fn __PMT ((__ptr_t __cookie));
+typedef int __io_fileno_fn (__ptr_t __cookie);
 
 #ifdef __USE_GNU
 /* User-visible names for the above.  */
@@ -139,9 +139,9 @@ typedef struct
 typedef struct
 {
   /* Make room in the input buffer.  */
-  int (*__input) __PMT ((FILE *__stream));
+  int (*__input) (FILE *__stream);
   /* Make room in the output buffer.  */
-  void (*__output) __PMT ((FILE *__stream, int __c));
+  void (*__output) (FILE *__stream, int __c);
 } __room_functions;
 
 extern __const __io_functions __default_io_functions;
@@ -151,10 +151,10 @@ extern __const __room_functions __default_room_functions;
 /* Default close function.  */
 extern __io_close_fn __stdio_close;
 /* Open FILE with mode M, store cookie in *COOKIEPTR.  */
-extern int __stdio_open __P ((__const char *__file, __io_mode __m,
-                             __ptr_t *__cookieptr));
+extern int __stdio_open (__const char *__file, __io_mode __m,
+                        void **__cookieptr) __THROW;
 /* Put out an error message for when stdio needs to die.  */
-extern void __stdio_errmsg __P ((__const char *__msg, size_t __len));
+extern void __stdio_errmsg (__const char *__msg, size_t __len) __THROW;
 
 
 
@@ -216,12 +216,12 @@ struct __stdio_file
 #define        __clearerr(stream)      ((stream)->__error = (stream)->__eof = 0)
 
 /* Nuke STREAM, making it unusable but available for reuse.  */
-extern void __invalidate __P ((FILE *__stream));
+extern void __invalidate (FILE *__stream) __THROW;
 
 /* Make sure STREAM->__offset and STREAM->__target are initialized.
    Returns 0 if successful, or EOF on
    error (but doesn't set STREAM->__error).  */
-extern int __stdio_check_offset __P ((FILE *__stream));
+extern int __stdio_check_offset (FILE *__stream) __THROW;
 
 
 /* The possibilities for the third argument to `setvbuf'.  */
@@ -279,23 +279,23 @@ extern FILE *stdin, *stdout, *stderr;
 
 
 /* Remove file FILENAME.  */
-extern int remove __P ((__const char *__filename));
+extern int remove (__const char *__filename) __THROW;
 /* Rename file OLD to NEW.  */
-extern int rename __P ((__const char *__old, __const char *__new));
+extern int rename (__const char *__old, __const char *__new) __THROW;
 
 
 /* Create a temporary file and open it read/write.  */
-extern FILE *tmpfile __P ((void));
+extern FILE *tmpfile (void) __THROW;
 #ifdef __USE_LARGEFILE64
-extern FILE *tmpfile64 __P ((void));
+extern FILE *tmpfile64 (void) __THROW;
 #endif
 /* Generate a temporary filename.  */
-extern char *tmpnam __P ((char *__s));
+extern char *tmpnam (char *__s) __THROW;
 
 #ifdef __USE_REENTRANT
 /* This is the reentrant variant of `tmpnam'.  The only difference is
    that it does not allow S to be NULL.  */
-extern char *tmpnam_r __P ((char *__s));
+extern char *tmpnam_r (char *__s) __THROW;
 #endif
 
 
@@ -307,38 +307,38 @@ extern char *tmpnam_r __P ((char *__s));
    If not and if DIR is not NULL, that value is checked.  If that fails,
    P_tmpdir is tried and finally "/tmp".  The storage for the filename
    is allocated by `malloc'.  */
-extern char *tempnam __P ((__const char *__dir, __const char *__pfx));
+extern char *tempnam (__const char *__dir, __const char *__pfx) __THROW;
 #endif
 
 
 /* This performs actual output when necessary, flushing
    STREAM's buffer and optionally writing another character.  */
-extern int __flshfp __P ((FILE *__stream, int __c));
+extern int __flshfp (FILE *__stream, int __c) __THROW;
 
 
 /* Close STREAM.  */
-extern int fclose __P ((FILE *__stream));
+extern int fclose (FILE *__stream) __THROW;
 /* Flush STREAM, or all streams if STREAM is NULL.  */
-extern int fflush __P ((FILE *__stream));
+extern int fflush (FILE *__stream) __THROW;
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not required.  */
-extern int fflush_unlocked __P ((FILE *__stream));
+extern int fflush_unlocked (FILE *__stream) __THROW;
 #endif
 
 #ifdef __USE_GNU
 /* Close all streams.  */
-extern int __fcloseall __P ((void));
-extern int fcloseall __P ((void));
+extern int __fcloseall (void) __THROW;
+extern int fcloseall (void) __THROW;
 #endif
 
 
 /* Open a file and create a new stream for it.  */
-extern FILE *fopen __P ((__const char *__filename, __const char *__modes));
+extern FILE *fopen (__const char *__filename, __const char *__modes) __THROW;
 /* Open a file, replacing an existing stream with it. */
-extern FILE *freopen __P ((__const char *__restrict __filename,
-                          __const char *__restrict __modes,
-                          FILE *__restrict __stream));
+extern FILE *freopen (__const char *__restrict __filename,
+                     __const char *__restrict __modes,
+                     FILE *__restrict __stream) __THROW;
 
 /* Return a new, zeroed, stream.
    You must set its cookie and io_mode.
@@ -349,69 +349,67 @@ extern FILE *freopen __P ((__const char *__restrict __filename,
    The target is set to -1, meaning it will be set to the offset
    before the target is needed.
    Returns NULL if a stream can't be created.  */
-extern FILE *__newstream __P ((void));
+extern FILE *__newstream (void) __THROW;
 
 #ifdef __USE_POSIX
 /* Create a new stream that refers to an existing system file descriptor.  */
-extern FILE *__fdopen __P ((int __fd, __const char *__modes));
-extern FILE *fdopen __P ((int __fd, __const char *__modes));
+extern FILE *__fdopen (int __fd, __const char *__modes) __THROW;
+extern FILE *fdopen (int __fd, __const char *__modes) __THROW;
 #endif
 
 #ifdef __USE_GNU
 /* Create a new stream that refers to the given magic cookie,
    and uses the given functions for input and output.  */
-extern FILE *fopencookie __P ((__ptr_t __magic_cookie, __const char *__modes,
-                              __io_functions __io_funcs));
+extern FILE *fopencookie (void *__magic_cookie, __const char *__modes,
+                         __io_functions __io_funcs) __THROW;
 
 /* Create a new stream that refers to a memory buffer.  */
-extern FILE *fmemopen __P ((__ptr_t __s, size_t __len, __const char *__modes));
+extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) __THROW;
 
 /* Open a stream that writes into a malloc'd buffer that is expanded as
    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
    and the number of characters written on fflush or fclose.  */
-extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __THROW;
 #endif
 
 
 /* If BUF is NULL, make STREAM unbuffered.
    Else make it use buffer BUF, of size BUFSIZ.  */
-extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __THROW;
 /* Make STREAM use buffering mode MODE.
    If BUF is not NULL, use N bytes of it for buffering;
    else allocate an internal buffer N bytes long.  */
-extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
-                        int __modes, size_t __n));
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+                   int __modes, size_t __n) __THROW;
 
 #ifdef __USE_BSD
 /* If BUF is NULL, make STREAM unbuffered.
    Else make it use SIZE bytes of BUF for buffering.  */
-extern void setbuffer __P ((FILE *__stream, char *__buf, size_t __size));
+extern void setbuffer (FILE *__stream, char *__buf, size_t __size) __THROW;
 
 /* Make STREAM line-buffered.  */
-extern void setlinebuf __P ((FILE *__stream));
+extern void setlinebuf (FILE *__stream) __THROW;
 #endif
 
 
 /* Write formatted output to STREAM.  */
-extern int fprintf __P ((FILE *__restrict __stream,
-                        __const char *__restrict __format, ...));
+extern int fprintf (FILE *__restrict __stream,
+                   __const char *__restrict __format, ...) __THROW;
 /* Write formatted output to stdout.  */
-extern int printf __P ((__const char *__restrict __format, ...));
+extern int printf (__const char *__restrict __format, ...) __THROW;
 /* Write formatted output to S.  */
-extern int sprintf __P ((char *__restrict __s,
-                        __const char *__restrict __format, ...));
+extern int sprintf (char *__restrict __s, __const char *__restrict __format,
+                   ...) __THROW;
 
 /* Write formatted output to S from argument list ARG.  */
-extern int vfprintf __P ((FILE *__restrict __s,
-                         __const char *__restrict __format,
-                         __gnuc_va_list __arg));
+extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
+                    __gnuc_va_list __arg) __THROW;
 /* Write formatted output to stdout from argument list ARG.  */
-extern int vprintf __P ((__const char *__restrict __format,
-                        __gnuc_va_list __arg));
+extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg)
+     ___THROW;
 /* Write formatted output to S from argument list ARG.  */
-extern int vsprintf __P ((char *__restrict __s,
-                         __const char *__restrict __format,
-                         __gnuc_va_list __arg));
+extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
+                    __gnuc_va_list __arg) __THROW;
 
 #ifdef __OPTIMIZE__
 extern __inline int
@@ -423,68 +421,67 @@ vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) __THROW
 
 #if defined __USE_BSD || defined __USE_ISOC9X
 /* Maximum chars of output to write in MAXLEN.  */
-extern int __snprintf __P ((char *__s, size_t __maxlen,
-                           __const char *__format, ...))
-     __attribute__ ((__format__ (__printf__, 3, 4)));
-extern int snprintf __P ((char *__s, size_t __maxlen,
-                         __const char *__format, ...))
-     __attribute__ ((__format__ (__printf__, 3, 4)));
-
-extern int __vsnprintf __P ((char *__s, size_t __maxlen,
-                            __const char *__format, __gnuc_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 3, 0)));
-extern int vsnprintf __P ((char *__s, size_t __maxlen,
-                          __const char *__format, __gnuc_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int __snprintf (char *__s, size_t __maxlen,
+                      __const char *__format, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int snprintf (char *__s, size_t __maxlen, __const char *__format, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int __vsnprintf (char *__s, size_t __maxlen,
+                       __const char *__format, __gnuc_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int vsnprintf (char *__s, size_t __maxlen,
+                     __const char *__format, __gnuc_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 3, 0)));
 #endif
 
 #ifdef __USE_GNU
 /* Write formatted output to a string dynamically allocated with `malloc'.
    Store the address of the string in *PTR.  */
-extern int vasprintf __P ((char **__restrict __ptr,
-                          __const char *__restrict __f, __gnuc_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int __asprintf __P ((char **__restrict __ptr,
-                           __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
-extern int asprintf __P ((char **__restrict __ptr,
-                         __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int vasprintf (char **__restrict __ptr,
+                     __const char *__restrict __f, __gnuc_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int __asprintf (char **__restrict __ptr,
+                      __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int asprintf (char **__restrict __ptr,
+                    __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
 
 /* Write formatted output to a file descriptor.  */
-extern int vdprintf __P ((int __fd, __const char *__restrict __fmt,
-                         __gnuc_va_list __arg))
-     __attribute__ ((__format__ (__printf__, 2, 0)));
-extern int dprintf __P ((int __fd, __const char *__restrict __fmt, ...))
-     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int vdprintf (int __fd, __const char *__restrict __fmt,
+                    __gnuc_va_list __arg)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
+     __THROW __attribute__ ((__format__ (__printf__, 2, 3)));
 #endif
 
 
 /* Read formatted input from STREAM.  */
-extern int fscanf __P ((FILE *__restrict __stream,
-                       __const char *__restrict __format, ...));
+extern int fscanf (FILE *__restrict __stream,
+                  __const char *__restrict __format, ...) __THROW;
 /* Read formatted input from stdin.  */
-extern int scanf __P ((__const char *__restrict __format, ...));
+extern int scanf (__const char *__restrict __format, ...) __THROW;
 /* Read formatted input from S.  */
-extern int sscanf __P ((__const char *__restrict __s,
-                       __const char *__restrict __format, ...));
+extern int sscanf (__const char *__restrict __s,
+                  __const char *__restrict __format, ...) __THROW;
 
 #ifdef __USE_ISOC9X
 /* Read formatted input from S into argument list ARG.  */
-extern int __vfscanf __P ((FILE *__s, __const char *__format,
-                          __gnuc_va_list __arg));
-extern int vfscanf __P ((FILE *__s, __const char *__format,
-                        __gnuc_va_list __arg));
+extern int __vfscanf (FILE *__s, __const char *__format,
+                     __gnuc_va_list __arg) __THROW;
+extern int vfscanf (FILE *__s, __const char *__format,
+                   __gnuc_va_list __arg) __THROW;
 
 /* Read formatted input from stdin into argument list ARG.  */
-extern int __vscanf __P ((__const char *__format, __gnuc_va_list __arg));
-extern int vscanf __P ((__const char *__format, __gnuc_va_list __arg));
+extern int __vscanf (__const char *__format, __gnuc_va_list __arg) __THROW;
+extern int vscanf (__const char *__format, __gnuc_va_list __arg) __THROW;
 
 /* Read formatted input from S into argument list ARG.  */
-extern int __vsscanf __P ((__const char *__s, __const char *__format,
-                          __gnuc_va_list __arg));
-extern int vsscanf __P ((__const char *__s, __const char *__format,
-                        __gnuc_va_list __arg));
+extern int __vsscanf (__const char *__s, __const char *__format,
+                     __gnuc_va_list __arg) __THROW;
+extern int vsscanf (__const char *__s, __const char *__format,
+                   __gnuc_va_list __arg) __THROW;
 
 
 #ifdef __OPTIMIZE__
@@ -509,15 +506,15 @@ vsscanf (const char *__s, const char *__fmt, __gnuc_va_list __arg) __THROW
 
 /* This does actual reading when necessary, filling STREAM's
    buffer and returning the first character in it.  */
-extern int __fillbf __P ((FILE *__stream));
+extern int __fillbf (FILE *__stream) __THROW;
 
 
 /* Read a character from STREAM.  */
-extern int fgetc __P ((FILE *__stream));
-extern int getc __P ((FILE *__stream));
+extern int fgetc (FILE *__stream) __THROW;
+extern int getc (FILE *__stream) __THROW;
 
 /* Read a character from stdin.  */
-extern int getchar __P ((void));
+extern int getchar (void) __THROW;
 
 /* The C standard explicitly says this can
    re-evaluate its argument, so it does. */
@@ -539,8 +536,8 @@ getchar (void) __THROW
 
 #if defined __USE_POSIX || defined __USE_MISC
 /* These are defined in POSIX.1:1996.  */
-extern int getc_unlocked __P ((FILE *__stream));
-extern int getchar_unlocked __P ((void));
+extern int getc_unlocked (FILE *__stream) __THROW;
+extern int getchar_unlocked (void) __THROW;
 
 # ifdef __OPTIMIZE__
 extern __inline int
@@ -559,11 +556,11 @@ getchar_unlocked (void) __THROW
 
 
 /* Write a character to STREAM.  */
-extern int fputc __P ((int __c, FILE *__stream));
-extern int putc __P ((int __c, FILE *__stream));
+extern int fputc (int __c, FILE *__stream) __THROW;
+extern int putc (int __c, FILE *__stream) __THROW;
 
 /* Write a character to stdout.  */
-extern int putchar __P ((int __c));
+extern int putchar (int __c) __THROW;
 
 
 /* The C standard explicitly says this can
@@ -587,7 +584,7 @@ putchar (int __c) __THROW
 
 #ifdef __USE_MISC
 /* Faster version when locking is not necessary.  */
-extern int fputc_unlocked __P ((int __c, FILE *__stream));
+extern int fputc_unlocked (int __c, FILE *__stream) __THROW;
 
 # ifdef __OPTIMIZE__
 extern __inline int
@@ -600,8 +597,8 @@ fputc_unlocked (int __c, FILE *__stream) __THROW
 
 #if defined __USE_POSIX || defined __USE_MISC
 /* These are defined in POSIX.1:1996.  */
-extern int putc_unlocked __P ((int __c, FILE *__stream));
-extern int putchar_unlocked __P ((int __c));
+extern int putc_unlocked (int __c, FILE *__stream) __THROW;
+extern int putchar_unlocked (int __c) __THROW;
 
 # ifdef __OPTIMIZE__
 extern __inline int
@@ -621,26 +618,26 @@ putchar_unlocked (int __c) __THROW
 
 #if defined __USE_SVID || defined __USE_MISC
 /* Get a word (int) from STREAM.  */
-extern int getw __P ((FILE *__stream));
+extern int getw (FILE *__stream) __THROW;
 
 /* Write a word (int) to STREAM.  */
-extern int putw __P ((int __w, FILE *__stream));
+extern int putw (int __w, FILE *__stream) __THROW;
 #endif
 
 
 /* Get a newline-terminated string of finite length from STREAM.  */
-extern char *fgets __P ((char *__restrict __s, int __n,
-                        FILE *__restrict __stream));
+extern char *fgets (char *__restrict __s, int __n,
+                   FILE *__restrict __stream) __THROW;
 
 #ifdef __USE_GNU
 /* This function does the same as `fgets' but does not lock the stream.  */
-extern char *fgets_unlocked __P ((char *__restrict __s, int __n,
-                                 FILE *__restrict __stream));
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+                            FILE *__restrict __stream) __THROW;
 #endif
 
 /* Get a newline-terminated string from stdin, removing the newline.
    DO NOT USE THIS FUNCTION!!  There is no limit on how much it will read.  */
-extern char *gets __P ((char *__s));
+extern char *gets (char *__s) __THROW;
 
 
 #ifdef __USE_GNU
@@ -651,14 +648,14 @@ extern char *gets __P ((char *__s));
    NULL), pointing to *N characters of space.  It is realloc'd as
    necessary.  Returns the number of characters read (not including the
    null terminator), or -1 on error or EOF.  */
-ssize_t __getdelim __P ((char **__lineptr, size_t *__n,
-                        int __delimiter, FILE *__stream));
-ssize_t getdelim __P ((char **__lineptr, size_t *__n,
-                      int __delimiter, FILE *__stream));
+ssize_t __getdelim (char **__lineptr, size_t *__n,
+                   int __delimiter, FILE *__stream) __THROW;
+ssize_t getdelim (char **__lineptr, size_t *__n,
+                 int __delimiter, FILE *__stream) __THROW;
 
 /* Like `getdelim', but reads up to a newline.  */
-ssize_t __getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
-ssize_t getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
+ssize_t __getline (char **__lineptr, size_t *__n, FILE *__stream) __THROW;
+ssize_t getline (char **__lineptr, size_t *__n, FILE *__stream) __THROW;
 
 #ifdef __OPTIMIZE__
 extern __inline ssize_t
@@ -671,59 +668,60 @@ getline (char **__lineptr, size_t *__n, FILE *__stream) __THROW
 
 
 /* Write a string to STREAM.  */
-extern int fputs __P ((__const char *__restrict __s,
-                      FILE *__restrict __stream));
+extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
+     __THROW;
 
 #ifdef __USE_GNU
 /* This function does the same as `fputs' but does not lock the stream.  */
-extern int fputs_unlocked __P ((__const char *__restrict __s,
-                               FILE *__restrict __stream));
+extern int fputs_unlocked (__const char *__restrict __s,
+                          FILE *__restrict __stream) __THROW;
 #endif
 
 /* Write a string, followed by a newline, to stdout.  */
-extern int puts __P ((__const char *__s));
+extern int puts (__const char *__s) __THROW;
 
 
 /* Push a character back onto the input buffer of STREAM.  */
-extern int ungetc __P ((int __c, FILE *__stream));
+extern int ungetc (int __c, FILE *__stream) __THROW;
 
 
 /* Read chunks of generic data from STREAM.  */
-extern size_t fread __P ((__ptr_t __restrict __ptr, size_t __size,
-                         size_t __n, FILE *__restrict __stream));
+extern size_t fread (void *__restrict __ptr, size_t __size,
+                    size_t __n, FILE *__restrict __stream) __THROW;
 /* Write chunks of generic data to STREAM.  */
-extern size_t fwrite __P ((__const __ptr_t __restrict __ptr, size_t __size,
-                          size_t __n, FILE *__restrict __s));
+extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
+                     size_t __n, FILE *__restrict __s) __THROW;
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not necessary.  */
-extern size_t fread_unlocked __P ((void *__restrict __ptr, size_t __size,
-                                  size_t __n, FILE *__restrict __stream));
-extern size_t fwrite_unlocked __P ((__const void *__restrict __ptr,
-                                   size_t __size, size_t __n,
-                                   FILE *__restrict __stream));
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+                             size_t __n, FILE *__restrict __stream) __THROW;
+extern size_t fwrite_unlocked (__const void *__restrict __ptr,
+                              size_t __size, size_t __n,
+                              FILE *__restrict __stream) __THROW;
 #endif
 
 
 /* Seek to a certain position on STREAM.  */
-extern int fseek __P ((FILE *__stream, long int __off, int __whence));
+extern int fseek (FILE *__stream, long int __off, int __whence) __THROW;
 /* Return the current position of STREAM.  */
-extern long int ftell __P ((FILE *__stream));
+extern long int ftell (FILE *__stream) __THROW;
 /* Rewind to the beginning of STREAM.  */
-extern void rewind __P ((FILE *__stream));
+extern void rewind (FILE *__stream) __THROW;
 
 /* Get STREAM's position.  */
-extern int fgetpos __P ((FILE *__restrict __stream, fpos_t *__restrict __pos));
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos)
+     __THROW;
 /* Set STREAM's position.  */
-extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
+extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __THROW;
 
 
 /* Clear the error and EOF indicators for STREAM.  */
-extern void clearerr __P ((FILE *__stream));
+extern void clearerr (FILE *__stream) __THROW;
 /* Return the EOF indicator for STREAM.  */
-extern int feof __P ((FILE *__stream));
+extern int feof (FILE *__stream) __THROW;
 /* Return the error indicator for STREAM.  */
-extern int ferror __P ((FILE *__stream));
+extern int ferror (FILE *__stream) __THROW;
 
 #ifdef __OPTIMIZE__
 #define        feof(stream)    ((stream)->__eof != 0)
@@ -732,9 +730,9 @@ extern int ferror __P ((FILE *__stream));
 
 #ifdef __USE_MISC
 /* Faster versions when locking is not required.  */
-extern void clearerr_unlocked __P ((FILE *__stream));
-extern int feof_unlocked __P ((FILE *__stream));
-extern int ferror_unlocked __P ((FILE *__stream));
+extern void clearerr_unlocked (FILE *__stream) __THROW;
+extern int feof_unlocked (FILE *__stream) __THROW;
+extern int ferror_unlocked (FILE *__stream) __THROW;
 
 # ifdef        __OPTIMIZE__
 #  define feof_unlocked(stream)                ((stream)->__eof != 0)
@@ -743,39 +741,39 @@ extern int ferror_unlocked __P ((FILE *__stream));
 #endif
 
 /* Print a message describing the meaning of the value of errno.  */
-extern void perror __P ((__const char *__s));
+extern void perror (__const char *__s) __THROW;
 
 
 #ifdef __USE_POSIX
 /* Return the system file descriptor for STREAM.  */
-extern int fileno __P ((FILE *__stream));
+extern int fileno (FILE *__stream) __THROW;
 #endif /* Use POSIX.  */
 
 #ifdef __USE_MISC
 /* Faster version when locking is not required.  */
-extern int fileno_unlocked __P ((FILE *__stream));
+extern int fileno_unlocked (FILE *__stream) __THROW;
 #endif
 
 
 #if (defined __USE_POSIX2 || defined __USE_SVID || defined __USE_BSD || \
      defined __USE_MISC)
 /* Create a new stream connected to a pipe running the given command.  */
-extern FILE *popen __P ((__const char *__command, __const char *__modes));
+extern FILE *popen (__const char *__command, __const char *__modes) __THROW;
 
 /* Close a stream opened by popen and return the status of its child.  */
-extern int pclose __P ((FILE *__stream));
+extern int pclose (FILE *__stream) __THROW;
 #endif
 
 
 #ifdef __USE_POSIX
 /* Return the name of the controlling terminal.  */
-extern char *ctermid __P ((char *__s));
+extern char *ctermid (char *__s) __THROW;
 #endif
 
 
 #ifdef __USE_XOPEN
 /* Return the name of the current user.  */
-extern char *cuserid __P ((char *__s));
+extern char *cuserid (char *__s) __THROW;
 #endif
 
 
@@ -783,14 +781,13 @@ extern char *cuserid __P ((char *__s));
 struct obstack;                        /* See <obstack.h>.  */
 
 /* Open a stream that writes to OBSTACK.  */
-extern FILE *open_obstack_stream __P ((struct obstack *__obstack));
+extern FILE *open_obstack_stream (struct obstack *__obstack) __THROW;
 
 /* Write formatted output to an obstack.  */
-extern int obstack_printf __P ((struct obstack *__obstack,
-                               __const char *__format, ...));
-extern int obstack_vprintf __P ((struct obstack *__obstack,
-                                __const char *__format,
-                                __gnuc_va_list __args));
+extern int obstack_printf (struct obstack *__obstack,
+                          __const char *__format, ...) __THROW;
+extern int obstack_vprintf (struct obstack *__obstack, __const char *__format,
+                           __gnuc_va_list __args) __THROW;
 #endif
 
 
@@ -798,14 +795,14 @@ extern int obstack_vprintf __P ((struct obstack *__obstack,
 /* These are defined in POSIX.1:1996.  */
 
 /* Acquire ownership of STREAM.  */
-extern void flockfile __P ((FILE *__stream));
+extern void flockfile (FILE *__stream) __THROW;
 
 /* Try to acquire ownership of STREAM but do not block if it is not
    possible.  */
-extern int ftrylockfile __P ((FILE *__stream));
+extern int ftrylockfile (FILE *__stream) __THROW;
 
 /* Relinquish the ownership granted for STREAM.  */
-extern void funlockfile __P ((FILE *__stream));
+extern void funlockfile (FILE *__stream) __THROW;
 #endif /* POSIX || misc */
 
 #if defined __USE_XOPEN && !defined __USE_GNU
index 741eca7..374f6bb 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (C) 1992, 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1992, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -30,7 +30,7 @@ __BEGIN_DECLS
 #undef alloca
 
 /* Allocate a block that will be freed when the calling function exits.  */
-extern __ptr_t alloca __P ((size_t __size));
+extern void *alloca (size_t __size) __THROW;
 
 #ifdef __GNUC__
 # define alloca(size)  __builtin_alloca (size)
index 56139b9..ae16684 100644 (file)
@@ -92,13 +92,13 @@ enum
 
 /* Print message with given CLASSIFICATION, LABEL, SEVERITY, TEXT, ACTION
    and TAG to console or standard error.  */
-extern int fmtmsg __P ((long int __classification, __const char *__label,
-                       int __severity, __const char *__text,
-                       __const char *__action, __const char *__tag));
+extern int fmtmsg (long int __classification, __const char *__label,
+                  int __severity, __const char *__text,
+                  __const char *__action, __const char *__tag) __THROW;
 
 #ifdef __USE_SVID
 /* Add or remove severity level.  */
-extern int addseverity __P ((int __severity, __const char *__string));
+extern int addseverity (int __severity, __const char *__string) __THROW;
 #endif
 
 __END_DECLS
index de288a2..e665f07 100644 (file)
@@ -36,16 +36,16 @@ typedef __ssize_t ssize_t;
 __BEGIN_DECLS
 
 /* Formatting a monetary value according to the current locale.  */
-extern ssize_t strfmon __P ((char *__restrict __s, size_t __maxsize,
-                            __const char *__restrict __format, ...));
+extern ssize_t strfmon (char *__restrict __s, size_t __maxsize,
+                       __const char *__restrict __format, ...) __THROW;
 
 #ifdef __USE_GNU
 # include <xlocale.h>
 
 /* Formatting a monetary value according to the current locale.  */
-extern ssize_t __strfmon_l __P ((char *__restrict __s, size_t __maxsize,
-                                __locale_t loc,
-                                __const char *__restrict __format, ...));
+extern ssize_t __strfmon_l (char *__restrict __s, size_t __maxsize,
+                           __locale_t loc,
+                           __const char *__restrict __format, ...) __THROW;
 #endif
 
 __END_DECLS
index 70a975e..30a1083 100644 (file)
@@ -77,52 +77,52 @@ __extension__ typedef struct
 
 /* Maximum length of a multibyte character in the current locale.  */
 #define        MB_CUR_MAX      (__ctype_get_mb_cur_max ())
-extern size_t __ctype_get_mb_cur_max __P ((void));
+extern size_t __ctype_get_mb_cur_max (void) __THROW;
 
 
 /* Convert a string to a floating-point number.  */
-extern double atof __P ((__const char *__nptr));
+extern double atof (__const char *__nptr) __THROW;
 /* Convert a string to an integer.  */
-extern int atoi __P ((__const char *__nptr));
+extern int atoi (__const char *__nptr) __THROW;
 /* Convert a string to a long integer.  */
-extern long int atol __P ((__const char *__nptr));
+extern long int atol (__const char *__nptr) __THROW;
 
 #if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_MISC)
 /* These functions will part of the standard C library in ISO C 9X.  */
-__extension__ extern long long int atoll __P ((__const char *__nptr));
+__extension__ extern long long int atoll (__const char *__nptr) __THROW;
 #endif
 
 /* Convert a string to a floating-point number.  */
-extern double strtod __P ((__const char *__restrict __nptr,
-                          char **__restrict __endptr));
+extern double strtod (__const char *__restrict __nptr,
+                     char **__restrict __endptr) __THROW;
 
 #ifdef __USE_ISOC9X
 /* Likewise for `float' and `long double' sizes of floating-point numbers.  */
-extern float strtof __P ((__const char *__restrict __nptr,
-                         char **__restrict __endptr));
+extern float strtof (__const char *__restrict __nptr,
+                    char **__restrict __endptr) __THROW;
 
-extern __long_double_t strtold __P ((__const char *__restrict __nptr,
-                                    char **__restrict __endptr));
+extern long double strtold (__const char *__restrict __nptr,
+                           char **__restrict __endptr) __THROW;
 #endif
 
 /* Convert a string to a long integer.  */
-extern long int strtol __P ((__const char *__restrict __nptr,
-                            char **__restrict __endptr, int __base));
+extern long int strtol (__const char *__restrict __nptr,
+                       char **__restrict __endptr, int __base) __THROW;
 /* Convert a string to an unsigned long integer.  */
-extern unsigned long int strtoul __P ((__const char *__restrict __nptr,
-                                      char **__restrict __endptr,
-                                      int __base));
+extern unsigned long int strtoul (__const char *__restrict __nptr,
+                                 char **__restrict __endptr, int __base)
+     __THROW;
 
 #if defined __GNUC__ && defined __USE_BSD
 /* Convert a string to a quadword integer.  */
 __extension__
-extern long long int strtoq __P ((__const char *__restrict __nptr,
-                                 char **__restrict __endptr, int __base));
+extern long long int strtoq (__const char *__restrict __nptr,
+                            char **__restrict __endptr, int __base) __THROW;
 /* Convert a string to an unsigned quadword integer.  */
 __extension__
-extern unsigned long long int strtouq __P ((__const char *__restrict __nptr,
-                                           char **__restrict __endptr,
-                                           int __base));
+extern unsigned long long int strtouq (__const char *__restrict __nptr,
+                                      char **__restrict __endptr, int __base)
+     __THROW;
 #endif /* GCC and use BSD.  */
 
 #if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_MISC)
@@ -130,13 +130,13 @@ extern unsigned long long int strtouq __P ((__const char *__restrict __nptr,
 
 /* Convert a string to a quadword integer.  */
 __extension__
-extern long long int strtoll __P ((__const char *__restrict __nptr,
-                                  char **__restrict __endptr, int __base));
+extern long long int strtoll (__const char *__restrict __nptr,
+                             char **__restrict __endptr, int __base) __THROW;
 /* Convert a string to an unsigned quadword integer.  */
 __extension__
-extern unsigned long long int strtoull __P ((__const char *__restrict __nptr,
-                                            char **__restrict __endptr,
-                                            int __base));
+extern unsigned long long int strtoull (__const char *__restrict __nptr,
+                                       char **__restrict __endptr, int __base)
+     __THROW;
 #endif /* ISO C 9X or GCC and use MISC.  */
 
 
@@ -158,79 +158,77 @@ extern unsigned long long int strtoull __P ((__const char *__restrict __nptr,
 
 /* Special versions of the functions above which take the locale to
    use as an additional parameter.  */
-extern long int __strtol_l __P ((__const char *__restrict __nptr,
-                                char **__restrict __endptr, int __base,
-                                __locale_t __loc));
+extern long int __strtol_l (__const char *__r