Remove K&R compatibility.
authordrepper <drepper>
Sat, 9 Oct 1999 21:17:24 +0000 (21:17 +0000)
committerdrepper <drepper>
Sat, 9 Oct 1999 21:17:24 +0000 (21:17 +0000)
argp/argp.h
assert/assert.h
catgets/nl_types.h
ctype/ctype.h
db/db.h
db/ndbm.h
db2/db.h
db2/db_185.h
debug/execinfo.h
dirent/dirent.h
dlfcn/dlfcn.h

index cfa7116..adfc3e6 100644 (file)
 typedef int error_t;
 # define __error_t_defined
 #endif
-
-#ifndef __P
-# ifdef __cplusplus
-#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 7)
-#   define __P(args)   args throw ()
-#  else
-#   define __P(args)   args
-#  endif
-#  define __PMT(args)  args
-# elif defined __STDC__ && __STDC__ > 0
-#  define __P(args)    args
-#  define __PMT(args)  args
-# else
-#  define __P(args)    ()
-#  define __PMT(args)  ()
-# endif
-#endif
 \f
 #ifdef  __cplusplus
 extern "C" {
@@ -133,8 +116,8 @@ struct argp_state;          /* " */
 struct argp_child;             /* " */
 
 /* The type of a pointer to an argp parsing function.  */
-typedef error_t (*argp_parser_t) __PMT ((int key, char *arg,
-                                        struct argp_state *state));
+typedef error_t (*argp_parser_t) (int key, char *arg,
+                                 struct argp_state *state);
 
 /* What to return for unrecognized keys.  For special ARGP_KEY_ keys, such
    returns will simply be ignored.  For user keys, this error will be turned
@@ -247,8 +230,7 @@ struct argp
      has been done, so if any of the replacement text also needs translation,
      that should be done by the filter function.  INPUT is either the input
      supplied to argp_parse, or NULL, if argp_help was called directly.  */
-  char *(*help_filter) __PMT ((int __key, __const char *__text,
-                              void *__input));
+  char *(*help_filter) (int __key, __const char *__text, void *__input);
 
   /* If non-zero the strings used in the argp library are translated using
      the domain described by this string.  Otherwise the currently installed
@@ -391,15 +373,14 @@ struct argp_state
    routine returned a non-zero value, it is returned; otherwise 0 is
    returned.  This function may also call exit unless the ARGP_NO_HELP flag
    is set.  INPUT is a pointer to a value to be passed in to the parser.  */
-extern error_t argp_parse __P ((__const struct argp *__restrict __argp,
-                               int __argc, char **__restrict __argv,
-                               unsigned __flags, int *__restrict __arg_index,
-                               void *__restrict __input));
-extern error_t __argp_parse __P ((__const struct argp *__restrict __argp,
-                                 int __argc, char **__restrict __argv,
-                                 unsigned __flags,
-                                 int *__restrict __arg_index,
-                                 void *__restrict __input));
+extern error_t argp_parse (__const struct argp *__restrict __argp,
+                          int __argc, char **__restrict __argv,
+                          unsigned __flags, int *__restrict __arg_index,
+                          void *__restrict __input) __THROW;
+extern error_t __argp_parse (__const struct argp *__restrict __argp,
+                            int __argc, char **__restrict __argv,
+                            unsigned __flags, int *__restrict __arg_index,
+                            void *__restrict __input) __THROW;
 \f
 /* Global variables.  */
 
@@ -414,9 +395,9 @@ extern __const char *argp_program_version;
    calls this function with a stream to print the version to and a pointer to
    the current parsing state, and then exits (unless the ARGP_NO_EXIT flag is
    used).  This variable takes precedent over ARGP_PROGRAM_VERSION.  */
-extern void (*argp_program_version_hook) __PMT ((FILE *__restrict __stream,
-                                                struct argp_state *__restrict
-                                                __state));
+extern void (*argp_program_version_hook) (FILE *__restrict __stream,
+                                         struct argp_state *__restrict
+                                         __state);
 
 /* If defined or set by the user program, it should point to string that is
    the bug-reporting address for the program.  It will be printed by
@@ -461,12 +442,12 @@ extern error_t argp_err_exit_status;
 
 /* Output a usage message for ARGP to STREAM.  FLAGS are from the set
    ARGP_HELP_*.  */
-extern void argp_help __P ((__const struct argp *__restrict __argp,
-                           FILE *__restrict __stream,
-                           unsigned __flags, char *__restrict __name));
-extern void __argp_help __P ((__const struct argp *__restrict __argp,
-                             FILE *__restrict __stream, unsigned __flags,
-                             char *__name));
+extern void argp_help (__const struct argp *__restrict __argp,
+                      FILE *__restrict __stream,
+                      unsigned __flags, char *__restrict __name) __THROW;
+extern void __argp_help __P (__const struct argp *__restrict __argp,
+                            FILE *__restrict __stream, unsigned __flags,
+                            char *__name) __THROW;
 \f
 /* The following routines are intended to be called from within an argp
    parsing routine (thus taking an argp_state structure as the first
@@ -478,27 +459,25 @@ extern void __argp_help __P ((__const struct argp *__restrict __argp,
 
 /* Output, if appropriate, a usage message for STATE to STREAM.  FLAGS are
    from the set ARGP_HELP_*.  */
-extern void argp_state_help __P ((__const struct argp_state *__restrict
-                                 __state,
-                                 FILE *__restrict __stream,
-                                 unsigned int __flags));
-extern void __argp_state_help __P ((__const struct argp_state *__restrict
-                                   __state,
-                                   FILE *__restrict __stream,
-                                   unsigned int __flags));
+extern void argp_state_help (__const struct argp_state *__restrict __state,
+                            FILE *__restrict __stream,
+                            unsigned int __flags) __THROW;
+extern void __argp_state_help (__const struct argp_state *__restrict __state,
+                              FILE *__restrict __stream,
+                              unsigned int __flags) __THROW;
 
 /* Possibly output the standard usage message for ARGP to stderr and exit.  */
-extern void argp_usage __P ((__const struct argp_state *__state));
-extern void __argp_usage __P ((__const struct argp_state *__state));
+extern void argp_usage (__const struct argp_state *__state) __THROW;
+extern void __argp_usage (__const struct argp_state *__state) __THROW;
 
 /* If appropriate, print the printf string FMT and following args, preceded
    by the program name and `:', to stderr, and followed by a `Try ... --help'
    message, then exit (1).  */
-extern void argp_error __P ((__const struct argp_state *__restrict __state,
-                            __const char *__restrict __fmt, ...))
+extern void argp_error (__const struct argp_state *__restrict __state,
+                       __const char *__restrict __fmt, ...) __THROW
      __attribute__ ((__format__ (__printf__, 2, 3)));
-extern void __argp_error __P ((__const struct argp_state *__restrict __state,
-                              __const char *__restrict __fmt, ...))
+extern void __argp_error (__const struct argp_state *__restrict __state,
+                         __const char *__restrict __fmt, ...) __THROW
      __attribute__ ((__format__ (__printf__, 2, 3)));
 
 /* Similar to the standard gnu error-reporting function error(), but will
@@ -509,31 +488,32 @@ extern void __argp_error __P ((__const struct argp_state *__restrict __state,
    difference between this function and argp_error is that the latter is for
    *parsing errors*, and the former is for other problems that occur during
    parsing but don't reflect a (syntactic) problem with the input.  */
-extern void argp_failure __P ((__const struct argp_state *__restrict __state,
-                              int __status, int __errnum,
-                              __const char *__restrict __fmt, ...))
+extern void argp_failure (__const struct argp_state *__restrict __state,
+                         int __status, int __errnum,
+                         __const char *__restrict __fmt, ...) __THROW
      __attribute__ ((__format__ (__printf__, 4, 5)));
-extern void __argp_failure __P ((__const struct argp_state *__restrict __state,
-                                int __status, int __errnum,
-                                __const char *__restrict __fmt, ...))
+extern void __argp_failure (__const struct argp_state *__restrict __state,
+                           int __status, int __errnum,
+                           __const char *__restrict __fmt, ...) __THROW
      __attribute__ ((__format__ (__printf__, 4, 5)));
 
 /* Returns true if the option OPT is a valid short option.  */
-extern int _option_is_short __P ((__const struct argp_option *__opt));
-extern int __option_is_short __P ((__const struct argp_option *__opt));
+extern int _option_is_short (__const struct argp_option *__opt) __THROW;
+extern int __option_is_short (__const struct argp_option *__opt) __THROW;
 
 /* Returns true if the option OPT is in fact the last (unused) entry in an
    options array.  */
-extern int _option_is_end __P ((__const struct argp_option *__opt));
-extern int __option_is_end __P ((__const struct argp_option *__opt));
+extern int _option_is_end (__const struct argp_option *__opt) __THROW;
+extern int __option_is_end (__const struct argp_option *__opt) __THROW;
 
 /* Return the input field for ARGP in the parser corresponding to STATE; used
    by the help routines.  */
-extern void *_argp_input __P ((__const struct argp *__restrict __argp,
-                              __const struct argp_state *__restrict __state));
-extern void *__argp_input __P ((__const struct argp *__restrict __argp,
-                               __const struct argp_state *__restrict
-                               __state));
+extern void *_argp_input (__const struct argp *__restrict __argp,
+                         __const struct argp_state *__restrict __state)
+     __THROW;
+extern void *__argp_input (__const struct argp *__restrict __argp,
+                          __const struct argp_state *__restrict __state)
+     __THROW;
 \f
 #ifdef __USE_EXTERN_INLINES
 
index 326183a..b37583c 100644 (file)
 __BEGIN_DECLS
 
 /* This prints an "Assertion failed" message and aborts.  */
-extern void __assert_fail __P ((__const char *__assertion,
-                               __const char *__file,
-                               unsigned int __line,
-                               __const char *__function))
-     __attribute__ ((__noreturn__));
+extern void __assert_fail (__const char *__assertion, __const char *__file,
+                          unsigned int __line, __const char *__function)
+     __THROW __attribute__ ((__noreturn__));
 
 /* Likewise, but prints the error text for ERRNUM.  */
-extern void __assert_perror_fail __P ((int __errnum,
-                                      __const char *__file,
-                                      unsigned int __line,
-                                      __const char *__function))
-     __attribute__ ((__noreturn__));
+extern void __assert_perror_fail (int __errnum, __const char *__file,
+                                 unsigned int __line,
+                                 __const char *__function)
+     __THROW __attribute__ ((__noreturn__));
 
 __END_DECLS
 
index 960edb5..7de084d 100644 (file)
@@ -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
@@ -37,15 +37,15 @@ typedef void *nl_catd;
 typedef int nl_item;
 
 /* Open message catalog for later use, returning descriptor.  */
-extern nl_catd catopen __P ((__const char *__cat_name, int __flag));
+extern nl_catd catopen (__const char *__cat_name, int __flag) __THROW;
 
 /* Return translation with NUMBER in SET of CATALOG; if not found
    return STRING.  */
-extern char *catgets __P ((nl_catd __catalog, int __set, int __number,
-                          __const char *__string));
+extern char *catgets (nl_catd __catalog, int __set, int __number,
+                     __const char *__string) __THROW;
 
 /* Close message CATALOG.  */
-extern int catclose __P ((nl_catd __catalog));
+extern int catclose (nl_catd __catalog) __THROW;
 
 __END_DECLS
 
index f287568..fe8f4b1 100644 (file)
@@ -82,7 +82,7 @@ extern __const __int32_t *__ctype_toupper; /* Case conversions.  */
 #define        __isascii(c)    (((c) & ~0x7f) == 0)    /* If C is a 7 bit value.  */
 #define        __toascii(c)    ((c) & 0x7f)            /* Mask off high bits.  */
 
-#define        __exctype(name) extern int name __P ((int))
+#define        __exctype(name) extern int name (int) __THROW
 
 /* The following names are all functions:
      int isCHARACTERISTIC(int c);
@@ -106,21 +106,21 @@ __exctype (isblank);
 
 
 /* Return the lowercase version of C.  */
-extern int tolower __P ((int __c));
+extern int tolower (int __c) __THROW;
 
 /* Return the uppercase version of C.  */
-extern int toupper __P ((int __c));
+extern int toupper (int __c) __THROW;
 
 
 #if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
 
 /* Return nonzero iff C is in the ASCII set
    (i.e., is no more than 7 bits wide).  */
-extern int isascii __P ((int __c));
+extern int isascii (int __c) __THROW;
 
 /* Return the part of C that is in the ASCII set
    (i.e., the low-order 7 bits of C).  */
-extern int toascii __P ((int __c));
+extern int toascii (int __c) __THROW;
 
 /* These are the same as `toupper' and `tolower' except that they do not
    check the argument for being in the range of a `char'.  */
@@ -128,6 +128,24 @@ __exctype (_toupper);
 __exctype (_tolower);
 #endif /* Use SVID or use misc.  */
 
+/* This code is needed for the optimized mapping functions.  */
+#define __tobody(c, f, a, args) \
+  (__extension__                                                             \
+   ({ int __res;                                                             \
+      if (sizeof (c) > 1)                                                    \
+       {                                                                     \
+         if (__builtin_constant_p (c))                                       \
+           {                                                                 \
+             int __c = (c);                                                  \
+             __res = __c < -128 || __c > 255 ? __c : a[__c];                 \
+           }                                                                 \
+         else                                                                \
+           __res = f args;                                                   \
+       }                                                                     \
+      else                                                                   \
+       __res = a[(int) (c)];                                                 \
+      __res; }))
+
 #ifndef        __NO_CTYPE
 # define isalnum(c)    __isctype((c), _ISalnum)
 # define isalpha(c)    __isctype((c), _ISalpha)
@@ -161,25 +179,8 @@ toupper (int __c) __THROW
 # endif
 
 # if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
-#  define __tobody(c, f, a) \
-  (__extension__                                                             \
-   ({ int __res;                                                             \
-      if (sizeof (c) > 1)                                                    \
-       {                                                                     \
-         if (__builtin_constant_p (c))                                       \
-           {                                                                 \
-             int __c = (c);                                                  \
-             __res = __c < -128 || __c > 255 ? __c : a[__c];                 \
-           }                                                                 \
-         else                                                                \
-           __res = f (c);                                                    \
-       }                                                                     \
-      else                                                                   \
-       __res = a[(int) (c)];                                                 \
-      __res; }))
-
-#  define tolower(c) __tobody (c, tolower, __ctype_tolower)
-#  define toupper(c) __tobody (c, toupper, __ctype_toupper)
+#  define tolower(c) __tobody (c, tolower, __ctype_tolower, (c))
+#  define toupper(c) __tobody (c, toupper, __ctype_toupper, (c))
 # endif        /* Optimizing gcc */
 
 # if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN
@@ -211,13 +212,12 @@ toupper (int __c) __THROW
 
 /* These definitions are similar to the ones above but all functions
    take as an argument a handle for the locale which shall be used.  */
-# define __isctype_l(c, type, locale) \
+# ifdef __OPTIMIZE__
+#  define __isctype_l(c, type, locale) \
   ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
+# endif
 
-# define __tolower_l(c, locale)        ((int) (locale)->__ctype_tolower[(int) (c)])
-# define __toupper_l(c, locale)        ((int) (locale)->__ctype_toupper[(int) (c)])
-
-# define __exctype_l(name)     extern int name __P ((int, __locale_t))
+# define __exctype_l(name)     extern int name (int, __locale_t) __THROW
 
 /* The following names are all functions:
      int isCHARACTERISTIC(int c, locale_t *locale);
@@ -239,10 +239,17 @@ __exctype_l (__isblank_l);
 
 
 /* Return the lowercase version of C in locale L.  */
-extern int __tolower_l __P ((int __c, __locale_t __l));
+extern int __tolower_l (int __c, __locale_t __l) __THROW;
 
 /* Return the uppercase version of C.  */
-extern int __toupper_l __P ((int __c, __locale_t __l));
+extern int __toupper_l (int __c, __locale_t __l) __THROW;
+
+# if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus
+#  define __tolower_l(c, locale) \
+  __tobody (c, __tolower_l, (locale)->__ctype_tolower, (c, locale))
+#  define __toupper_l(c, locale) \
+  __tobody (c, __toupper_l, (locale)->__ctype_toupper, (c, locale))
+# endif        /* Optimizing gcc */
 
 
 # ifndef __NO_CTYPE
diff --git a/db/db.h b/db/db.h
index 8b7921f..183501c 100644 (file)
--- a/db/db.h
+++ b/db/db.h
@@ -117,14 +117,14 @@ typedef enum { DB_BTREE, DB_HASH, DB_RECNO } DBTYPE;
 /* Access method description structure. */
 typedef struct __db {
        DBTYPE type;                    /* Underlying db type. */
-       int (*close)    __PMT((struct __db *));
-       int (*del)      __PMT((const struct __db *, const DBT *, u_int));
-       int (*get)      __PMT((const struct __db *, const DBT *, DBT *, u_int));
-       int (*put)      __PMT((const struct __db *, DBT *, const DBT *, u_int));
-       int (*seq)      __PMT((const struct __db *, DBT *, DBT *, u_int));
-       int (*sync)     __PMT((const struct __db *, u_int));
+       int (*close)    (struct __db *);
+       int (*del)      (const struct __db *, const DBT *, u_int);
+       int (*get)      (const struct __db *, const DBT *, DBT *, u_int);
+       int (*put)      (const struct __db *, DBT *, const DBT *, u_int);
+       int (*seq)      (const struct __db *, DBT *, DBT *, u_int);
+       int (*sync)     (const struct __db *, u_int);
        void *internal;                 /* Access method private. */
-       int (*fd)       __PMT((const struct __db *));
+       int (*fd)       (const struct __db *);
 } DB;
 
 #define        BTREEMAGIC      0x053162
@@ -139,9 +139,9 @@ typedef struct {
        int     minkeypage;     /* minimum keys per page */
        u_int   psize;          /* page size */
        int     (*compare)      /* comparison function */
-           __PMT((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        size_t  (*prefix)       /* prefix function */
-           __PMT((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        int     lorder;         /* byte order */
 } BTREEINFO;
 
@@ -155,7 +155,7 @@ typedef struct {
        u_int   nelem;          /* number of elements */
        u_int   cachesize;      /* bytes to cache */
        u_int32_t               /* hash function */
-               (*hash) __PMT((const void *, size_t));
+               (*hash) (const void *, size_t);
        int     lorder;         /* byte order */
 } HASHINFO;
 
@@ -170,7 +170,7 @@ typedef struct {
        int     lorder;         /* byte order */
        size_t  reclen;         /* record length (fixed-length records) */
        u_char  bval;           /* delimiting byte (variable-length records */
-       char    *bfname;        /* btree file name */ 
+       char    *bfname;        /* btree file name */
 } RECNOINFO;
 
 #ifdef __DBINTERFACE_PRIVATE
@@ -224,14 +224,14 @@ typedef struct {
 #endif
 
 __BEGIN_DECLS
-DB *__dbopen __P((const char *, int, int, DBTYPE, const void *));
-DB *dbopen __P((const char *, int, int, DBTYPE, const void *));
+DB *__dbopen (const char *, int, int, DBTYPE, const void *) __THROW;
+DB *dbopen (const char *, int, int, DBTYPE, const void *) __THROW;
 
 #ifdef __DBINTERFACE_PRIVATE
-DB     *__bt_open __P((const char *, int, int, const BTREEINFO *, int));
-DB     *__hash_open __P((const char *, int, int, const HASHINFO *, int));
-DB     *__rec_open __P((const char *, int, int, const RECNOINFO *, int));
-void    __dbpanic __P((DB *dbp));
+DB     *__bt_open (const char *, int, int, const BTREEINFO *, int) __THROW;
+DB     *__hash_open (const char *, int, int, const HASHINFO *, int) __THROW;
+DB     *__rec_open (const char *, int, int, const RECNOINFO *, int) __THROW;
+void    __dbpanic (DB *dbp) __THROW;
 #endif
 __END_DECLS
 
index db14dff..b05aa56 100644 (file)
--- a/db/ndbm.h
+++ b/db/ndbm.h
@@ -63,17 +63,17 @@ typedef DB DBM;
 #define        dbm_pagfno(a)   DBM_PAGFNO_NOT_AVAILABLE
 
 __BEGIN_DECLS
-void    dbm_close __P((DBM *));
-int     dbm_delete __P((DBM *, datum));
-datum   dbm_fetch __P((DBM *, datum));
-datum   dbm_firstkey __P((DBM *));
-long    dbm_forder __P((DBM *, datum));
-datum   dbm_nextkey __P((DBM *));
-DBM    *dbm_open __P((const char *, int, int));
-int     dbm_store __P((DBM *, datum, datum, int));
-int     dbm_dirfno __P((DBM *));
-int     dbm_error __P((DBM *));
-int     dbm_clearerr __P((DBM *));
+void    dbm_close (DBM *);
+int     dbm_delete (DBM *, datum);
+datum   dbm_fetch (DBM *, datum);
+datum   dbm_firstkey (DBM *);
+long    dbm_forder (DBM *, datum);
+datum   dbm_nextkey (DBM *);
+DBM    *dbm_open (const char *, int, int);
+int     dbm_store (DBM *, datum, datum, int);
+int     dbm_dirfno (DBM *);
+int     dbm_error (DBM *);
+int     dbm_clearerr (DBM *);
 __END_DECLS
 
 #endif /* ndbm.h */
index b04c897..306f2ff 100644 (file)
--- a/db2/db.h
+++ b/db2/db.h
@@ -201,12 +201,12 @@ struct __db_env {
        int              db_lorder;     /* Byte order. */
 
                                        /* Error message callback. */
-       void (*db_errcall) __P((const char *, char *));
+       void (*db_errcall) (const char *, char *);
        FILE            *db_errfile;    /* Error message file stream. */
        const char      *db_errpfx;     /* Error message prefix. */
        int              db_verbose;    /* Generate debugging messages. */
        int              db_panic;      /* Panic flag, callback function. */
-       void (*db_paniccall) __P((DB_ENV *, int));
+       void (*db_paniccall) (DB_ENV *, int);
 
        /* User paths. */
        char            *db_home;       /* Database home. */
@@ -237,7 +237,7 @@ struct __db_env {
        DB_TXNMGR       *tx_info;       /* Return from txn_open(). */
        u_int32_t        tx_max;        /* Maximum number of transactions. */
        int (*tx_recover)               /* Dispatch function for recovery. */
-           __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
+           (DB_LOG *, DBT *, DB_LSN *, int, void *);
 
        /*
         * XA support.
@@ -293,23 +293,23 @@ struct __db_info {
        size_t           db_pagesize;   /* Underlying page size. */
 
                                        /* Local heap allocation. */
-       void *(*db_malloc) __P((size_t));
+       void *(*db_malloc) (size_t);
        int (*dup_compare)              /* Duplicate compare function. */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
 
        /* Btree access method. */
        u_int32_t        bt_maxkey;     /* Maximum keys per page. */
        u_int32_t        bt_minkey;     /* Minimum keys per page. */
        int (*bt_compare)               /* Comparison function. */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        size_t (*bt_prefix)             /* Prefix function. */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
 
        /* Hash access method. */
        u_int32_t        h_ffactor;     /* Fill factor. */
        u_int32_t        h_nelem;       /* Number of elements. */
        u_int32_t      (*h_hash)        /* Hash function. */
-           __P((const void *, u_int32_t));
+           (const void *, u_int32_t);
 
        /* Recno access method. */
        int              re_pad;        /* Fixed-length padding byte. */
@@ -423,23 +423,23 @@ struct __db {
        size_t    pgsize;               /* Logical page size of file. */
 
                                        /* Local heap allocation. */
-       void *(*db_malloc) __P((size_t));
+       void *(*db_malloc) (size_t);
        int (*dup_compare)              /* Duplicate compare function. */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        u_int32_t (*h_hash)             /* Hash function. */
-           __P((const void *, u_int32_t));
+           (const void *, u_int32_t);
 
                                        /* Functions. */
-       int (*am_close) __P((DB *));
-       int (*close)    __P((DB *, u_int32_t));
-       int (*cursor)   __P((DB *, DB_TXN *, DBC **, u_int32_t));
-       int (*del)      __P((DB *, DB_TXN *, DBT *, u_int32_t));
-       int (*fd)       __P((DB *, int *));
-       int (*get)      __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
-       int (*join)     __P((DB *, DBC **, u_int32_t, DBC **));
-       int (*put)      __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
-       int (*stat)     __P((DB *, void *, void *(*)(size_t), u_int32_t));
-       int (*sync)     __P((DB *, u_int32_t));
+       int (*am_close) (DB *);
+       int (*close)    (DB *, u_int32_t);
+       int (*cursor)   (DB *, DB_TXN *, DBC **, u_int32_t);
+       int (*del)      (DB *, DB_TXN *, DBT *, u_int32_t);
+       int (*fd)       (DB *, int *);
+       int (*get)      (DB *, DB_TXN *, DBT *, DBT *, u_int32_t);
+       int (*join)     (DB *, DBC **, u_int32_t, DBC **);
+       int (*put)      (DB *, DB_TXN *, DBT *, DBT *, u_int32_t);
+       int (*stat)     (DB *, void *, void *(*)(size_t), u_int32_t);
+       int (*sync)     (DB *, u_int32_t);
 
 #define        DB_AM_CDB       0x000001        /* Concurrent Access Methods. */
 #define        DB_AM_DUP       0x000002        /* DB_DUP (internal). */
@@ -491,12 +491,12 @@ struct __dbc {
        DBT rkey;                       /* Returned key. */
        DBT rdata;                      /* Returned data. */
 
-       int (*c_am_close) __P((DBC *));
-       int (*c_am_destroy) __P((DBC *));
-       int (*c_close) __P((DBC *));
-       int (*c_del) __P((DBC *, u_int32_t));
-       int (*c_get) __P((DBC *, DBT *, DBT *, u_int32_t));
-       int (*c_put) __P((DBC *, DBT *, DBT *, u_int32_t));
+       int (*c_am_close) (DBC *);
+       int (*c_am_destroy) (DBC *);
+       int (*c_close) (DBC *);
+       int (*c_del) (DBC *, u_int32_t);
+       int (*c_get) (DBC *, DBT *, DBT *, u_int32_t);
+       int (*c_put) (DBC *, DBT *, DBT *, u_int32_t);
 
        void     *internal;             /* Access method private. */
 
@@ -556,15 +556,14 @@ struct __db_h_stat {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int   db_appinit __P((const char *, char * const *, DB_ENV *, u_int32_t));
-int   db_appexit __P((DB_ENV *));
-int   db_jump_set __P((void *, int));
-int   db_open __P((const char *,
-         DBTYPE, u_int32_t, int, DB_ENV *, DB_INFO *, DB **));
-int   db_value_set __P((int, int));
-char *db_version __P((int *, int *, int *));
-int   db_xa_open __P((const char *,
-         DBTYPE, u_int32_t, int, DB_INFO *, DB **));
+int   db_appinit (const char *, char * const *, DB_ENV *, u_int32_t);
+int   db_appexit (DB_ENV *);
+int   db_jump_set (void *, int);
+int   db_open (const char *,
+              DBTYPE, u_int32_t, int, DB_ENV *, DB_INFO *, DB **);
+int   db_value_set (int, int);
+char *db_version (int *, int *, int *);
+int   db_xa_open (const char *, DBTYPE, u_int32_t, int, DB_INFO *, DB **);
 #if defined(__cplusplus)
 }
 #endif
@@ -674,22 +673,21 @@ struct __db_lock_stat {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int      lock_close __P((DB_LOCKTAB *));
-int      lock_detect __P((DB_LOCKTAB *, u_int32_t, u_int32_t));
-int      lock_get __P((DB_LOCKTAB *,
-           u_int32_t, u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *));
-int      lock_id __P((DB_LOCKTAB *, u_int32_t *));
-int      lock_open __P((const char *,
-           u_int32_t, int, DB_ENV *, DB_LOCKTAB **));
-int      lock_put __P((DB_LOCKTAB *, DB_LOCK));
-int      lock_tget __P((DB_LOCKTAB *,
-           DB_TXN *, u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *));
-int      lock_stat __P((DB_LOCKTAB *, DB_LOCK_STAT **, void *(*)(size_t)));
-int      lock_unlink __P((const char *, int, DB_ENV *));
-int      lock_vec __P((DB_LOCKTAB *,
-           u_int32_t, u_int32_t, DB_LOCKREQ *, int, DB_LOCKREQ **));
-int      lock_tvec __P((DB_LOCKTAB *,
-           DB_TXN *, u_int32_t, DB_LOCKREQ *, int, DB_LOCKREQ **));
+int      lock_close (DB_LOCKTAB *);
+int      lock_detect (DB_LOCKTAB *, u_int32_t, u_int32_t);
+int      lock_get (DB_LOCKTAB *,
+           u_int32_t, u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *);
+int      lock_id (DB_LOCKTAB *, u_int32_t *);
+int      lock_open (const char *, u_int32_t, int, DB_ENV *, DB_LOCKTAB **);
+int      lock_put (DB_LOCKTAB *, DB_LOCK);
+int      lock_tget (DB_LOCKTAB *,
+           DB_TXN *, u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *);
+int      lock_stat (DB_LOCKTAB *, DB_LOCK_STAT **, void *(*)(size_t));
+int      lock_unlink (const char *, int, DB_ENV *);
+int      lock_vec (DB_LOCKTAB *,
+           u_int32_t, u_int32_t, DB_LOCKREQ *, int, DB_LOCKREQ **);
+int      lock_tvec (DB_LOCKTAB *,
+           DB_TXN *, u_int32_t, DB_LOCKREQ *, int, DB_LOCKREQ **);
 #if defined(__cplusplus)
 }
 #endif
@@ -739,18 +737,18 @@ struct __db_log_stat {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int     log_archive __P((DB_LOG *, char **[], u_int32_t, void *(*)(size_t)));
-int     log_close __P((DB_LOG *));
-int     log_compare __P((const DB_LSN *, const DB_LSN *));
-int     log_file __P((DB_LOG *, const DB_LSN *, char *, size_t));
-int     log_flush __P((DB_LOG *, const DB_LSN *));
-int     log_get __P((DB_LOG *, DB_LSN *, DBT *, u_int32_t));
-int     log_open __P((const char *, u_int32_t, int, DB_ENV *, DB_LOG **));
-int     log_put __P((DB_LOG *, DB_LSN *, const DBT *, u_int32_t));
-int     log_register __P((DB_LOG *, DB *, const char *, DBTYPE, u_int32_t *));
-int     log_stat __P((DB_LOG *, DB_LOG_STAT **, void *(*)(size_t)));
-int     log_unlink __P((const char *, int, DB_ENV *));
-int     log_unregister __P((DB_LOG *, u_int32_t));
+int     log_archive (DB_LOG *, char **[], u_int32_t, void *(*)(size_t));
+int     log_close (DB_LOG *);
+int     log_compare (const DB_LSN *, const DB_LSN *);
+int     log_file (DB_LOG *, const DB_LSN *, char *, size_t);
+int     log_flush (DB_LOG *, const DB_LSN *);
+int     log_get (DB_LOG *, DB_LSN *, DBT *, u_int32_t);
+int     log_open (const char *, u_int32_t, int, DB_ENV *, DB_LOG **);
+int     log_put (DB_LOG *, DB_LSN *, const DBT *, u_int32_t);
+int     log_register (DB_LOG *, DB *, const char *, DBTYPE, u_int32_t *);
+int     log_stat (DB_LOG *, DB_LOG_STAT **, void *(*)(size_t));
+int     log_unlink (const char *, int, DB_ENV *);
+int     log_unregister (DB_LOG *, u_int32_t);
 #if defined(__cplusplus)
 }
 #endif
@@ -816,23 +814,23 @@ struct __db_mpool_fstat {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int    memp_close __P((DB_MPOOL *));
-int    memp_fclose __P((DB_MPOOLFILE *));
-int    memp_fget __P((DB_MPOOLFILE *, db_pgno_t *, u_int32_t, void *));
-int    memp_fopen __P((DB_MPOOL *, const char *,
-           u_int32_t, int, size_t, DB_MPOOL_FINFO *, DB_MPOOLFILE **));
-int    memp_fput __P((DB_MPOOLFILE *, void *, u_int32_t));
-int    memp_fset __P((DB_MPOOLFILE *, void *, u_int32_t));
-int    memp_fsync __P((DB_MPOOLFILE *));
-int    memp_open __P((const char *, u_int32_t, int, DB_ENV *, DB_MPOOL **));
-int    memp_register __P((DB_MPOOL *, int,
+int    memp_close (DB_MPOOL *);
+int    memp_fclose (DB_MPOOLFILE *);
+int    memp_fget (DB_MPOOLFILE *, db_pgno_t *, u_int32_t, void *);
+int    memp_fopen (DB_MPOOL *, const char *,
+           u_int32_t, int, size_t, DB_MPOOL_FINFO *, DB_MPOOLFILE **);
+int    memp_fput (DB_MPOOLFILE *, void *, u_int32_t);
+int    memp_fset (DB_MPOOLFILE *, void *, u_int32_t);
+int    memp_fsync (DB_MPOOLFILE *);
+int    memp_open (const char *, u_int32_t, int, DB_ENV *, DB_MPOOL **);
+int    memp_register (DB_MPOOL *, int,
            int (*)(db_pgno_t, void *, DBT *),
-           int (*)(db_pgno_t, void *, DBT *)));
-int    memp_stat __P((DB_MPOOL *,
-           DB_MPOOL_STAT **, DB_MPOOL_FSTAT ***, void *(*)(size_t)));
-int    memp_sync __P((DB_MPOOL *, DB_LSN *));
-int    memp_trickle __P((DB_MPOOL *, int, int *));
-int    memp_unlink __P((const char *, int, DB_ENV *));
+           int (*)(db_pgno_t, void *, DBT *));
+int    memp_stat (DB_MPOOL *,
+           DB_MPOOL_STAT **, DB_MPOOL_FSTAT ***, void *(*)(size_t));
+int    memp_sync (DB_MPOOL *, DB_LSN *);
+int    memp_trickle (DB_MPOOL *, int, int *);
+int    memp_unlink (const char *, int, DB_ENV *);
 #if defined(__cplusplus)
 }
 #endif
@@ -879,16 +877,16 @@ struct __db_txn_stat {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int      txn_abort __P((DB_TXN *));
-int      txn_begin __P((DB_TXNMGR *, DB_TXN *, DB_TXN **));
-int      txn_checkpoint __P((const DB_TXNMGR *, u_int32_t, u_int32_t));
-int      txn_commit __P((DB_TXN *));
-int      txn_close __P((DB_TXNMGR *));
-u_int32_t txn_id __P((DB_TXN *));
-int      txn_open __P((const char *, u_int32_t, int, DB_ENV *, DB_TXNMGR **));
-int      txn_prepare __P((DB_TXN *));
-int      txn_stat __P((DB_TXNMGR *, DB_TXN_STAT **, void *(*)(size_t)));
-int      txn_unlink __P((const char *, int, DB_ENV *));
+int      txn_abort (DB_TXN *);
+int      txn_begin (DB_TXNMGR *, DB_TXN *, DB_TXN **);
+int      txn_checkpoint (const DB_TXNMGR *, u_int32_t, u_int32_t);
+int      txn_commit (DB_TXN *);
+int      txn_close (DB_TXNMGR *);
+u_int32_t txn_id (DB_TXN *);
+int      txn_open (const char *, u_int32_t, int, DB_ENV *, DB_TXNMGR **);
+int      txn_prepare (DB_TXN *);
+int      txn_stat (DB_TXNMGR *, DB_TXN_STAT **, void *(*)(size_t));
+int      txn_unlink (const char *, int, DB_ENV *);
 #if defined(__cplusplus)
 }
 #endif
@@ -942,16 +940,16 @@ typedef struct {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int     __db_dbm_close __P((void));
-int     __db_dbm_dbrdonly __P((void));
-int     __db_dbm_delete __P((datum));
-int     __db_dbm_dirf __P((void));
-datum   __db_dbm_fetch __P((datum));
-datum   __db_dbm_firstkey __P((void));
-int     __db_dbm_init __P((char *));
-datum   __db_dbm_nextkey __P((datum));
-int     __db_dbm_pagf __P((void));
-int     __db_dbm_store __P((datum, datum));
+int     __db_dbm_close (void);
+int     __db_dbm_dbrdonly (void);
+int     __db_dbm_delete (datum);
+int     __db_dbm_dirf (void);
+datum   __db_dbm_fetch (datum);
+datum   __db_dbm_firstkey (void);
+int     __db_dbm_init (char *);
+datum   __db_dbm_nextkey (datum);
+int     __db_dbm_pagf (void);
+int     __db_dbm_store (datum, datum);
 #if defined(__cplusplus)
 }
 #endif
@@ -977,18 +975,18 @@ int        __db_dbm_store __P((datum, datum));
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int     __db_ndbm_clearerr __P((DBM *));
-void    __db_ndbm_close __P((DBM *));
-int     __db_ndbm_delete __P((DBM *, datum));
-int     __db_ndbm_dirfno __P((DBM *));
-int     __db_ndbm_error __P((DBM *));
-datum   __db_ndbm_fetch __P((DBM *, datum));
-datum   __db_ndbm_firstkey __P((DBM *));
-datum   __db_ndbm_nextkey __P((DBM *));
-DBM    *__db_ndbm_open __P((const char *, int, int));
-int     __db_ndbm_pagfno __P((DBM *));
-int     __db_ndbm_rdonly __P((DBM *));
-int     __db_ndbm_store __P((DBM *, datum, datum, int));
+int     __db_ndbm_clearerr (DBM *);
+void    __db_ndbm_close (DBM *);
+int     __db_ndbm_delete (DBM *, datum);
+int     __db_ndbm_dirfno (DBM *);
+int     __db_ndbm_error (DBM *);
+datum   __db_ndbm_fetch (DBM *, datum);
+datum   __db_ndbm_firstkey (DBM *);
+datum   __db_ndbm_nextkey (DBM *);
+DBM    *__db_ndbm_open (const char *, int, int);
+int     __db_ndbm_pagfno (DBM *);
+int     __db_ndbm_rdonly (DBM *);
+int     __db_ndbm_store (DBM *, datum, datum, int);
 #if defined(__cplusplus)
 }
 #endif
@@ -1017,9 +1015,9 @@ typedef struct entry {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-int     __db_hcreate __P((size_t));
-void    __db_hdestroy __P((void));
-ENTRY  *__db_hsearch __P((ENTRY, ACTION));
+int     __db_hcreate (size_t);
+void    __db_hdestroy (void);
+ENTRY  *__db_hsearch (ENTRY, ACTION);
 #if defined(__cplusplus)
 }
 #endif
index a928ca8..456a8b4 100644 (file)
@@ -111,14 +111,14 @@ typedef enum { DB_BTREE, DB_HASH, DB_RECNO } DBTYPE;
 /* Access method description structure. */
 typedef struct __db {
        DBTYPE type;                    /* Underlying db type. */
-       int (*close)    __P((struct __db *));
-       int (*del)      __P((const struct __db *, const DBT *, u_int));
-       int (*get)      __P((const struct __db *, const DBT *, DBT *, u_int));
-       int (*put)      __P((const struct __db *, DBT *, const DBT *, u_int));
-       int (*seq)      __P((const struct __db *, DBT *, DBT *, u_int));
-       int (*sync)     __P((const struct __db *, u_int));
+       int (*close)    (struct __db *);
+       int (*del)      (const struct __db *, const DBT *, u_int);
+       int (*get)      (const struct __db *, const DBT *, DBT *, u_int);
+       int (*put)      (const struct __db *, DBT *, const DBT *, u_int);
+       int (*seq)      (const struct __db *, DBT *, DBT *, u_int);
+       int (*sync)     (const struct __db *, u_int);
        void *internal;                 /* Access method private. */
-       int (*fd)       __P((const struct __db *));
+       int (*fd)       (const struct __db *);
 } DB;
 
 #define        BTREEMAGIC      0x053162
@@ -133,9 +133,9 @@ typedef struct {
        u_int32_t minkeypage;   /* minimum keys per page */
        u_int32_t psize;        /* page size */
        int     (*compare)      /* comparison function */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        size_t  (*prefix)       /* prefix function */
-           __P((const DBT *, const DBT *));
+           (const DBT *, const DBT *);
        int     lorder;         /* byte order */
 } BTREEINFO;
 
@@ -149,7 +149,7 @@ typedef struct {
        u_int32_t nelem;        /* number of elements */
        u_int32_t cachesize;    /* bytes to cache */
        u_int32_t               /* hash function */
-               (*hash) __P((const void *, size_t));
+               (*hash) (const void *, size_t);
        int     lorder;         /* byte order */
 } HASHINFO;
 
@@ -170,7 +170,7 @@ typedef struct {
 #if defined(__cplusplus)
 extern "C" {
 #endif
-DB *dbopen __P((const char *, int, int, DBTYPE, const void *));
+DB *dbopen (const char *, int, int, DBTYPE, const void *);
 
 #if defined(__cplusplus)
 }
index 9e0e551..87267fb 100644 (file)
@@ -1,4 +1,4 @@
-/* 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
@@ -25,23 +25,19 @@ __BEGIN_DECLS
 
 /* Store up to SIZE return address of the current program state in
    ARRAY and return the exact number of values stored.  */
-extern int __backtrace __P ((void **__array, int __size));
-extern int backtrace __P ((void **__array, int __size));
+extern int backtrace (void **__array, int __size) __THROW;
 
 
 /* Return names of functions from the backtrace list in ARRAY in a newly
    malloc()ed memory block.  */
-extern char **__backtrace_symbols __P ((void *__const *__array, int __size));
-extern char **backtrace_symbols __P ((void *__const *__array, int __size));
+extern char **backtrace_symbols (void *__const *__array, int __size) __THROW;
 
 
 /* This function is similar to backtrace_symbols() but it writes the result
    immediately to a file and can therefore also be used in situations where
    malloc() is not usable anymore.  */
-extern void __backtrace_symbols_fd __P ((void *__const *__array, int __size,
-                                        int __fd));
-extern void backtrace_symbols_fd __P ((void *__const *__array, int __size,
-                                      int __fd));
+extern void backtrace_symbols_fd (void *__const *__array, int __size,
+                                 int __fd) __THROW;
 
 __END_DECLS
 
index 29b9cd5..8caa93c 100644 (file)
@@ -127,11 +127,11 @@ typedef struct __dirstream DIR;
 
 /* Open a directory stream on NAME.
    Return a DIR stream on the directory, or NULL if it could not be opened.  */
-extern DIR *opendir __P ((__const char *__name));
+extern DIR *opendir (__const char *__name) __THROW;
 
 /* Close the directory stream DIRP.
    Return 0 if successful, -1 if not.  */
-extern int closedir __P ((DIR *__dirp));
+extern int closedir (DIR *__dirp) __THROW;
 
 /* Read a directory entry from DIRP.  Return a pointer to a `struct
    dirent' describing the entry, or NULL for EOF or error.  The
@@ -141,61 +141,62 @@ extern int closedir __P ((DIR *__dirp));
    If the Large File Support API is selected we have to use the
    appropriate interface.  */
 #ifndef __USE_FILE_OFFSET64
-extern struct dirent *readdir __P ((DIR *__dirp));
+extern struct dirent *readdir (DIR *__dirp) __THROW;
 #else
 # ifdef __REDIRECT
-extern struct dirent *__REDIRECT (readdir, __P ((DIR *__dirp)), readdir64);
+extern struct dirent *__REDIRECT (readdir, (DIR *__dirp) __THROW, readdir64);
 # else
 #  define readdir readdir64
 # endif
 #endif
 
 #ifdef __USE_LARGEFILE64
-extern struct dirent64 *readdir64 __P ((DIR *__dirp));
+extern struct dirent64 *readdir64 (DIR *__dirp) __THROW;
 #endif
 
 #if defined __USE_POSIX || defined __USE_MISC
 /* Reentrant version of `readdir'.  Return in RESULT a pointer to the
    next entry.  */
 # ifndef __USE_FILE_OFFSET64
-extern int readdir_r __P ((DIR *__restrict __dirp,
-                          struct dirent *__restrict __entry,
-                          struct dirent **__restrict __result));
+extern int readdir_r (DIR *__restrict __dirp,
+                     struct dirent *__restrict __entry,
+                     struct dirent **__restrict __result) __THROW;
 # else
 #  ifdef __REDIRECT
-extern int __REDIRECT (readdir_r, __P ((DIR *__restrict __dirp,
-                                       struct dirent *__restrict __entry,
-                                       struct dirent **__restrict __result)),
-                   readdir64_r);
+extern int __REDIRECT (readdir_r,
+                      (DIR *__restrict __dirp,
+                       struct dirent *__restrict __entry,
+                       struct dirent **__restrict __result) __THROW,
+                      readdir64_r);
 #  else
 #   define readdir_r readdir64_r
 #  endif
 # endif
 
 # ifdef __USE_LARGEFILE64
-extern int readdir64_r __P ((DIR *__restrict __dirp,
-                            struct dirent64 *__restrict __entry,
-                            struct dirent64 **__restrict __result));
+extern int readdir64_r (DIR *__restrict __dirp,
+                       struct dirent64 *__restrict __entry,
+                       struct dirent64 **__restrict __result) __THROW;
 # endif
 #endif /* POSIX or misc */
 
 /* Rewind DIRP to the beginning of the directory.  */
-extern void rewinddir __P ((DIR *__dirp));
+extern void rewinddir (DIR *__dirp) __THROW;
 
 #if defined __USE_BSD || defined __USE_MISC || defined __USE_XOPEN
 # include <bits/types.h>
 
 /* Seek to position POS on DIRP.  */
-extern void seekdir __P ((DIR *__dirp, long int __pos));
+extern void seekdir (DIR *__dirp, long int __pos) __THROW;
 
 /* Return the current position of DIRP.  */
-extern long int telldir __P ((DIR *__dirp));
+extern long int telldir (DIR *__dirp) __THROW;
 #endif
 
 #if defined __USE_BSD || defined __USE_MISC
 
 /* Return the file descriptor used by DIRP.  */
-extern int dirfd __P ((DIR *__dirp));
+extern int dirfd (DIR *__dirp) __THROW;
 
 # if defined __OPTIMIZE__ && defined _DIR_dirfd
 #  define dirfd(dirp)  _DIR_dirfd (dirp)
@@ -221,17 +222,17 @@ extern int dirfd __P ((DIR *__dirp));
    sorted using qsort with CMP, and collected in a malloc'd array in
    *NAMELIST.  Returns the number of entries selected, or -1 on error.  */
 # ifndef __USE_FILE_OFFSET64
-extern int scandir __P ((__const char *__restrict __dir,
-                        struct dirent ***__restrict __namelist,
-                        int (*__selector) (__const struct dirent *),
-                        int (*__cmp) (__const __ptr_t, __const __ptr_t)));
+extern int scandir (__const char *__restrict __dir,
+                   struct dirent ***__restrict __namelist,
+                   int (*__selector) (__const struct dirent *),
+                   int (*__cmp) (__const void *, __const void *)) __THROW;
 # else
 #  ifdef __REDIRECT
 extern int __REDIRECT (scandir,
-                      __P ((__const char *__restrict __dir,
-                            struct dirent ***__restrict __namelist,
-                            int (*__selector) (__const struct dirent *),
-                            int (*__cmp) (__const __ptr_t, __const __ptr_t))),
+                      (__const char *__restrict __dir,
+                       struct dirent ***__restrict __namelist,
+                       int (*__selector) (__const struct dirent *),
+                       int (*__cmp) (__const void *, __const void *)) __THROW,
                       scandir64);
 #  else
 #   define scandir scandir64
@@ -241,19 +242,19 @@ extern int __REDIRECT (scandir,
 # if defined __USE_GNU && defined __USE_LARGEFILE64
 /* This function is like `scandir' but it uses the 64bit dirent structure.
    Please note that the CMP function must now work with struct dirent64 **.  */
-extern int scandir64 __P ((__const char *__restrict __dir,
-                          struct dirent64 ***__restrict __namelist,
-                          int (*__selector) (__const struct dirent64 *),
-                          int (*__cmp) (__const __ptr_t, __const __ptr_t)));
+extern int scandir64 (__const char *__restrict __dir,
+                     struct dirent64 ***__restrict __namelist,
+                     int (*__selector) (__const struct dirent64 *),
+                     int (*__cmp) (__const void *, __const void *)) __THROW;
 # endif
 
 /* Function to compare two `struct dirent's alphabetically.  */
 # ifndef __USE_FILE_OFFSET64
-extern int alphasort __P ((__const __ptr_t __e1, __const __ptr_t __e2));
+extern int alphasort (__const void *__e1, __const void *__e2) __THROW;
 # else
 #  ifdef __REDIRECT
 extern int __REDIRECT (alphasort,
-                      __P ((__const __ptr_t __e1, __const __ptr_t __e2)),
+                      (__const void *__e1, __const void *__e2) __THROW,
                       alphasort64);
 #  else
 #   define alphasort alphasort64
@@ -261,17 +262,17 @@ extern int __REDIRECT (alphasort,
 # endif
 
 # if defined __USE_GNU && defined __USE_LARGEFILE64
-extern int alphasort64 __P ((__const __ptr_t __e1, __const __ptr_t __e2));
+extern int alphasort64 (__const void *__e1, __const void *__e2) __THROW;
 # endif
 
 # ifdef __USE_GNU
 /* Function to compare two `struct dirent's by name & version.  */
 #  ifndef __USE_FILE_OFFSET64
-extern int versionsort __P ((__const __ptr_t __e1, __const __ptr_t __e2));
+extern int versionsort (__const void *__e1, __const void *__e2) __THROW;
 #  else
 #   ifdef __REDIRECT
 extern int __REDIRECT (versionsort,
-                      __P ((__const __ptr_t __e1, __const __ptr_t __e2)),
+                      (__const void *__e1, __const void *__e2) __THROW,
                       versionsort64);
 #   else
 #    define versionsort versionsort64
@@ -279,7 +280,7 @@ extern int __REDIRECT (versionsort,
 #  endif
 
 #  ifdef __USE_LARGEFILE64
-extern int versionsort64 __P ((__const __ptr_t __e1, __const __ptr_t __e2));
+extern int versionsort64 (__const void *__e1, __const void *__e2) __THROW;
 #  endif
 # endif
 
@@ -288,15 +289,15 @@ extern int versionsort64 __P ((__const __ptr_t __e1, __const __ptr_t __e2));
    position after reading.  Returns the number of bytes read; zero when at
    end of directory; or -1 for errors.  */
 # ifndef __USE_FILE_OFFSET64
-extern __ssize_t getdirentries __P ((int __fd, char *__restrict __buf,
-                                    size_t __nbytes,
-                                    __off_t *__restrict __basep));
+extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
+                               size_t __nbytes,
+                               __off_t *__restrict __basep) __THROW;
 # else
 #  ifdef __REDIRECT
 extern __ssize_t __REDIRECT (getdirentries,
-                            __P ((int __fd, char *__restrict __buf,
-                                  size_t __nbytes,
-                                  __off_t *__restrict __basep)),
+                            (int __fd, char *__restrict __buf,
+                             size_t __nbytes,
+                             __off_t *__restrict __basep) __THROW,
                             getdirentries64);
 #  else
 #   define getdirentries getdirentries64
@@ -304,9 +305,9 @@ extern __ssize_t __REDIRECT (getdirentries,
 # endif
 
 # ifdef __USE_LARGEFILE64
-extern __ssize_t getdirentries64 __P ((int __fd, char *__restrict __buf,
-                                      size_t __nbytes,
-                                      __off64_t *__restrict __basep));
+extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
+                                 size_t __nbytes,
+                                 __off64_t *__restrict __basep) __THROW;
 # endif
 
 #endif /* Use BSD or misc.  */
index 22ab9aa..b1c51c0 100644 (file)
@@ -44,29 +44,29 @@ __BEGIN_DECLS
 
 /* Open the shared object FILE and map it in; return a handle that can be
    passed to `dlsym' to get symbol values from it.  */
-extern void *dlopen __P ((__const char *__file, int __mode));
+extern void *dlopen (__const char *__file, int __mode) __THROW;
 
 /* Unmap and close a shared object opened by `dlopen'.
    The handle cannot be used again after calling `dlclose'.  */
-extern int dlclose __P ((void *__handle));
+extern int dlclose (void *__handle) __THROW;
 
 /* Find the run-time address in the shared object HANDLE refers to
    of the symbol called NAME.  */
-extern void *dlsym __P ((void *__restrict __handle,
-                        __const char *__restrict __name));
+extern void *dlsym (void *__restrict __handle,
+                   __const char *__restrict __name) __THROW;
 
 #ifdef __USE_GNU
 /* Find the run-time address in the shared object HANDLE refers to
    of the symbol called NAME with VERSION.  */
-extern void *dlvsym __P ((void *__restrict __handle,
-                         __const char *__restrict __name,
-                         __const char *__restrict __version));
+extern void *dlvsym (void *__restrict __handle,
+                    __const char *__restrict __name,
+                    __const char *__restrict __version) __THROW;
 #endif
 
 /* When any of the above functions fails, call this function
    to return a string describing the error.  Each call resets
    the error string so that a following call returns null.  */
-extern char *dlerror __P ((void));
+extern char *dlerror (void) __THROW;
 
 #ifdef __USE_GNU
 /* Fill in *INFO with the following information about ADDRESS.
@@ -78,7 +78,7 @@ typedef struct
     __const char *dli_sname;   /* Name of nearest symbol.  */
     void *dli_saddr;           /* Exact value of nearest symbol.  */
   } Dl_info;
-extern int dladdr __P ((const void *__address, Dl_info *__info));
+extern int dladdr (const void *__address, Dl_info *__info) __THROW;
 
 /* To support profiling of shared objects it is a good idea to call
    the function found using `dlsym' using the following macro since
@@ -94,7 +94,7 @@ extern int dladdr __P ((const void *__address, Dl_info *__info));
   (_dl_mcount_wrapper_check (fctp), (*(fctp)) args)
 
 /* This function calls the profiling functions.  */
-extern void _dl_mcount_wrapper_check __P ((void *__selfpc));
+extern void _dl_mcount_wrapper_check (void *__selfpc) __THROW;
 #endif
 
 __END_DECLS