+2024-09-16 Paul Eggert <eggert@cs.ucla.edu>
+
+ Don’t port July [[...]] changes to C89
+ Yesterday’s changes to port to C17 and earlier were intrusive,
+ since they twice replaced one macro with two. Revert the macro
+ definitions to what they were before yesterday, and instead change
+ callers so that they always have four arguments even if the last
+ one is empty. Although this change requires C99 or later, that’s
+ safe nowadays. Suggested by Bruno Haible in:
+ https://lists.gnu.org/r/bug-gnulib/2024-09/msg00079.html
+ * lib/c++defs.h (_GL_FUNCDECL_RPL, _GL_FUNCDECL_SYS):
+ Revert yesterday’s changes. All callers changed.
+ Add comments explaining the required comma before missing attrs.
+
2024-09-16 Bruno Haible <bruno@clisp.org>
wchar: Fix compilation error (regression yesterday).
# undef inet_ntop
# define inet_ntop rpl_inet_ntop
# endif
-_GL_FUNCATTR_RPL (inet_ntop, const char *,
+_GL_FUNCDECL_RPL (inet_ntop, const char *,
(int af, const void *restrict src,
char *restrict dst, socklen_t cnt),
_GL_ARG_NONNULL ((2, 3)));
char *restrict dst, socklen_t cnt));
# else
# if !@HAVE_DECL_INET_NTOP@
-_GL_FUNCATTR_SYS (inet_ntop, const char *,
+_GL_FUNCDECL_SYS (inet_ntop, const char *,
(int af, const void *restrict src,
char *restrict dst, socklen_t cnt),
_GL_ARG_NONNULL ((2, 3)));
# undef inet_pton
# define inet_pton rpl_inet_pton
# endif
-_GL_FUNCATTR_RPL (inet_pton, int,
+_GL_FUNCDECL_RPL (inet_pton, int,
(int af, const char *restrict src, void *restrict dst),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (inet_pton, int,
(int af, const char *restrict src, void *restrict dst));
# else
# if !@HAVE_DECL_INET_PTON@
-_GL_FUNCATTR_SYS (inet_pton, int,
+_GL_FUNCDECL_SYS (inet_pton, int,
(int af, const char *restrict src, void *restrict dst),
_GL_ARG_NONNULL ((2, 3)));
# endif
# define _GL_EXTERN_C_FUNC
#endif
-/* _GL_FUNCDECL_RPL (func, rettype, parameters);
- _GL_FUNCATTR_RPL (func, rettype, parameters, attributes);
+/* _GL_FUNCDECL_RPL (func, rettype, parameters, [attributes]);
declares a replacement function, named rpl_func, with the given prototype,
- consisting of return type and parameters. Use _GL_FUNCDECL_RPL if the
- function lacks attributes, _GL_FUNCATTR_RPL if it has them.
- Example:
- _GL_FUNCATTR_RPL (open, int, (const char *filename, int flags, ...),
+ consisting of return type, parameters, and attributes.
+ Although attributes are optional, the comma before them is required
+ for portability to C17 and earlier. The attribute _GL_ATTRIBUTE_NOTHROW,
+ if needed, must be placed after the _GL_FUNCDECL_RPL invocation,
+ at the end of the declaration.
+ Examples:
+ _GL_FUNCDECL_RPL (free, void, (void *ptr), ) _GL_ATTRIBUTE_NOTHROW;
+ _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...),
_GL_ARG_NONNULL ((1)));
Note: Attributes, such as _GL_ATTRIBUTE_DEPRECATED, are supported in front
- of an invocation only in C mode, not in C++ mode. (That's because
+ of a _GL_FUNCDECL_RPL invocation only in C mode, not in C++ mode. (That's
+ because
[[...]] extern "C" <declaration>;
is invalid syntax in C++.)
-
- Note: The attribute _GL_ATTRIBUTE_NOTHROW, if needed, must be placed outside
- of the invocation, at the end of the declaration.
*/
-#define _GL_FUNCDECL_RPL(func,rettype,parameters) \
- _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters)
-#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters) \
- _GL_EXTERN_C_FUNC rettype rpl_func parameters
-#define _GL_FUNCATTR_RPL(func,rettype,parameters,attrs) \
- _GL_FUNCATTR_RPL_1 (rpl_##func, rettype, parameters, attrs)
-#define _GL_FUNCATTR_RPL_1(rpl_func,rettype,parameters,attrs) \
- _GL_EXTERN_C_FUNC attrs rettype rpl_func parameters
+#define _GL_FUNCDECL_RPL(func,rettype,parameters,...) \
+ _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters, __VA_ARGS__)
+#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters,...) \
+ _GL_EXTERN_C_FUNC __VA_ARGS__ rettype rpl_func parameters
-/* _GL_FUNCDECL_SYS (func, rettype, parameters);
- _GL_FUNCATTR_SYS (func, rettype, parameters, attributes);
+/* _GL_FUNCDECL_SYS (func, rettype, parameters, [attributes]);
declares the system function, named func, with the given prototype,
- consisting of return type and parameters. Use _GL_FUNCDECL_SYS if the
- function lacks attributes, _GL_FUNCATTR_SYS if it has them.
- Example:
- _GL_FUNCATTR_SYS (open, int, (const char *filename, int flags, ...),
- _GL_ARG_NONNULL ((1)));
-
- Note: The attribute _GL_ATTRIBUTE_NOTHROW, if needed, must be placed outside
- of the invocation, at the end of the declaration.
+ consisting of return type, parameters, and attributes.
+ Although attributes are optional, the comma before them is required
+ for portability to C17 and earlier. The attribute _GL_ATTRIBUTE_NOTHROW,
+ if needed, must be placed after the _GL_FUNCDECL_RPL invocation,
+ at the end of the declaration.
+ Examples:
+ _GL_FUNCDECL_SYS (getumask, mode_t, (void), ) _GL_ATTRIBUTE_NOTHROW;
+ _GL_FUNCDECL_SYS (posix_openpt, int, (int flags), _GL_ATTRIBUTE_NODISCARD);
*/
-#define _GL_FUNCDECL_SYS(func,rettype,parameters) \
- _GL_EXTERN_C_FUNC rettype func parameters
-#define _GL_FUNCATTR_SYS(func,rettype,parameters,attrs) \
- _GL_EXTERN_C_FUNC attrs rettype func parameters
+#define _GL_FUNCDECL_SYS(func,rettype,parameters,...) \
+ _GL_EXTERN_C_FUNC __VA_ARGS__ rettype func parameters
/* _GL_CXXALIAS_RPL (func, rettype, parameters);
declares a C++ alias called GNULIB_NAMESPACE::func
# define closedir rpl_closedir
# define GNULIB_defined_closedir 1
# endif
-_GL_FUNCATTR_RPL (closedir, int, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (closedir, int, (DIR *dirp), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (closedir, int, (DIR *dirp));
# else
# if !@HAVE_CLOSEDIR@
-_GL_FUNCATTR_SYS (closedir, int, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (closedir, int, (DIR *dirp), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (closedir, int, (DIR *dirp));
# endif
# define opendir rpl_opendir
# define GNULIB_defined_opendir 1
# endif
-_GL_FUNCATTR_RPL (opendir, DIR *,
+_GL_FUNCDECL_RPL (opendir, DIR *,
(const char *dir_name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
_GL_CXXALIAS_RPL (opendir, DIR *, (const char *dir_name));
# else
# if !@HAVE_OPENDIR@ || (__GNUC__ >= 11 && !defined __clang__)
-_GL_FUNCATTR_SYS (opendir, DIR *,
+_GL_FUNCDECL_SYS (opendir, DIR *,
(const char *dir_name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
&& (__GNUC__ >= 11 && !defined __clang__) && !defined opendir
/* For -Wmismatched-dealloc: Associate opendir with closedir or
rpl_closedir. */
-_GL_FUNCATTR_SYS (opendir, DIR *,
+_GL_FUNCDECL_SYS (opendir, DIR *,
(const char *dir_name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# undef readdir
# define readdir rpl_readdir
# endif
-_GL_FUNCATTR_RPL (readdir, struct dirent *, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (readdir, struct dirent *, (DIR *dirp), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (readdir, struct dirent *, (DIR *dirp));
# else
# if !@HAVE_READDIR@
-_GL_FUNCATTR_SYS (readdir, struct dirent *, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (readdir, struct dirent *, (DIR *dirp), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (readdir, struct dirent *, (DIR *dirp));
# endif
# undef rewinddir
# define rewinddir rpl_rewinddir
# endif
-_GL_FUNCATTR_RPL (rewinddir, void, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (rewinddir, void, (DIR *dirp), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (rewinddir, void, (DIR *dirp));
# else
# if !@HAVE_REWINDDIR@
-_GL_FUNCATTR_SYS (rewinddir, void, (DIR *dirp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (rewinddir, void, (DIR *dirp), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (rewinddir, void, (DIR *dirp));
# endif
# undef dirfd
# define dirfd rpl_dirfd
# endif
-_GL_FUNCATTR_RPL (dirfd, int, (DIR *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (dirfd, int, (DIR *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (dirfd, int, (DIR *));
# else
# undef dirfd
# endif
# if !(@HAVE_DECL_DIRFD@ || defined dirfd)
-_GL_FUNCATTR_SYS (dirfd, int, (DIR *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (dirfd, int, (DIR *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (dirfd, int, (DIR *));
# endif
# undef fdopendir
# define fdopendir rpl_fdopendir
# endif
-_GL_FUNCATTR_RPL (fdopendir, DIR *,
+_GL_FUNCDECL_RPL (fdopendir, DIR *,
(int fd),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
_GL_CXXALIAS_RPL (fdopendir, DIR *, (int fd));
# else
# if !@HAVE_FDOPENDIR@ || !@HAVE_DECL_FDOPENDIR@ \
|| (__GNUC__ >= 11 && !defined __clang__)
-_GL_FUNCATTR_SYS (fdopendir, DIR *,
+_GL_FUNCDECL_SYS (fdopendir, DIR *,
(int fd),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
&& (__GNUC__ >= 11 && !defined __clang__) && !defined fdopendir
/* For -Wmismatched-dealloc: Associate fdopendir with closedir or
rpl_closedir. */
-_GL_FUNCATTR_SYS (fdopendir, DIR *,
+_GL_FUNCDECL_SYS (fdopendir, DIR *,
(int fd),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
sorted using qsort with CMP, and collected in a malloc'd array in
*NAMELIST. Returns the number of entries selected, or -1 on error. */
# if !@HAVE_SCANDIR@
-_GL_FUNCATTR_SYS (scandir, int,
+_GL_FUNCDECL_SYS (scandir, int,
(const char *dir, struct dirent ***namelist,
int (*filter) (const struct dirent *),
int (*cmp) (const struct dirent **, const struct dirent **)),
#if @GNULIB_ALPHASORT@
/* Compare two 'struct dirent' entries alphabetically. */
# if !@HAVE_ALPHASORT@
-_GL_FUNCATTR_SYS (alphasort, int,
+_GL_FUNCDECL_SYS (alphasort, int,
(const struct dirent **, const struct dirent **),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# undef error
# define error rpl_error
# endif
-_GL_FUNCATTR_RPL (error, void,
+_GL_FUNCDECL_RPL (error, void,
(int __status, int __errnum, const char *__format, ...),
_GL_ATTRIBUTE_COLD
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 3, 4)));
# endif
#else
# if ! @HAVE_ERROR@
-_GL_FUNCATTR_SYS (error, void,
+_GL_FUNCDECL_SYS (error, void,
(int __status, int __errnum, const char *__format, ...),
_GL_ATTRIBUTE_COLD
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 3, 4)));
# undef error_at_line
# define error_at_line rpl_error_at_line
# endif
-_GL_FUNCATTR_RPL (error_at_line, void,
+_GL_FUNCDECL_RPL (error_at_line, void,
(int __status, int __errnum, const char *__filename,
unsigned int __lineno, const char *__format, ...),
_GL_ATTRIBUTE_COLD
# endif
#else
# if ! @HAVE_ERROR_AT_LINE@
-_GL_FUNCATTR_SYS (error_at_line, void,
+_GL_FUNCDECL_SYS (error_at_line, void,
(int __status, int __errnum, const char *__filename,
unsigned int __lineno, const char *__format, ...),
_GL_ATTRIBUTE_COLD
# undef creat
# define creat rpl_creat
# endif
-_GL_FUNCATTR_RPL (creat, int, (const char *filename, mode_t mode),
+_GL_FUNCDECL_RPL (creat, int, (const char *filename, mode_t mode),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (creat, int, (const char *filename, mode_t mode));
# elif defined _WIN32 && !defined __CYGWIN__
# undef fcntl
# define fcntl rpl_fcntl
# endif
-_GL_FUNCDECL_RPL (fcntl, int, (int fd, int action, ...));
+_GL_FUNCDECL_RPL (fcntl, int, (int fd, int action, ...), );
_GL_CXXALIAS_RPL (fcntl, int, (int fd, int action, ...));
# if !GNULIB_defined_rpl_fcntl
# define GNULIB_defined_rpl_fcntl 1
# endif
# else
# if !@HAVE_FCNTL@
-_GL_FUNCDECL_SYS (fcntl, int, (int fd, int action, ...));
+_GL_FUNCDECL_SYS (fcntl, int, (int fd, int action, ...), );
# if !GNULIB_defined_fcntl
# define GNULIB_defined_fcntl 1
# endif
# undef open
# define open rpl_open
# endif
-_GL_FUNCATTR_RPL (open, int, (const char *filename, int flags, ...),
+_GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
# elif defined _WIN32 && !defined __CYGWIN__
# undef openat
# define openat rpl_openat
# endif
-_GL_FUNCATTR_RPL (openat, int,
+_GL_FUNCDECL_RPL (openat, int,
(int fd, char const *file, int flags, /* mode_t mode */ ...),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (openat, int,
(int fd, char const *file, int flags, /* mode_t mode */ ...));
# else
# if !@HAVE_OPENAT@
-_GL_FUNCATTR_SYS (openat, int,
+_GL_FUNCDECL_SYS (openat, int,
(int fd, char const *file, int flags, /* mode_t mode */ ...),
_GL_ARG_NONNULL ((2)));
# endif
# undef fegetenv
# define fegetenv rpl_fegetenv
# endif
-_GL_FUNCDECL_RPL (fegetenv, int, (fenv_t *envp));
+_GL_FUNCDECL_RPL (fegetenv, int, (fenv_t *envp), );
_GL_CXXALIAS_RPL (fegetenv, int, (fenv_t *envp));
# else
# if !@HAVE_FEGETENV@
-_GL_FUNCDECL_SYS (fegetenv, int, (fenv_t *envp));
+_GL_FUNCDECL_SYS (fegetenv, int, (fenv_t *envp), );
# endif
_GL_CXXALIAS_SYS (fegetenv, int, (fenv_t *envp));
# endif
# undef fesetenv
# define fesetenv rpl_fesetenv
# endif
-_GL_FUNCDECL_RPL (fesetenv, int, (fenv_t const *envp));
+_GL_FUNCDECL_RPL (fesetenv, int, (fenv_t const *envp), );
_GL_CXXALIAS_RPL (fesetenv, int, (fenv_t const *envp));
# else
# if !@HAVE_FESETENV@
-_GL_FUNCDECL_SYS (fesetenv, int, (fenv_t const *envp));
+_GL_FUNCDECL_SYS (fesetenv, int, (fenv_t const *envp), );
# endif
_GL_CXXALIAS_SYS (fesetenv, int, (fenv_t const *envp));
# endif
# undef feupdateenv
# define feupdateenv rpl_feupdateenv
# endif
-_GL_FUNCDECL_RPL (feupdateenv, int, (fenv_t const *envp));
+_GL_FUNCDECL_RPL (feupdateenv, int, (fenv_t const *envp), );
_GL_CXXALIAS_RPL (feupdateenv, int, (fenv_t const *envp));
# else
# if !@HAVE_FEUPDATEENV@
-_GL_FUNCDECL_SYS (feupdateenv, int, (fenv_t const *envp));
+_GL_FUNCDECL_SYS (feupdateenv, int, (fenv_t const *envp), );
# endif
_GL_CXXALIAS_SYS (feupdateenv, int, (fenv_t const *envp));
# endif
# undef feholdexcept
# define feholdexcept rpl_feholdexcept
# endif
-_GL_FUNCDECL_RPL (feholdexcept, int, (fenv_t *envp));
+_GL_FUNCDECL_RPL (feholdexcept, int, (fenv_t *envp), );
_GL_CXXALIAS_RPL (feholdexcept, int, (fenv_t *envp));
# else
# if !@HAVE_FEHOLDEXCEPT@
-_GL_FUNCDECL_SYS (feholdexcept, int, (fenv_t *envp));
+_GL_FUNCDECL_SYS (feholdexcept, int, (fenv_t *envp), );
# endif
_GL_CXXALIAS_SYS (feholdexcept, int, (fenv_t *envp));
# endif
# undef fegetround
# define fegetround rpl_fegetround
# endif
-_GL_FUNCDECL_RPL (fegetround, int, (void));
+_GL_FUNCDECL_RPL (fegetround, int, (void), );
_GL_CXXALIAS_RPL (fegetround, int, (void));
# else
# if !@HAVE_FEGETROUND@
-_GL_FUNCDECL_SYS (fegetround, int, (void));
+_GL_FUNCDECL_SYS (fegetround, int, (void), );
# endif
_GL_CXXALIAS_SYS (fegetround, int, (void));
# endif
# undef fesetround
# define fesetround rpl_fesetround
# endif
-_GL_FUNCDECL_RPL (fesetround, int, (int rounding_direction));
+_GL_FUNCDECL_RPL (fesetround, int, (int rounding_direction), );
_GL_CXXALIAS_RPL (fesetround, int, (int rounding_direction));
# else
# if !@HAVE_FESETROUND@
-_GL_FUNCDECL_SYS (fesetround, int, (int rounding_direction));
+_GL_FUNCDECL_SYS (fesetround, int, (int rounding_direction), );
# endif
_GL_CXXALIAS_SYS (fesetround, int, (int rounding_direction));
# endif
# undef feclearexcept
# define feclearexcept rpl_feclearexcept
# endif
-_GL_FUNCDECL_RPL (feclearexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (feclearexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (feclearexcept, int, (int exceptions));
# else
# if !@HAVE_FECLEAREXCEPT@
-_GL_FUNCDECL_SYS (feclearexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (feclearexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (feclearexcept, int, (int exceptions));
# endif
# undef feraiseexcept
# define feraiseexcept rpl_feraiseexcept
# endif
-_GL_FUNCDECL_RPL (feraiseexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (feraiseexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (feraiseexcept, int, (int exceptions));
# else
# if !@HAVE_FERAISEEXCEPT@
-_GL_FUNCDECL_SYS (feraiseexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (feraiseexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (feraiseexcept, int, (int exceptions));
# endif
# undef fetestexcept
# define fetestexcept rpl_fetestexcept
# endif
-_GL_FUNCDECL_RPL (fetestexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (fetestexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (fetestexcept, int, (int exceptions));
# else
# if !@HAVE_FETESTEXCEPT@
-_GL_FUNCDECL_SYS (fetestexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (fetestexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (fetestexcept, int, (int exceptions));
# endif
# undef fesetexcept
# define fesetexcept rpl_fesetexcept
# endif
-_GL_FUNCDECL_RPL (fesetexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (fesetexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (fesetexcept, int, (int exceptions));
# else
# if !@HAVE_FESETEXCEPT@
-_GL_FUNCDECL_SYS (fesetexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (fesetexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (fesetexcept, int, (int exceptions));
# endif
# undef feenableexcept
# define feenableexcept rpl_feenableexcept
# endif
-_GL_FUNCDECL_RPL (feenableexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (feenableexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (feenableexcept, int, (int exceptions));
# else
# if !@HAVE_FEENABLEEXCEPT@
-_GL_FUNCDECL_SYS (feenableexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (feenableexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (feenableexcept, int, (int exceptions));
# endif
# undef fedisableexcept
# define fedisableexcept rpl_fedisableexcept
# endif
-_GL_FUNCDECL_RPL (fedisableexcept, int, (int exceptions));
+_GL_FUNCDECL_RPL (fedisableexcept, int, (int exceptions), );
_GL_CXXALIAS_RPL (fedisableexcept, int, (int exceptions));
# else
# if !@HAVE_FEDISABLEEXCEPT@
-_GL_FUNCDECL_SYS (fedisableexcept, int, (int exceptions));
+_GL_FUNCDECL_SYS (fedisableexcept, int, (int exceptions), );
# endif
_GL_CXXALIAS_SYS (fedisableexcept, int, (int exceptions));
# endif
# undef fegetexcept
# define fegetexcept rpl_fegetexcept
# endif
-_GL_FUNCDECL_RPL (fegetexcept, int, (void));
+_GL_FUNCDECL_RPL (fegetexcept, int, (void), );
_GL_CXXALIAS_RPL (fegetexcept, int, (void));
# else
# if !@HAVE_FEGETEXCEPT@
-_GL_FUNCDECL_SYS (fegetexcept, int, (void));
+_GL_FUNCDECL_SYS (fegetexcept, int, (void), );
# endif
_GL_CXXALIAS_SYS (fegetexcept, int, (void));
# endif
# define fegetexceptflag rpl_fegetexceptflag
# endif
_GL_FUNCDECL_RPL (fegetexceptflag, int,
- (fexcept_t *saved_flags, int exceptions));
+ (fexcept_t *saved_flags, int exceptions), );
_GL_CXXALIAS_RPL (fegetexceptflag, int,
(fexcept_t *saved_flags, int exceptions));
# else
# if !@HAVE_FEGETEXCEPTFLAG@
_GL_FUNCDECL_SYS (fegetexceptflag, int,
- (fexcept_t *saved_flags, int exceptions));
+ (fexcept_t *saved_flags, int exceptions), );
# endif
_GL_CXXALIAS_SYS (fegetexceptflag, int,
(fexcept_t *saved_flags, int exceptions));
# define fesetexceptflag rpl_fesetexceptflag
# endif
_GL_FUNCDECL_RPL (fesetexceptflag, int,
- (fexcept_t const *saved_flags, int exceptions));
+ (fexcept_t const *saved_flags, int exceptions), );
_GL_CXXALIAS_RPL (fesetexceptflag, int,
(fexcept_t const *saved_flags, int exceptions));
# else
# if !@HAVE_FESETEXCEPTFLAG@
_GL_FUNCDECL_SYS (fesetexceptflag, int,
- (fexcept_t const *saved_flags, int exceptions));
+ (fexcept_t const *saved_flags, int exceptions), );
# endif
_GL_CXXALIAS_SYS (fesetexceptflag, int,
(fexcept_t const *saved_flags, int exceptions));
# define fetestexceptflag rpl_fetestexceptflag
# endif
_GL_FUNCDECL_RPL (fetestexceptflag, int,
- (fexcept_t const *saved_flags, int exceptions));
+ (fexcept_t const *saved_flags, int exceptions), );
_GL_CXXALIAS_RPL (fetestexceptflag, int,
(fexcept_t const *saved_flags, int exceptions));
# else
# if !@HAVE_FETESTEXCEPTFLAG@
_GL_FUNCDECL_SYS (fetestexceptflag, int,
- (fexcept_t const *saved_flags, int exceptions));
+ (fexcept_t const *saved_flags, int exceptions), );
# endif
_GL_CXXALIAS_SYS (fetestexceptflag, int,
(fexcept_t const *saved_flags, int exceptions));
# define fnmatch rpl_fnmatch
# endif
# define GNULIB_defined_fnmatch_function 1
-_GL_FUNCATTR_RPL (fnmatch, int,
+_GL_FUNCDECL_RPL (fnmatch, int,
(const char *pattern, const char *name, int flags),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (fnmatch, int,
# else
# if !@HAVE_FNMATCH@
# define GNULIB_defined_fnmatch_function 1
-_GL_FUNCATTR_SYS (fnmatch, int,
+_GL_FUNCDECL_SYS (fnmatch, int,
(const char *pattern, const char *name, int flags),
_GL_ARG_NONNULL ((1, 2)));
# endif
#if @GNULIB_GLOB@
# if @REPLACE_GLOB@
-_GL_FUNCATTR_RPL (glob, int, (const char *_Restrict_ __pattern, int __flags,
+_GL_FUNCDECL_RPL (glob, int, (const char *_Restrict_ __pattern, int __flags,
_gl_glob_errfunc_fn __errfunc,
glob_t *_Restrict_ __pglob),
_GL_ARG_NONNULL ((1)));
glob_t *_Restrict_ __pglob));
# else
# if !@HAVE_GLOB@
-_GL_FUNCATTR_SYS (glob, int, (const char *_Restrict_ __pattern, int __flags,
+_GL_FUNCDECL_SYS (glob, int, (const char *_Restrict_ __pattern, int __flags,
_gl_glob_errfunc_fn __errfunc,
glob_t *_Restrict_ __pglob),
_GL_ARG_NONNULL ((1)));
#if @GNULIB_GLOB@
# if @REPLACE_GLOB@
-_GL_FUNCATTR_RPL (globfree, void, (glob_t *__pglob), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (globfree, void, (glob_t *__pglob), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (globfree, void, (glob_t *__pglob));
# else
# if !@HAVE_GLOB@
-_GL_FUNCATTR_SYS (globfree, void, (glob_t *__pglob), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (globfree, void, (glob_t *__pglob), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (globfree, void, (glob_t *__pglob));
# endif
#if @GNULIB_GLOB@
# if @REPLACE_GLOB_PATTERN_P@
-_GL_FUNCATTR_RPL (glob_pattern_p, int, (const char *__pattern, int __quote),
+_GL_FUNCDECL_RPL (glob_pattern_p, int, (const char *__pattern, int __quote),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (glob_pattern_p, int, (const char *__pattern, int __quote));
# else
# if !@HAVE_GLOB_PATTERN_P@
-_GL_FUNCATTR_SYS (glob_pattern_p, int, (const char *__pattern, int __quote),
+_GL_FUNCDECL_SYS (glob_pattern_p, int, (const char *__pattern, int __quote),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (glob_pattern_p, int, (const char *__pattern, int __quote));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define iconv_open rpl_iconv_open
# endif
-_GL_FUNCATTR_RPL (iconv_open, iconv_t,
+_GL_FUNCDECL_RPL (iconv_open, iconv_t,
(const char *tocode, const char *fromcode),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (iconv_open, iconv_t,
(iconv_t cd,
@ICONV_CONST@ char **restrict inbuf,
size_t *restrict inbytesleft,
- char **restrict outbuf, size_t *restrict outbytesleft));
+ char **restrict outbuf, size_t *restrict outbytesleft), );
_GL_CXXALIAS_RPL (iconv, size_t,
(iconv_t cd,
@ICONV_CONST@ char **restrict inbuf,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define iconv_close rpl_iconv_close
# endif
-_GL_FUNCDECL_RPL (iconv_close, int, (iconv_t cd));
+_GL_FUNCDECL_RPL (iconv_close, int, (iconv_t cd), );
_GL_CXXALIAS_RPL (iconv_close, int, (iconv_t cd));
# else
_GL_CXXALIAS_SYS (iconv_close, int, (iconv_t cd));
# undef imaxabs
# define imaxabs rpl_imaxabs
# endif
-_GL_FUNCDECL_RPL (imaxabs, intmax_t, (intmax_t x));
+_GL_FUNCDECL_RPL (imaxabs, intmax_t, (intmax_t x), );
_GL_CXXALIAS_RPL (imaxabs, intmax_t, (intmax_t x));
# else
# if !@HAVE_DECL_IMAXABS@
-_GL_FUNCDECL_SYS (imaxabs, intmax_t, (intmax_t x));
+_GL_FUNCDECL_SYS (imaxabs, intmax_t, (intmax_t x), );
# endif
_GL_CXXALIAS_SYS (imaxabs, intmax_t, (intmax_t x));
# endif
# undef imaxdiv
# define imaxdiv rpl_imaxdiv
# endif
-_GL_FUNCDECL_RPL (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom));
+_GL_FUNCDECL_RPL (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom), );
_GL_CXXALIAS_RPL (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom));
# else
# if !@HAVE_DECL_IMAXDIV@
-_GL_FUNCDECL_SYS (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom));
+_GL_FUNCDECL_SYS (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom), );
# endif
_GL_CXXALIAS_SYS (imaxdiv, imaxdiv_t, (intmax_t numer, intmax_t denom));
# endif
# undef strtoimax
# define strtoimax rpl_strtoimax
# endif
-_GL_FUNCATTR_RPL (strtoimax, intmax_t,
+_GL_FUNCDECL_RPL (strtoimax, intmax_t,
(const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoimax, intmax_t,
# else
# if !@HAVE_DECL_STRTOIMAX@
# undef strtoimax
-_GL_FUNCATTR_SYS (strtoimax, intmax_t,
+_GL_FUNCDECL_SYS (strtoimax, intmax_t,
(const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
# endif
# undef strtoumax
# define strtoumax rpl_strtoumax
# endif
-_GL_FUNCATTR_RPL (strtoumax, uintmax_t,
+_GL_FUNCDECL_RPL (strtoumax, uintmax_t,
(const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoumax, uintmax_t,
# else
# if !@HAVE_DECL_STRTOUMAX@
# undef strtoumax
-_GL_FUNCATTR_SYS (strtoumax, uintmax_t,
+_GL_FUNCDECL_SYS (strtoumax, uintmax_t,
(const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
# endif
# undef nl_langinfo
# define nl_langinfo rpl_nl_langinfo
# endif
-_GL_FUNCDECL_RPL (nl_langinfo, char *, (nl_item item));
+_GL_FUNCDECL_RPL (nl_langinfo, char *, (nl_item item), );
_GL_CXXALIAS_RPL (nl_langinfo, char *, (nl_item item));
# else
# if !@HAVE_NL_LANGINFO@
-_GL_FUNCDECL_SYS (nl_langinfo, char *, (nl_item item));
+_GL_FUNCDECL_SYS (nl_langinfo, char *, (nl_item item), );
# endif
_GL_CXXALIAS_SYS (nl_langinfo, char *, (nl_item item));
# endif
# undef localeconv
# define localeconv rpl_localeconv
# endif
-_GL_FUNCDECL_RPL (localeconv, struct lconv *, (void));
+_GL_FUNCDECL_RPL (localeconv, struct lconv *, (void), );
_GL_CXXALIAS_RPL (localeconv, struct lconv *, (void));
# else
_GL_CXXALIAS_SYS (localeconv, struct lconv *, (void));
# define setlocale rpl_setlocale
# define GNULIB_defined_setlocale 1
# endif
-_GL_FUNCDECL_RPL (setlocale, char *, (int category, const char *locale));
+_GL_FUNCDECL_RPL (setlocale, char *, (int category, const char *locale), );
_GL_CXXALIAS_RPL (setlocale, char *, (int category, const char *locale));
# else
_GL_CXXALIAS_SYS (setlocale, char *, (int category, const char *locale));
# define newlocale rpl_newlocale
# define GNULIB_defined_newlocale 1
# endif
-_GL_FUNCATTR_RPL (newlocale, locale_t,
+_GL_FUNCDECL_RPL (newlocale, locale_t,
(int category_mask, const char *name, locale_t base),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (newlocale, locale_t,
# define duplocale rpl_duplocale
# define GNULIB_defined_duplocale 1
# endif
-_GL_FUNCATTR_RPL (duplocale, locale_t, (locale_t locale), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (duplocale, locale_t, (locale_t locale), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (duplocale, locale_t, (locale_t locale));
# else
_GL_CXXALIAS_SYS (duplocale, locale_t, (locale_t locale));
# define freelocale rpl_freelocale
# define GNULIB_defined_freelocale 1
# endif
-_GL_FUNCATTR_RPL (freelocale, void, (locale_t locale), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (freelocale, void, (locale_t locale), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (freelocale, void, (locale_t locale));
# else
# if @HAVE_FREELOCALE@
# undef memalign
# define memalign rpl_memalign
# endif
-_GL_FUNCATTR_RPL (memalign, void *,
+_GL_FUNCDECL_RPL (memalign, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate memalign with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (memalign, void *,
+_GL_FUNCDECL_SYS (memalign, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (memalign, void *,
+_GL_FUNCDECL_SYS (memalign, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if (__GNUC__ >= 11 && !defined __clang__) && !defined memalign
/* For -Wmismatched-dealloc: Associate memalign with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (memalign, void *,
+_GL_FUNCDECL_SYS (memalign, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (memalign, void *,
+_GL_FUNCDECL_SYS (memalign, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# undef acosf
# define acosf rpl_acosf
# endif
-_GL_FUNCDECL_RPL (acosf, float, (float x));
+_GL_FUNCDECL_RPL (acosf, float, (float x), );
_GL_CXXALIAS_RPL (acosf, float, (float x));
# else
# if !@HAVE_ACOSF@
# undef acosf
-_GL_FUNCDECL_SYS (acosf, float, (float x));
+_GL_FUNCDECL_SYS (acosf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (acosf, float, (float x));
# endif
#if @GNULIB_ACOSL@
# if !@HAVE_ACOSL@ || !@HAVE_DECL_ACOSL@
# undef acosl
-_GL_FUNCDECL_SYS (acosl, long double, (long double x));
+_GL_FUNCDECL_SYS (acosl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (acosl, long double, (long double x));
# if __GLIBC__ >= 2
# undef asinf
# define asinf rpl_asinf
# endif
-_GL_FUNCDECL_RPL (asinf, float, (float x));
+_GL_FUNCDECL_RPL (asinf, float, (float x), );
_GL_CXXALIAS_RPL (asinf, float, (float x));
# else
# if !@HAVE_ASINF@
# undef asinf
-_GL_FUNCDECL_SYS (asinf, float, (float x));
+_GL_FUNCDECL_SYS (asinf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (asinf, float, (float x));
# endif
#if @GNULIB_ASINL@
# if !@HAVE_ASINL@ || !@HAVE_DECL_ASINL@
# undef asinl
-_GL_FUNCDECL_SYS (asinl, long double, (long double x));
+_GL_FUNCDECL_SYS (asinl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (asinl, long double, (long double x));
# if __GLIBC__ >= 2
# undef atanf
# define atanf rpl_atanf
# endif
-_GL_FUNCDECL_RPL (atanf, float, (float x));
+_GL_FUNCDECL_RPL (atanf, float, (float x), );
_GL_CXXALIAS_RPL (atanf, float, (float x));
# else
# if !@HAVE_ATANF@
# undef atanf
-_GL_FUNCDECL_SYS (atanf, float, (float x));
+_GL_FUNCDECL_SYS (atanf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (atanf, float, (float x));
# endif
#if @GNULIB_ATANL@
# if !@HAVE_ATANL@ || !@HAVE_DECL_ATANL@
# undef atanl
-_GL_FUNCDECL_SYS (atanl, long double, (long double x));
+_GL_FUNCDECL_SYS (atanl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (atanl, long double, (long double x));
# if __GLIBC__ >= 2
# undef atan2f
# define atan2f rpl_atan2f
# endif
-_GL_FUNCDECL_RPL (atan2f, float, (float y, float x));
+_GL_FUNCDECL_RPL (atan2f, float, (float y, float x), );
_GL_CXXALIAS_RPL (atan2f, float, (float y, float x));
# else
# if !@HAVE_ATAN2F@
# undef atan2f
-_GL_FUNCDECL_SYS (atan2f, float, (float y, float x));
+_GL_FUNCDECL_SYS (atan2f, float, (float y, float x), );
# endif
_GL_CXXALIAS_SYS (atan2f, float, (float y, float x));
# endif
# undef cbrtf
# define cbrtf rpl_cbrtf
# endif
-_GL_FUNCDECL_RPL (cbrtf, float, (float x));
+_GL_FUNCDECL_RPL (cbrtf, float, (float x), );
_GL_CXXALIAS_RPL (cbrtf, float, (float x));
# else
# if !@HAVE_DECL_CBRTF@
-_GL_FUNCDECL_SYS (cbrtf, float, (float x));
+_GL_FUNCDECL_SYS (cbrtf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (cbrtf, float, (float x));
# endif
#if @GNULIB_CBRT@
# if !@HAVE_CBRT@
-_GL_FUNCDECL_SYS (cbrt, double, (double x));
+_GL_FUNCDECL_SYS (cbrt, double, (double x), );
# endif
_GL_CXXALIAS_SYS (cbrt, double, (double x));
# if __GLIBC__ >= 2
# undef cbrtl
# define cbrtl rpl_cbrtl
# endif
-_GL_FUNCDECL_RPL (cbrtl, long double, (long double x));
+_GL_FUNCDECL_RPL (cbrtl, long double, (long double x), );
_GL_CXXALIAS_RPL (cbrtl, long double, (long double x));
# else
# if !@HAVE_DECL_CBRTL@
-_GL_FUNCDECL_SYS (cbrtl, long double, (long double x));
+_GL_FUNCDECL_SYS (cbrtl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (cbrtl, long double, (long double x));
# endif
# undef ceilf
# define ceilf rpl_ceilf
# endif
-_GL_FUNCDECL_RPL (ceilf, float, (float x));
+_GL_FUNCDECL_RPL (ceilf, float, (float x), );
_GL_CXXALIAS_RPL (ceilf, float, (float x));
# else
# if !@HAVE_DECL_CEILF@
# undef ceilf
-_GL_FUNCDECL_SYS (ceilf, float, (float x));
+_GL_FUNCDECL_SYS (ceilf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (ceilf, float, (float x));
# endif
# undef ceil
# define ceil rpl_ceil
# endif
-_GL_FUNCDECL_RPL (ceil, double, (double x));
+_GL_FUNCDECL_RPL (ceil, double, (double x), );
_GL_CXXALIAS_RPL (ceil, double, (double x));
# else
_GL_CXXALIAS_SYS (ceil, double, (double x));
# undef ceill
# define ceill rpl_ceill
# endif
-_GL_FUNCDECL_RPL (ceill, long double, (long double x));
+_GL_FUNCDECL_RPL (ceill, long double, (long double x), );
_GL_CXXALIAS_RPL (ceill, long double, (long double x));
# else
# if !@HAVE_DECL_CEILL@
# undef ceill
-_GL_FUNCDECL_SYS (ceill, long double, (long double x));
+_GL_FUNCDECL_SYS (ceill, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (ceill, long double, (long double x));
# endif
#if @GNULIB_COPYSIGNF@
# if !@HAVE_DECL_COPYSIGNF@
# undef copysignf
-_GL_FUNCDECL_SYS (copysignf, float, (float x, float y));
+_GL_FUNCDECL_SYS (copysignf, float, (float x, float y), );
# endif
_GL_CXXALIAS_SYS (copysignf, float, (float x, float y));
_GL_CXXALIASWARN (copysignf);
#if @GNULIB_COPYSIGN@
# if !@HAVE_COPYSIGN@
-_GL_FUNCDECL_SYS (copysign, double, (double x, double y));
+_GL_FUNCDECL_SYS (copysign, double, (double x, double y), );
# endif
_GL_CXXALIAS_SYS (copysign, double, (double x, double y));
# if __GLIBC__ >= 2
#if @GNULIB_COPYSIGNL@
# if !@HAVE_COPYSIGNL@
-_GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y));
+_GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y), );
# endif
_GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y));
# if __GLIBC__ >= 2
# undef cosf
# define cosf rpl_cosf
# endif
-_GL_FUNCDECL_RPL (cosf, float, (float x));
+_GL_FUNCDECL_RPL (cosf, float, (float x), );
_GL_CXXALIAS_RPL (cosf, float, (float x));
# else
# if !@HAVE_COSF@
# undef cosf
-_GL_FUNCDECL_SYS (cosf, float, (float x));
+_GL_FUNCDECL_SYS (cosf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (cosf, float, (float x));
# endif
#if @GNULIB_COSL@
# if !@HAVE_COSL@ || !@HAVE_DECL_COSL@
# undef cosl
-_GL_FUNCDECL_SYS (cosl, long double, (long double x));
+_GL_FUNCDECL_SYS (cosl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (cosl, long double, (long double x));
# if __GLIBC__ >= 2
# undef coshf
# define coshf rpl_coshf
# endif
-_GL_FUNCDECL_RPL (coshf, float, (float x));
+_GL_FUNCDECL_RPL (coshf, float, (float x), );
_GL_CXXALIAS_RPL (coshf, float, (float x));
# else
# if !@HAVE_COSHF@
# undef coshf
-_GL_FUNCDECL_SYS (coshf, float, (float x));
+_GL_FUNCDECL_SYS (coshf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (coshf, float, (float x));
# endif
# undef expf
# define expf rpl_expf
# endif
-_GL_FUNCDECL_RPL (expf, float, (float x));
+_GL_FUNCDECL_RPL (expf, float, (float x), );
_GL_CXXALIAS_RPL (expf, float, (float x));
# else
# if !@HAVE_EXPF@
# undef expf
-_GL_FUNCDECL_SYS (expf, float, (float x));
+_GL_FUNCDECL_SYS (expf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (expf, float, (float x));
# endif
# undef expl
# define expl rpl_expl
# endif
-_GL_FUNCDECL_RPL (expl, long double, (long double x));
+_GL_FUNCDECL_RPL (expl, long double, (long double x), );
_GL_CXXALIAS_RPL (expl, long double, (long double x));
# else
# if !@HAVE_EXPL@ || !@HAVE_DECL_EXPL@
# undef expl
-_GL_FUNCDECL_SYS (expl, long double, (long double x));
+_GL_FUNCDECL_SYS (expl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (expl, long double, (long double x));
# endif
#if @GNULIB_EXP2F@
# if !@HAVE_DECL_EXP2F@
-_GL_FUNCDECL_SYS (exp2f, float, (float x));
+_GL_FUNCDECL_SYS (exp2f, float, (float x), );
# endif
_GL_CXXALIAS_SYS (exp2f, float, (float x));
_GL_CXXALIASWARN (exp2f);
# undef exp2
# define exp2 rpl_exp2
# endif
-_GL_FUNCDECL_RPL (exp2, double, (double x));
+_GL_FUNCDECL_RPL (exp2, double, (double x), );
_GL_CXXALIAS_RPL (exp2, double, (double x));
# else
# if !@HAVE_DECL_EXP2@
-_GL_FUNCDECL_SYS (exp2, double, (double x));
+_GL_FUNCDECL_SYS (exp2, double, (double x), );
# endif
_GL_CXXALIAS_SYS (exp2, double, (double x));
# endif
# undef exp2l
# define exp2l rpl_exp2l
# endif
-_GL_FUNCDECL_RPL (exp2l, long double, (long double x));
+_GL_FUNCDECL_RPL (exp2l, long double, (long double x), );
_GL_CXXALIAS_RPL (exp2l, long double, (long double x));
# else
# if !@HAVE_DECL_EXP2L@
# undef exp2l
-_GL_FUNCDECL_SYS (exp2l, long double, (long double x));
+_GL_FUNCDECL_SYS (exp2l, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (exp2l, long double, (long double x));
# endif
# undef expm1f
# define expm1f rpl_expm1f
# endif
-_GL_FUNCDECL_RPL (expm1f, float, (float x));
+_GL_FUNCDECL_RPL (expm1f, float, (float x), );
_GL_CXXALIAS_RPL (expm1f, float, (float x));
# else
# if !@HAVE_EXPM1F@
-_GL_FUNCDECL_SYS (expm1f, float, (float x));
+_GL_FUNCDECL_SYS (expm1f, float, (float x), );
# endif
_GL_CXXALIAS_SYS (expm1f, float, (float x));
# endif
# undef expm1
# define expm1 rpl_expm1
# endif
-_GL_FUNCDECL_RPL (expm1, double, (double x));
+_GL_FUNCDECL_RPL (expm1, double, (double x), );
_GL_CXXALIAS_RPL (expm1, double, (double x));
# else
# if !@HAVE_EXPM1@
-_GL_FUNCDECL_SYS (expm1, double, (double x));
+_GL_FUNCDECL_SYS (expm1, double, (double x), );
# endif
_GL_CXXALIAS_SYS (expm1, double, (double x));
# endif
# undef expm1l
# define expm1l rpl_expm1l
# endif
-_GL_FUNCDECL_RPL (expm1l, long double, (long double x));
+_GL_FUNCDECL_RPL (expm1l, long double, (long double x), );
_GL_CXXALIAS_RPL (expm1l, long double, (long double x));
# else
# if !@HAVE_DECL_EXPM1L@
# undef expm1l
# if !(defined __cplusplus && defined _AIX)
-_GL_FUNCDECL_SYS (expm1l, long double, (long double x));
+_GL_FUNCDECL_SYS (expm1l, long double, (long double x), );
# endif
# endif
_GL_CXXALIAS_SYS (expm1l, long double, (long double x));
#if @GNULIB_FABSF@
# if !@HAVE_FABSF@
# undef fabsf
-_GL_FUNCDECL_SYS (fabsf, float, (float x));
+_GL_FUNCDECL_SYS (fabsf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (fabsf, float, (float x));
# if __GLIBC__ >= 2
# undef fabsl
# define fabsl rpl_fabsl
# endif
-_GL_FUNCDECL_RPL (fabsl, long double, (long double x));
+_GL_FUNCDECL_RPL (fabsl, long double, (long double x), );
_GL_CXXALIAS_RPL (fabsl, long double, (long double x));
# else
# if !@HAVE_FABSL@
# undef fabsl
-_GL_FUNCDECL_SYS (fabsl, long double, (long double x));
+_GL_FUNCDECL_SYS (fabsl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (fabsl, long double, (long double x));
# endif
# undef floorf
# define floorf rpl_floorf
# endif
-_GL_FUNCDECL_RPL (floorf, float, (float x));
+_GL_FUNCDECL_RPL (floorf, float, (float x), );
_GL_CXXALIAS_RPL (floorf, float, (float x));
# else
# if !@HAVE_DECL_FLOORF@
# undef floorf
-_GL_FUNCDECL_SYS (floorf, float, (float x));
+_GL_FUNCDECL_SYS (floorf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (floorf, float, (float x));
# endif
# undef floor
# define floor rpl_floor
# endif
-_GL_FUNCDECL_RPL (floor, double, (double x));
+_GL_FUNCDECL_RPL (floor, double, (double x), );
_GL_CXXALIAS_RPL (floor, double, (double x));
# else
_GL_CXXALIAS_SYS (floor, double, (double x));
# undef floorl
# define floorl rpl_floorl
# endif
-_GL_FUNCDECL_RPL (floorl, long double, (long double x));
+_GL_FUNCDECL_RPL (floorl, long double, (long double x), );
_GL_CXXALIAS_RPL (floorl, long double, (long double x));
# else
# if !@HAVE_DECL_FLOORL@
# undef floorl
-_GL_FUNCDECL_SYS (floorl, long double, (long double x));
+_GL_FUNCDECL_SYS (floorl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (floorl, long double, (long double x));
# endif
# undef fmaf
# define fmaf rpl_fmaf
# endif
-_GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z));
+_GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z), );
_GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z));
# else
# if !@HAVE_FMAF@
# undef fmaf
-_GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z));
+_GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z), );
# endif
_GL_CXXALIAS_SYS (fmaf, float, (float x, float y, float z));
# endif
# undef fma
# define fma rpl_fma
# endif
-_GL_FUNCDECL_RPL (fma, double, (double x, double y, double z));
+_GL_FUNCDECL_RPL (fma, double, (double x, double y, double z), );
_GL_CXXALIAS_RPL (fma, double, (double x, double y, double z));
# else
# if !@HAVE_FMA@
# undef fma
-_GL_FUNCDECL_SYS (fma, double, (double x, double y, double z));
+_GL_FUNCDECL_SYS (fma, double, (double x, double y, double z), );
# endif
_GL_CXXALIAS_SYS (fma, double, (double x, double y, double z));
# endif
# define fmal rpl_fmal
# endif
_GL_FUNCDECL_RPL (fmal, long double,
- (long double x, long double y, long double z));
+ (long double x, long double y, long double z), );
_GL_CXXALIAS_RPL (fmal, long double,
(long double x, long double y, long double z));
# else
# undef fmal
# if !(defined __cplusplus && defined _AIX)
_GL_FUNCDECL_SYS (fmal, long double,
- (long double x, long double y, long double z));
+ (long double x, long double y, long double z), );
# endif
# endif
_GL_CXXALIAS_SYS (fmal, long double,
# undef fmodf
# define fmodf rpl_fmodf
# endif
-_GL_FUNCDECL_RPL (fmodf, float, (float x, float y));
+_GL_FUNCDECL_RPL (fmodf, float, (float x, float y), );
_GL_CXXALIAS_RPL (fmodf, float, (float x, float y));
# else
# if !@HAVE_FMODF@
# undef fmodf
-_GL_FUNCDECL_SYS (fmodf, float, (float x, float y));
+_GL_FUNCDECL_SYS (fmodf, float, (float x, float y), );
# endif
_GL_CXXALIAS_SYS (fmodf, float, (float x, float y));
# endif
# undef fmod
# define fmod rpl_fmod
# endif
-_GL_FUNCDECL_RPL (fmod, double, (double x, double y));
+_GL_FUNCDECL_RPL (fmod, double, (double x, double y), );
_GL_CXXALIAS_RPL (fmod, double, (double x, double y));
# else
_GL_CXXALIAS_SYS (fmod, double, (double x, double y));
# undef fmodl
# define fmodl rpl_fmodl
# endif
-_GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y));
+_GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y), );
_GL_CXXALIAS_RPL (fmodl, long double, (long double x, long double y));
# else
# if !@HAVE_FMODL@
# undef fmodl
-_GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y));
+_GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y), );
# endif
_GL_CXXALIAS_SYS (fmodl, long double, (long double x, long double y));
# endif
# undef frexpf
# define frexpf rpl_frexpf
# endif
-_GL_FUNCATTR_RPL (frexpf, float, (float x, int *expptr), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (frexpf, float, (float x, int *expptr), _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (frexpf, float, (float x, int *expptr));
# else
# if !@HAVE_FREXPF@
# undef frexpf
-_GL_FUNCATTR_SYS (frexpf, float, (float x, int *expptr), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_SYS (frexpf, float, (float x, int *expptr), _GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (frexpf, float, (float x, int *expptr));
# endif
# undef frexp
# define frexp rpl_frexp
# endif
-_GL_FUNCATTR_RPL (frexp, double, (double x, int *expptr),
+_GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr));
# else
# undef frexpl
# define frexpl rpl_frexpl
# endif
-_GL_FUNCATTR_RPL (frexpl, long double,
+_GL_FUNCDECL_RPL (frexpl, long double,
(long double x, int *expptr), _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (frexpl, long double, (long double x, int *expptr));
#else
# if !@HAVE_DECL_FREXPL@
-_GL_FUNCATTR_SYS (frexpl, long double,
+_GL_FUNCDECL_SYS (frexpl, long double,
(long double x, int *expptr), _GL_ARG_NONNULL ((2)));
# endif
# if @GNULIB_FREXPL@
# undef hypotf
# define hypotf rpl_hypotf
# endif
-_GL_FUNCDECL_RPL (hypotf, float, (float x, float y));
+_GL_FUNCDECL_RPL (hypotf, float, (float x, float y), );
_GL_CXXALIAS_RPL (hypotf, float, (float x, float y));
# else
# if !@HAVE_HYPOTF@
-_GL_FUNCDECL_SYS (hypotf, float, (float x, float y));
+_GL_FUNCDECL_SYS (hypotf, float, (float x, float y), );
# endif
_GL_CXXALIAS_SYS (hypotf, float, (float x, float y));
# endif
# undef hypot
# define hypot rpl_hypot
# endif
-_GL_FUNCDECL_RPL (hypot, double, (double x, double y));
+_GL_FUNCDECL_RPL (hypot, double, (double x, double y), );
_GL_CXXALIAS_RPL (hypot, double, (double x, double y));
# else
_GL_CXXALIAS_SYS (hypot, double, (double x, double y));
# undef hypotl
# define hypotl rpl_hypotl
# endif
-_GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y));
+_GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y), );
_GL_CXXALIAS_RPL (hypotl, long double, (long double x, long double y));
# else
# if !@HAVE_HYPOTL@
-_GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y));
+_GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y), );
# endif
_GL_CXXALIAS_SYS (hypotl, long double, (long double x, long double y));
# endif
# undef ilogbf
# define ilogbf rpl_ilogbf
# endif
-_GL_FUNCDECL_RPL (ilogbf, int, (float x));
+_GL_FUNCDECL_RPL (ilogbf, int, (float x), );
_GL_CXXALIAS_RPL (ilogbf, int, (float x));
# else
# if !@HAVE_ILOGBF@
-_GL_FUNCDECL_SYS (ilogbf, int, (float x));
+_GL_FUNCDECL_SYS (ilogbf, int, (float x), );
# endif
_GL_CXXALIAS_SYS (ilogbf, int, (float x));
# endif
# undef ilogb
# define ilogb rpl_ilogb
# endif
-_GL_FUNCDECL_RPL (ilogb, int, (double x));
+_GL_FUNCDECL_RPL (ilogb, int, (double x), );
_GL_CXXALIAS_RPL (ilogb, int, (double x));
# else
# if !@HAVE_ILOGB@
-_GL_FUNCDECL_SYS (ilogb, int, (double x));
+_GL_FUNCDECL_SYS (ilogb, int, (double x), );
# endif
_GL_CXXALIAS_SYS (ilogb, int, (double x));
# endif
# undef ilogbl
# define ilogbl rpl_ilogbl
# endif
-_GL_FUNCDECL_RPL (ilogbl, int, (long double x));
+_GL_FUNCDECL_RPL (ilogbl, int, (long double x), );
_GL_CXXALIAS_RPL (ilogbl, int, (long double x));
# else
# if !@HAVE_ILOGBL@
# undef ilogbl
-_GL_FUNCDECL_SYS (ilogbl, int, (long double x));
+_GL_FUNCDECL_SYS (ilogbl, int, (long double x), );
# endif
_GL_CXXALIAS_SYS (ilogbl, int, (long double x));
# endif
#if @GNULIB_LDEXPF@
# if !@HAVE_LDEXPF@
# undef ldexpf
-_GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp));
+_GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp), );
# endif
_GL_CXXALIAS_SYS (ldexpf, float, (float x, int exp));
# if __GLIBC__ >= 2
# undef ldexp
# define ldexp rpl_ldexp
# endif
-_GL_FUNCDECL_RPL (ldexp, double, (double x, int exp));
+_GL_FUNCDECL_RPL (ldexp, double, (double x, int exp), );
_GL_CXXALIAS_RPL (ldexp, double, (double x, int exp));
# else
/* Assume ldexp is always declared. */
# undef ldexpl
# define ldexpl rpl_ldexpl
# endif
-_GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp));
+_GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp), );
_GL_CXXALIAS_RPL (ldexpl, long double, (long double x, int exp));
#else
# if !@HAVE_DECL_LDEXPL@
-_GL_FUNCDECL_SYS (ldexpl, long double, (long double x, int exp));
+_GL_FUNCDECL_SYS (ldexpl, long double, (long double x, int exp), );
# endif
# if @GNULIB_LDEXPL@
_GL_CXXALIAS_SYS (ldexpl, long double, (long double x, int exp));
# undef logf
# define logf rpl_logf
# endif
-_GL_FUNCDECL_RPL (logf, float, (float x));
+_GL_FUNCDECL_RPL (logf, float, (float x), );
_GL_CXXALIAS_RPL (logf, float, (float x));
# else
# if !@HAVE_LOGF@
# undef logf
-_GL_FUNCDECL_SYS (logf, float, (float x));
+_GL_FUNCDECL_SYS (logf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (logf, float, (float x));
# endif
# undef log
# define log rpl_log
# endif
-_GL_FUNCDECL_RPL (log, double, (double x));
+_GL_FUNCDECL_RPL (log, double, (double x), );
_GL_CXXALIAS_RPL (log, double, (double x));
# else
_GL_CXXALIAS_SYS (log, double, (double x));
# undef logl
# define logl rpl_logl
# endif
-_GL_FUNCDECL_RPL (logl, long double, (long double x));
+_GL_FUNCDECL_RPL (logl, long double, (long double x), );
_GL_CXXALIAS_RPL (logl, long double, (long double x));
# else
# if !@HAVE_LOGL@ || !@HAVE_DECL_LOGL@
# undef logl
-_GL_FUNCDECL_SYS (logl, long double, (long double x));
+_GL_FUNCDECL_SYS (logl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (logl, long double, (long double x));
# endif
# undef log10f
# define log10f rpl_log10f
# endif
-_GL_FUNCDECL_RPL (log10f, float, (float x));
+_GL_FUNCDECL_RPL (log10f, float, (float x), );
_GL_CXXALIAS_RPL (log10f, float, (float x));
# else
# if !@HAVE_LOG10F@
# undef log10f
-_GL_FUNCDECL_SYS (log10f, float, (float x));
+_GL_FUNCDECL_SYS (log10f, float, (float x), );
# endif
_GL_CXXALIAS_SYS (log10f, float, (float x));
# endif
# undef log10
# define log10 rpl_log10
# endif
-_GL_FUNCDECL_RPL (log10, double, (double x));
+_GL_FUNCDECL_RPL (log10, double, (double x), );
_GL_CXXALIAS_RPL (log10, double, (double x));
# else
_GL_CXXALIAS_SYS (log10, double, (double x));
# undef log10l
# define log10l rpl_log10l
# endif
-_GL_FUNCDECL_RPL (log10l, long double, (long double x));
+_GL_FUNCDECL_RPL (log10l, long double, (long double x), );
_GL_CXXALIAS_RPL (log10l, long double, (long double x));
# else
# if !@HAVE_LOG10L@ || !@HAVE_DECL_LOG10L@
# undef log10l
-_GL_FUNCDECL_SYS (log10l, long double, (long double x));
+_GL_FUNCDECL_SYS (log10l, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (log10l, long double, (long double x));
# endif
# undef log1pf
# define log1pf rpl_log1pf
# endif
-_GL_FUNCDECL_RPL (log1pf, float, (float x));
+_GL_FUNCDECL_RPL (log1pf, float, (float x), );
_GL_CXXALIAS_RPL (log1pf, float, (float x));
# else
# if !@HAVE_LOG1PF@
-_GL_FUNCDECL_SYS (log1pf, float, (float x));
+_GL_FUNCDECL_SYS (log1pf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (log1pf, float, (float x));
# endif
# undef log1p
# define log1p rpl_log1p
# endif
-_GL_FUNCDECL_RPL (log1p, double, (double x));
+_GL_FUNCDECL_RPL (log1p, double, (double x), );
_GL_CXXALIAS_RPL (log1p, double, (double x));
# else
# if !@HAVE_LOG1P@
-_GL_FUNCDECL_SYS (log1p, double, (double x));
+_GL_FUNCDECL_SYS (log1p, double, (double x), );
# endif
_GL_CXXALIAS_SYS (log1p, double, (double x));
# endif
# undef log1pl
# define log1pl rpl_log1pl
# endif
-_GL_FUNCDECL_RPL (log1pl, long double, (long double x));
+_GL_FUNCDECL_RPL (log1pl, long double, (long double x), );
_GL_CXXALIAS_RPL (log1pl, long double, (long double x));
# else
# if !@HAVE_LOG1PL@
-_GL_FUNCDECL_SYS (log1pl, long double, (long double x));
+_GL_FUNCDECL_SYS (log1pl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (log1pl, long double, (long double x));
# endif
# undef log2f
# define log2f rpl_log2f
# endif
-_GL_FUNCDECL_RPL (log2f, float, (float x));
+_GL_FUNCDECL_RPL (log2f, float, (float x), );
_GL_CXXALIAS_RPL (log2f, float, (float x));
# else
# if !@HAVE_DECL_LOG2F@
# undef log2f
-_GL_FUNCDECL_SYS (log2f, float, (float x));
+_GL_FUNCDECL_SYS (log2f, float, (float x), );
# endif
_GL_CXXALIAS_SYS (log2f, float, (float x));
# endif
# undef log2
# define log2 rpl_log2
# endif
-_GL_FUNCDECL_RPL (log2, double, (double x));
+_GL_FUNCDECL_RPL (log2, double, (double x), );
_GL_CXXALIAS_RPL (log2, double, (double x));
# else
# if !@HAVE_DECL_LOG2@
# undef log2
-_GL_FUNCDECL_SYS (log2, double, (double x));
+_GL_FUNCDECL_SYS (log2, double, (double x), );
# endif
_GL_CXXALIAS_SYS (log2, double, (double x));
# endif
# undef log2l
# define log2l rpl_log2l
# endif
-_GL_FUNCDECL_RPL (log2l, long double, (long double x));
+_GL_FUNCDECL_RPL (log2l, long double, (long double x), );
_GL_CXXALIAS_RPL (log2l, long double, (long double x));
# else
# if !@HAVE_DECL_LOG2L@
-_GL_FUNCDECL_SYS (log2l, long double, (long double x));
+_GL_FUNCDECL_SYS (log2l, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (log2l, long double, (long double x));
# endif
# undef logbf
# define logbf rpl_logbf
# endif
-_GL_FUNCDECL_RPL (logbf, float, (float x));
+_GL_FUNCDECL_RPL (logbf, float, (float x), );
_GL_CXXALIAS_RPL (logbf, float, (float x));
# else
# if !@HAVE_LOGBF@
-_GL_FUNCDECL_SYS (logbf, float, (float x));
+_GL_FUNCDECL_SYS (logbf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (logbf, float, (float x));
# endif
# undef logb
# define logb rpl_logb
# endif
-_GL_FUNCDECL_RPL (logb, double, (double x));
+_GL_FUNCDECL_RPL (logb, double, (double x), );
_GL_CXXALIAS_RPL (logb, double, (double x));
# else
# if !@HAVE_DECL_LOGB@
-_GL_FUNCDECL_SYS (logb, double, (double x));
+_GL_FUNCDECL_SYS (logb, double, (double x), );
# endif
_GL_CXXALIAS_SYS (logb, double, (double x));
# endif
# undef logbl
# define logbl rpl_logbl
# endif
-_GL_FUNCDECL_RPL (logbl, long double, (long double x));
+_GL_FUNCDECL_RPL (logbl, long double, (long double x), );
_GL_CXXALIAS_RPL (logbl, long double, (long double x));
# else
# if !@HAVE_LOGBL@
-_GL_FUNCDECL_SYS (logbl, long double, (long double x));
+_GL_FUNCDECL_SYS (logbl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (logbl, long double, (long double x));
# endif
#if @GNULIB_LOGP1F@
# if !@HAVE_LOGP1F@
-_GL_FUNCDECL_SYS (logp1f, float, (float x));
+_GL_FUNCDECL_SYS (logp1f, float, (float x), );
# endif
_GL_CXXALIAS_SYS (logp1f, float, (float x));
# if __GLIBC__ >= 2
#if @GNULIB_LOGP1@
# if !@HAVE_LOGP1@
-_GL_FUNCDECL_SYS (logp1, double, (double x));
+_GL_FUNCDECL_SYS (logp1, double, (double x), );
# endif
_GL_CXXALIAS_SYS (logp1, double, (double x));
# if __GLIBC__ >= 2
#if @GNULIB_LOGP1L@
# if !@HAVE_LOGP1L@
-_GL_FUNCDECL_SYS (logp1l, long double, (long double x));
+_GL_FUNCDECL_SYS (logp1l, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (logp1l, long double, (long double x));
# if __GLIBC__ >= 2
# undef modff
# define modff rpl_modff
# endif
-_GL_FUNCATTR_RPL (modff, float, (float x, float *iptr), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (modff, float, (float x, float *iptr), _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (modff, float, (float x, float *iptr));
# else
# if !@HAVE_MODFF@
# undef modff
-_GL_FUNCATTR_SYS (modff, float, (float x, float *iptr), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_SYS (modff, float, (float x, float *iptr), _GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (modff, float, (float x, float *iptr));
# endif
# undef modf
# define modf rpl_modf
# endif
-_GL_FUNCATTR_RPL (modf, double, (double x, double *iptr),
+_GL_FUNCDECL_RPL (modf, double, (double x, double *iptr),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (modf, double, (double x, double *iptr));
# else
# undef modfl
# define modfl rpl_modfl
# endif
-_GL_FUNCATTR_RPL (modfl, long double, (long double x, long double *iptr),
+_GL_FUNCDECL_RPL (modfl, long double, (long double x, long double *iptr),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (modfl, long double, (long double x, long double *iptr));
# else
# if !@HAVE_MODFL@
# undef modfl
-_GL_FUNCATTR_SYS (modfl, long double, (long double x, long double *iptr),
+_GL_FUNCDECL_SYS (modfl, long double, (long double x, long double *iptr),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (modfl, long double, (long double x, long double *iptr));
#if @GNULIB_POWF@
# if !@HAVE_POWF@
# undef powf
-_GL_FUNCDECL_SYS (powf, float, (float x, float y));
+_GL_FUNCDECL_SYS (powf, float, (float x, float y), );
# endif
_GL_CXXALIAS_SYS (powf, float, (float x, float y));
_GL_CXXALIASWARN (powf);
# undef remainderf
# define remainderf rpl_remainderf
# endif
-_GL_FUNCDECL_RPL (remainderf, float, (float x, float y));
+_GL_FUNCDECL_RPL (remainderf, float, (float x, float y), );
_GL_CXXALIAS_RPL (remainderf, float, (float x, float y));
# else
# if !@HAVE_REMAINDERF@
-_GL_FUNCDECL_SYS (remainderf, float, (float x, float y));
+_GL_FUNCDECL_SYS (remainderf, float, (float x, float y), );
# endif
_GL_CXXALIAS_SYS (remainderf, float, (float x, float y));
# endif
# undef remainder
# define remainder rpl_remainder
# endif
-_GL_FUNCDECL_RPL (remainder, double, (double x, double y));
+_GL_FUNCDECL_RPL (remainder, double, (double x, double y), );
_GL_CXXALIAS_RPL (remainder, double, (double x, double y));
# else
# if !@HAVE_REMAINDER@ || !@HAVE_DECL_REMAINDER@
-_GL_FUNCDECL_SYS (remainder, double, (double x, double y));
+_GL_FUNCDECL_SYS (remainder, double, (double x, double y), );
# endif
_GL_CXXALIAS_SYS (remainder, double, (double x, double y));
# endif
# undef remainderl
# define remainderl rpl_remainderl
# endif
-_GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y));
+_GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y), );
_GL_CXXALIAS_RPL (remainderl, long double, (long double x, long double y));
# else
# if !@HAVE_DECL_REMAINDERL@
# undef remainderl
# if !(defined __cplusplus && defined _AIX)
-_GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y));
+_GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y), );
# endif
# endif
_GL_CXXALIAS_SYS (remainderl, long double, (long double x, long double y));
#if @GNULIB_RINTF@
# if !@HAVE_DECL_RINTF@
-_GL_FUNCDECL_SYS (rintf, float, (float x));
+_GL_FUNCDECL_SYS (rintf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (rintf, float, (float x));
_GL_CXXALIASWARN (rintf);
#if @GNULIB_RINT@
# if !@HAVE_RINT@
-_GL_FUNCDECL_SYS (rint, double, (double x));
+_GL_FUNCDECL_SYS (rint, double, (double x), );
# endif
_GL_CXXALIAS_SYS (rint, double, (double x));
# if __GLIBC__ >= 2
# undef rintl
# define rintl rpl_rintl
# endif
-_GL_FUNCDECL_RPL (rintl, long double, (long double x));
+_GL_FUNCDECL_RPL (rintl, long double, (long double x), );
_GL_CXXALIAS_RPL (rintl, long double, (long double x));
# else
# if !@HAVE_RINTL@
-_GL_FUNCDECL_SYS (rintl, long double, (long double x));
+_GL_FUNCDECL_SYS (rintl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (rintl, long double, (long double x));
# endif
# undef roundf
# define roundf rpl_roundf
# endif
-_GL_FUNCDECL_RPL (roundf, float, (float x));
+_GL_FUNCDECL_RPL (roundf, float, (float x), );
_GL_CXXALIAS_RPL (roundf, float, (float x));
# else
# if !@HAVE_DECL_ROUNDF@
-_GL_FUNCDECL_SYS (roundf, float, (float x));
+_GL_FUNCDECL_SYS (roundf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (roundf, float, (float x));
# endif
# undef round
# define round rpl_round
# endif
-_GL_FUNCDECL_RPL (round, double, (double x));
+_GL_FUNCDECL_RPL (round, double, (double x), );
_GL_CXXALIAS_RPL (round, double, (double x));
# else
# if !@HAVE_DECL_ROUND@
-_GL_FUNCDECL_SYS (round, double, (double x));
+_GL_FUNCDECL_SYS (round, double, (double x), );
# endif
_GL_CXXALIAS_SYS (round, double, (double x));
# endif
# undef roundl
# define roundl rpl_roundl
# endif
-_GL_FUNCDECL_RPL (roundl, long double, (long double x));
+_GL_FUNCDECL_RPL (roundl, long double, (long double x), );
_GL_CXXALIAS_RPL (roundl, long double, (long double x));
# else
# if !@HAVE_DECL_ROUNDL@
# undef roundl
# if !(defined __cplusplus && defined _AIX)
-_GL_FUNCDECL_SYS (roundl, long double, (long double x));
+_GL_FUNCDECL_SYS (roundl, long double, (long double x), );
# endif
# endif
_GL_CXXALIAS_SYS (roundl, long double, (long double x));
# undef sinf
# define sinf rpl_sinf
# endif
-_GL_FUNCDECL_RPL (sinf, float, (float x));
+_GL_FUNCDECL_RPL (sinf, float, (float x), );
_GL_CXXALIAS_RPL (sinf, float, (float x));
# else
# if !@HAVE_SINF@
# undef sinf
-_GL_FUNCDECL_SYS (sinf, float, (float x));
+_GL_FUNCDECL_SYS (sinf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (sinf, float, (float x));
# endif
#if @GNULIB_SINL@
# if !@HAVE_SINL@ || !@HAVE_DECL_SINL@
# undef sinl
-_GL_FUNCDECL_SYS (sinl, long double, (long double x));
+_GL_FUNCDECL_SYS (sinl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (sinl, long double, (long double x));
# if __GLIBC__ >= 2
# undef sinhf
# define sinhf rpl_sinhf
# endif
-_GL_FUNCDECL_RPL (sinhf, float, (float x));
+_GL_FUNCDECL_RPL (sinhf, float, (float x), );
_GL_CXXALIAS_RPL (sinhf, float, (float x));
# else
# if !@HAVE_SINHF@
# undef sinhf
-_GL_FUNCDECL_SYS (sinhf, float, (float x));
+_GL_FUNCDECL_SYS (sinhf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (sinhf, float, (float x));
# endif
# undef sqrtf
# define sqrtf rpl_sqrtf
# endif
-_GL_FUNCDECL_RPL (sqrtf, float, (float x));
+_GL_FUNCDECL_RPL (sqrtf, float, (float x), );
_GL_CXXALIAS_RPL (sqrtf, float, (float x));
# else
# if !@HAVE_SQRTF@
# undef sqrtf
-_GL_FUNCDECL_SYS (sqrtf, float, (float x));
+_GL_FUNCDECL_SYS (sqrtf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (sqrtf, float, (float x));
# endif
# undef sqrtl
# define sqrtl rpl_sqrtl
# endif
-_GL_FUNCDECL_RPL (sqrtl, long double, (long double x));
+_GL_FUNCDECL_RPL (sqrtl, long double, (long double x), );
_GL_CXXALIAS_RPL (sqrtl, long double, (long double x));
# else
# if !@HAVE_SQRTL@ || !@HAVE_DECL_SQRTL@
# undef sqrtl
-_GL_FUNCDECL_SYS (sqrtl, long double, (long double x));
+_GL_FUNCDECL_SYS (sqrtl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (sqrtl, long double, (long double x));
# endif
# undef tanf
# define tanf rpl_tanf
# endif
-_GL_FUNCDECL_RPL (tanf, float, (float x));
+_GL_FUNCDECL_RPL (tanf, float, (float x), );
_GL_CXXALIAS_RPL (tanf, float, (float x));
# else
# if !@HAVE_TANF@
# undef tanf
-_GL_FUNCDECL_SYS (tanf, float, (float x));
+_GL_FUNCDECL_SYS (tanf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (tanf, float, (float x));
# endif
#if @GNULIB_TANL@
# if !@HAVE_TANL@ || !@HAVE_DECL_TANL@
# undef tanl
-_GL_FUNCDECL_SYS (tanl, long double, (long double x));
+_GL_FUNCDECL_SYS (tanl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (tanl, long double, (long double x));
# if __GLIBC__ >= 2
# undef tanhf
# define tanhf rpl_tanhf
# endif
-_GL_FUNCDECL_RPL (tanhf, float, (float x));
+_GL_FUNCDECL_RPL (tanhf, float, (float x), );
_GL_CXXALIAS_RPL (tanhf, float, (float x));
# else
# if !@HAVE_TANHF@
# undef tanhf
-_GL_FUNCDECL_SYS (tanhf, float, (float x));
+_GL_FUNCDECL_SYS (tanhf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (tanhf, float, (float x));
# endif
# undef truncf
# define truncf rpl_truncf
# endif
-_GL_FUNCDECL_RPL (truncf, float, (float x));
+_GL_FUNCDECL_RPL (truncf, float, (float x), );
_GL_CXXALIAS_RPL (truncf, float, (float x));
# else
# if !@HAVE_DECL_TRUNCF@
-_GL_FUNCDECL_SYS (truncf, float, (float x));
+_GL_FUNCDECL_SYS (truncf, float, (float x), );
# endif
_GL_CXXALIAS_SYS (truncf, float, (float x));
# endif
# undef trunc
# define trunc rpl_trunc
# endif
-_GL_FUNCDECL_RPL (trunc, double, (double x));
+_GL_FUNCDECL_RPL (trunc, double, (double x), );
_GL_CXXALIAS_RPL (trunc, double, (double x));
# else
# if !@HAVE_DECL_TRUNC@
-_GL_FUNCDECL_SYS (trunc, double, (double x));
+_GL_FUNCDECL_SYS (trunc, double, (double x), );
# endif
_GL_CXXALIAS_SYS (trunc, double, (double x));
# endif
# undef truncl
# define truncl rpl_truncl
# endif
-_GL_FUNCDECL_RPL (truncl, long double, (long double x));
+_GL_FUNCDECL_RPL (truncl, long double, (long double x), );
_GL_CXXALIAS_RPL (truncl, long double, (long double x));
# else
# if !@HAVE_DECL_TRUNCL@
-_GL_FUNCDECL_SYS (truncl, long double, (long double x));
+_GL_FUNCDECL_SYS (truncl, long double, (long double x), );
# endif
_GL_CXXALIAS_SYS (truncl, long double, (long double x));
# endif
# undef getpayloadf
# define getpayloadf rpl_getpayloadf
# endif
-_GL_FUNCDECL_RPL (getpayloadf, float, (const float *));
+_GL_FUNCDECL_RPL (getpayloadf, float, (const float *), );
_GL_CXXALIAS_RPL (getpayloadf, float, (const float *));
# else
# if !@HAVE_GETPAYLOADF@
-_GL_FUNCDECL_SYS (getpayloadf, float, (const float *));
+_GL_FUNCDECL_SYS (getpayloadf, float, (const float *), );
# endif
_GL_CXXALIAS_SYS (getpayloadf, float, (const float *));
# endif
# undef getpayload
# define getpayload rpl_getpayload
# endif
-_GL_FUNCDECL_RPL (getpayload, double, (const double *));
+_GL_FUNCDECL_RPL (getpayload, double, (const double *), );
_GL_CXXALIAS_RPL (getpayload, double, (const double *));
# else
# if !@HAVE_GETPAYLOAD@
-_GL_FUNCDECL_SYS (getpayload, double, (const double *));
+_GL_FUNCDECL_SYS (getpayload, double, (const double *), );
# endif
_GL_CXXALIAS_SYS (getpayload, double, (const double *));
# endif
# undef getpayloadl
# define getpayloadl rpl_getpayloadl
# endif
-_GL_FUNCDECL_RPL (getpayloadl, long double, (const long double *));
+_GL_FUNCDECL_RPL (getpayloadl, long double, (const long double *), );
_GL_CXXALIAS_RPL (getpayloadl, long double, (const long double *));
# else
# if !@HAVE_GETPAYLOADL@
-_GL_FUNCDECL_SYS (getpayloadl, long double, (const long double *));
+_GL_FUNCDECL_SYS (getpayloadl, long double, (const long double *), );
# endif
_GL_CXXALIAS_SYS (getpayloadl, long double, (const long double *));
# endif
#if @GNULIB_SETPAYLOADF@
# if !@HAVE_SETPAYLOADF@
-_GL_FUNCDECL_SYS (setpayloadf, int, (float *, float));
+_GL_FUNCDECL_SYS (setpayloadf, int, (float *, float), );
# endif
_GL_CXXALIAS_SYS (setpayloadf, int, (float *, float));
_GL_CXXALIASWARN (setpayloadf);
#if @GNULIB_SETPAYLOAD@
# if !@HAVE_SETPAYLOAD@
-_GL_FUNCDECL_SYS (setpayload, int, (double *, double));
+_GL_FUNCDECL_SYS (setpayload, int, (double *, double), );
# endif
_GL_CXXALIAS_SYS (setpayload, int, (double *, double));
_GL_CXXALIASWARN (setpayload);
#if @GNULIB_SETPAYLOADL@
# if !@HAVE_SETPAYLOADL@
-_GL_FUNCDECL_SYS (setpayloadl, int, (long double *, long double));
+_GL_FUNCDECL_SYS (setpayloadl, int, (long double *, long double), );
# endif
_GL_CXXALIAS_SYS (setpayloadl, int, (long double *, long double));
_GL_CXXALIASWARN (setpayloadl);
#if @GNULIB_SETPAYLOADSIGF@
# if !@HAVE_SETPAYLOADSIGF@
-_GL_FUNCDECL_SYS (setpayloadsigf, int, (float *, float));
+_GL_FUNCDECL_SYS (setpayloadsigf, int, (float *, float), );
# endif
_GL_CXXALIAS_SYS (setpayloadsigf, int, (float *, float));
_GL_CXXALIASWARN (setpayloadsigf);
#if @GNULIB_SETPAYLOADSIG@
# if !@HAVE_SETPAYLOADSIG@
-_GL_FUNCDECL_SYS (setpayloadsig, int, (double *, double));
+_GL_FUNCDECL_SYS (setpayloadsig, int, (double *, double), );
# endif
_GL_CXXALIAS_SYS (setpayloadsig, int, (double *, double));
_GL_CXXALIASWARN (setpayloadsig);
#if @GNULIB_SETPAYLOADSIGL@
# if !@HAVE_SETPAYLOADSIGL@
-_GL_FUNCDECL_SYS (setpayloadsigl, int, (long double *, long double));
+_GL_FUNCDECL_SYS (setpayloadsigl, int, (long double *, long double), );
# endif
_GL_CXXALIAS_SYS (setpayloadsigl, int, (long double *, long double));
_GL_CXXALIASWARN (setpayloadsigl);
# undef totalorderf
# define totalorderf rpl_totalorderf
# endif
-_GL_FUNCDECL_RPL (totalorderf, int, (float const *, float const *));
+_GL_FUNCDECL_RPL (totalorderf, int, (float const *, float const *), );
_GL_CXXALIAS_RPL (totalorderf, int, (float const *, float const *));
# else
# if !@HAVE_TOTALORDERF@
-_GL_FUNCDECL_SYS (totalorderf, int, (float const *, float const *));
+_GL_FUNCDECL_SYS (totalorderf, int, (float const *, float const *), );
# endif
_GL_CXXALIAS_SYS (totalorderf, int, (float const *, float const *));
# endif
# undef totalorder
# define totalorder rpl_totalorder
# endif
-_GL_FUNCDECL_RPL (totalorder, int, (double const *, double const *));
+_GL_FUNCDECL_RPL (totalorder, int, (double const *, double const *), );
_GL_CXXALIAS_RPL (totalorder, int, (double const *, double const *));
# else
# if !@HAVE_TOTALORDER@
-_GL_FUNCDECL_SYS (totalorder, int, (double const *, double const *));
+_GL_FUNCDECL_SYS (totalorder, int, (double const *, double const *), );
# endif
_GL_CXXALIAS_SYS (totalorder, int, (double const *, double const *));
# endif
# define totalorderl rpl_totalorderl
# endif
_GL_FUNCDECL_RPL (totalorderl, int,
- (long double const *, long double const *));
+ (long double const *, long double const *), );
_GL_CXXALIAS_RPL (totalorderl, int,
(long double const *, long double const *));
# else
# if !@HAVE_TOTALORDERL@
_GL_FUNCDECL_SYS (totalorderl, int,
- (long double const *, long double const *));
+ (long double const *, long double const *), );
# endif
_GL_CXXALIAS_SYS (totalorderl, int,
(long double const *, long double const *));
# undef totalordermagf
# define totalordermagf rpl_totalordermagf
# endif
-_GL_FUNCDECL_RPL (totalordermagf, int, (float const *, float const *));
+_GL_FUNCDECL_RPL (totalordermagf, int, (float const *, float const *), );
_GL_CXXALIAS_RPL (totalordermagf, int, (float const *, float const *));
# else
# if !@HAVE_TOTALORDERMAGF@
-_GL_FUNCDECL_SYS (totalordermagf, int, (float const *, float const *));
+_GL_FUNCDECL_SYS (totalordermagf, int, (float const *, float const *), );
# endif
_GL_CXXALIAS_SYS (totalordermagf, int, (float const *, float const *));
# endif
# undef totalordermag
# define totalordermag rpl_totalordermag
# endif
-_GL_FUNCDECL_RPL (totalordermag, int, (double const *, double const *));
+_GL_FUNCDECL_RPL (totalordermag, int, (double const *, double const *), );
_GL_CXXALIAS_RPL (totalordermag, int, (double const *, double const *));
# else
# if !@HAVE_TOTALORDERMAG@
-_GL_FUNCDECL_SYS (totalordermag, int, (double const *, double const *));
+_GL_FUNCDECL_SYS (totalordermag, int, (double const *, double const *), );
# endif
_GL_CXXALIAS_SYS (totalordermag, int, (double const *, double const *));
# endif
# define totalordermagl rpl_totalordermagl
# endif
_GL_FUNCDECL_RPL (totalordermagl, int,
- (long double const *, long double const *));
+ (long double const *, long double const *), );
_GL_CXXALIAS_RPL (totalordermagl, int,
(long double const *, long double const *));
# else
# if !@HAVE_TOTALORDERMAGL@
_GL_FUNCDECL_SYS (totalordermagl, int,
- (long double const *, long double const *));
+ (long double const *, long double const *), );
# endif
_GL_CXXALIAS_SYS (totalordermagl, int,
(long double const *, long double const *));
# undef hasmntopt
# define hasmntopt rpl_hasmntopt
# endif
-_GL_FUNCATTR_RPL (hasmntopt, char *,
+_GL_FUNCDECL_RPL (hasmntopt, char *,
(const struct mntent *me, const char *option),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (hasmntopt, char *,
(const struct mntent *me, const char *option));
# else
# if !@HAVE_HASMNTOPT@
-_GL_FUNCATTR_SYS (hasmntopt, char *,
+_GL_FUNCDECL_SYS (hasmntopt, char *,
(const struct mntent *me, const char *option),
_GL_ARG_NONNULL ((1, 2)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strfmon_l rpl_strfmon_l
# endif
-_GL_FUNCATTR_RPL (strfmon_l, ssize_t,
+_GL_FUNCDECL_RPL (strfmon_l, ssize_t,
(char *restrict s, size_t maxsize, locale_t locale,
const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_STRFMON (4, 5)
# undef getaddrinfo
# define getaddrinfo rpl_getaddrinfo
# endif
-_GL_FUNCATTR_RPL (getaddrinfo, int,
+_GL_FUNCDECL_RPL (getaddrinfo, int,
(const char *restrict nodename,
const char *restrict servname,
const struct addrinfo *restrict hints,
struct addrinfo **restrict res));
# else
# if !@HAVE_DECL_GETADDRINFO@
-_GL_FUNCATTR_SYS (getaddrinfo, int,
+_GL_FUNCDECL_SYS (getaddrinfo, int,
(const char *restrict nodename,
const char *restrict servname,
const struct addrinfo *restrict hints,
# undef freeaddrinfo
# define freeaddrinfo rpl_freeaddrinfo
# endif
-_GL_FUNCATTR_RPL (freeaddrinfo, void, (struct addrinfo *ai),
+_GL_FUNCDECL_RPL (freeaddrinfo, void, (struct addrinfo *ai),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (freeaddrinfo, void, (struct addrinfo *ai));
# else
# if !@HAVE_DECL_FREEADDRINFO@
-_GL_FUNCATTR_SYS (freeaddrinfo, void, (struct addrinfo *ai),
+_GL_FUNCDECL_SYS (freeaddrinfo, void, (struct addrinfo *ai),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (freeaddrinfo, void, (struct addrinfo *ai));
# undef gai_strerror
# define gai_strerror rpl_gai_strerror
# endif
-_GL_FUNCDECL_RPL (gai_strerror, const char *, (int ecode));
+_GL_FUNCDECL_RPL (gai_strerror, const char *, (int ecode), );
_GL_CXXALIAS_RPL (gai_strerror, const char *, (int ecode));
# else
# if !@HAVE_DECL_GAI_STRERROR@
/* Convert error return from getaddrinfo() to a string.
For more details, see the POSIX:2008 specification
<https://pubs.opengroup.org/onlinepubs/9699919799/functions/gai_strerror.html>. */
-_GL_FUNCDECL_SYS (gai_strerror, const char *, (int ecode));
+_GL_FUNCDECL_SYS (gai_strerror, const char *, (int ecode), );
# endif
_GL_CXXALIAS_SYS (gai_strerror, const char *, (int ecode));
# endif
/* Convert socket address to printable node and service names.
For more details, see the POSIX:2008 specification
<https://pubs.opengroup.org/onlinepubs/9699919799/functions/getnameinfo.html>. */
-_GL_FUNCATTR_SYS (getnameinfo, int,
+_GL_FUNCDECL_SYS (getnameinfo, int,
(const struct sockaddr *restrict sa, socklen_t salen,
char *restrict node, socklen_t nodelen,
char *restrict service, socklen_t servicelen,
# undef poll
# define poll rpl_poll
# endif
-_GL_FUNCDECL_RPL (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout));
+_GL_FUNCDECL_RPL (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout), );
_GL_CXXALIAS_RPL (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout));
# else
# if !@HAVE_POLL@
-_GL_FUNCDECL_SYS (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout));
+_GL_FUNCDECL_SYS (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout), );
# endif
_GL_CXXALIAS_SYS (poll, int, (struct pollfd *pfd, nfds_t nfd, int timeout));
# endif
# undef pthread_create
# define pthread_create rpl_pthread_create
# endif
-_GL_FUNCATTR_RPL (pthread_create, int,
+_GL_FUNCDECL_RPL (pthread_create, int,
(pthread_t *restrict threadp,
const pthread_attr_t *restrict attr,
void * (*mainfunc) (void *), void *restrict arg),
void * (*mainfunc) (void *), void *restrict arg));
# else
# if !@HAVE_PTHREAD_CREATE@
-_GL_FUNCATTR_SYS (pthread_create, int,
+_GL_FUNCDECL_SYS (pthread_create, int,
(pthread_t *restrict threadp,
const pthread_attr_t *restrict attr,
void * (*mainfunc) (void *), void *restrict arg),
# undef pthread_attr_init
# define pthread_attr_init rpl_pthread_attr_init
# endif
-_GL_FUNCATTR_RPL (pthread_attr_init, int, (pthread_attr_t *attr),
+_GL_FUNCDECL_RPL (pthread_attr_init, int, (pthread_attr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_attr_init, int, (pthread_attr_t *attr));
# else
# if !@HAVE_PTHREAD_ATTR_INIT@
-_GL_FUNCATTR_SYS (pthread_attr_init, int, (pthread_attr_t *attr),
+_GL_FUNCDECL_SYS (pthread_attr_init, int, (pthread_attr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_attr_init, int, (pthread_attr_t *attr));
# undef pthread_attr_getdetachstate
# define pthread_attr_getdetachstate rpl_pthread_attr_getdetachstate
# endif
-_GL_FUNCATTR_RPL (pthread_attr_getdetachstate, int,
+_GL_FUNCDECL_RPL (pthread_attr_getdetachstate, int,
(const pthread_attr_t *attr, int *detachstatep),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_attr_getdetachstate, int,
(const pthread_attr_t *attr, int *detachstatep));
# else
# if !@HAVE_PTHREAD_ATTR_GETDETACHSTATE@
-_GL_FUNCATTR_SYS (pthread_attr_getdetachstate, int,
+_GL_FUNCDECL_SYS (pthread_attr_getdetachstate, int,
(const pthread_attr_t *attr, int *detachstatep),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef pthread_attr_setdetachstate
# define pthread_attr_setdetachstate rpl_pthread_attr_setdetachstate
# endif
-_GL_FUNCATTR_RPL (pthread_attr_setdetachstate, int,
+_GL_FUNCDECL_RPL (pthread_attr_setdetachstate, int,
(pthread_attr_t *attr, int detachstate),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_attr_setdetachstate, int,
(pthread_attr_t *attr, int detachstate));
# else
# if !@HAVE_PTHREAD_ATTR_SETDETACHSTATE@
-_GL_FUNCATTR_SYS (pthread_attr_setdetachstate, int,
+_GL_FUNCDECL_SYS (pthread_attr_setdetachstate, int,
(pthread_attr_t *attr, int detachstate),
_GL_ARG_NONNULL ((1)));
# endif
# undef pthread_attr_destroy
# define pthread_attr_destroy rpl_pthread_attr_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr),
+_GL_FUNCDECL_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr));
# else
# if !@HAVE_PTHREAD_ATTR_DESTROY@
-_GL_FUNCATTR_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr),
+_GL_FUNCDECL_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr));
# undef pthread_self
# define pthread_self rpl_pthread_self
# endif
-_GL_FUNCATTR_RPL (pthread_self, pthread_t, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (pthread_self, pthread_t, (void), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (pthread_self, pthread_t, (void));
# else
# if !@HAVE_PTHREAD_SELF@
-_GL_FUNCATTR_SYS (pthread_self, pthread_t, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (pthread_self, pthread_t, (void), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (pthread_self, pthread_t, (void));
# endif
# undef pthread_equal
# define pthread_equal rpl_pthread_equal
# endif
-_GL_FUNCDECL_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
+_GL_FUNCDECL_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2), );
_GL_CXXALIAS_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
# else
# if !@HAVE_PTHREAD_EQUAL@
-_GL_FUNCDECL_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
+_GL_FUNCDECL_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2), );
# endif
_GL_CXXALIAS_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
# endif
# undef pthread_detach
# define pthread_detach rpl_pthread_detach
# endif
-_GL_FUNCDECL_RPL (pthread_detach, int, (pthread_t thread));
+_GL_FUNCDECL_RPL (pthread_detach, int, (pthread_t thread), );
_GL_CXXALIAS_RPL (pthread_detach, int, (pthread_t thread));
# else
# if !@HAVE_PTHREAD_DETACH@
-_GL_FUNCDECL_SYS (pthread_detach, int, (pthread_t thread));
+_GL_FUNCDECL_SYS (pthread_detach, int, (pthread_t thread), );
# endif
_GL_CXXALIAS_SYS (pthread_detach, int, (pthread_t thread));
# endif
# undef pthread_join
# define pthread_join rpl_pthread_join
# endif
-_GL_FUNCDECL_RPL (pthread_join, int, (pthread_t thread, void **valuep));
+_GL_FUNCDECL_RPL (pthread_join, int, (pthread_t thread, void **valuep), );
_GL_CXXALIAS_RPL (pthread_join, int, (pthread_t thread, void **valuep));
# else
# if !@HAVE_PTHREAD_JOIN@
-_GL_FUNCDECL_SYS (pthread_join, int, (pthread_t thread, void **valuep));
+_GL_FUNCDECL_SYS (pthread_join, int, (pthread_t thread, void **valuep), );
# endif
_GL_CXXALIAS_SYS (pthread_join, int, (pthread_t thread, void **valuep));
# endif
# undef pthread_exit
# define pthread_exit rpl_pthread_exit
# endif
-_GL_FUNCDECL_RPL (pthread_exit, _Noreturn void, (void *value));
+_GL_FUNCDECL_RPL (pthread_exit, _Noreturn void, (void *value), );
_GL_CXXALIAS_RPL (pthread_exit, void, (void *value));
# else
# if !@HAVE_PTHREAD_EXIT@
-_GL_FUNCDECL_SYS (pthread_exit, _Noreturn void, (void *value));
+_GL_FUNCDECL_SYS (pthread_exit, _Noreturn void, (void *value), );
# endif
/* Need to cast because of AIX with xlclang++. */
_GL_CXXALIAS_SYS_CAST (pthread_exit, void, (void *value));
# undef pthread_once
# define pthread_once rpl_pthread_once
# endif
-_GL_FUNCATTR_RPL (pthread_once, int,
+_GL_FUNCDECL_RPL (pthread_once, int,
(pthread_once_t *once_control, void (*initfunction) (void)),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_once, int,
(pthread_once_t *once_control, void (*initfunction) (void)));
# else
# if !@HAVE_PTHREAD_ONCE@
-_GL_FUNCATTR_SYS (pthread_once, int,
+_GL_FUNCDECL_SYS (pthread_once, int,
(pthread_once_t *once_control, void (*initfunction) (void)),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef pthread_mutex_init
# define pthread_mutex_init rpl_pthread_mutex_init
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_init, int,
+_GL_FUNCDECL_RPL (pthread_mutex_init, int,
(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
const pthread_mutexattr_t *restrict attr));
# else
# if !@HAVE_PTHREAD_MUTEX_INIT@
-_GL_FUNCATTR_SYS (pthread_mutex_init, int,
+_GL_FUNCDECL_SYS (pthread_mutex_init, int,
(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# undef pthread_mutexattr_init
# define pthread_mutexattr_init rpl_pthread_mutexattr_init
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr),
+_GL_FUNCDECL_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_INIT@
-_GL_FUNCATTR_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr),
+_GL_FUNCDECL_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
# undef pthread_mutexattr_gettype
# define pthread_mutexattr_gettype rpl_pthread_mutexattr_gettype
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_gettype, int,
+_GL_FUNCDECL_RPL (pthread_mutexattr_gettype, int,
(const pthread_mutexattr_t *restrict attr,
int *restrict typep),
_GL_ARG_NONNULL ((1, 2)));
int *restrict typep));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_GETTYPE@
-_GL_FUNCATTR_SYS (pthread_mutexattr_gettype, int,
+_GL_FUNCDECL_SYS (pthread_mutexattr_gettype, int,
(const pthread_mutexattr_t *restrict attr,
int *restrict typep),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_mutexattr_settype
# define pthread_mutexattr_settype rpl_pthread_mutexattr_settype
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_settype, int,
+_GL_FUNCDECL_RPL (pthread_mutexattr_settype, int,
(pthread_mutexattr_t *attr, int type), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutexattr_settype, int,
(pthread_mutexattr_t *attr, int type));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_SETTYPE@
-_GL_FUNCATTR_SYS (pthread_mutexattr_settype, int,
+_GL_FUNCDECL_SYS (pthread_mutexattr_settype, int,
(pthread_mutexattr_t *attr, int type), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutexattr_settype, int,
# undef pthread_mutexattr_getrobust
# define pthread_mutexattr_getrobust rpl_pthread_mutexattr_getrobust
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_getrobust, int,
+_GL_FUNCDECL_RPL (pthread_mutexattr_getrobust, int,
(const pthread_mutexattr_t *restrict attr,
int *restrict robustp),
_GL_ARG_NONNULL ((1, 2)));
int *restrict robustp));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_GETROBUST@
-_GL_FUNCATTR_SYS (pthread_mutexattr_getrobust, int,
+_GL_FUNCDECL_SYS (pthread_mutexattr_getrobust, int,
(const pthread_mutexattr_t *restrict attr,
int *restrict robustp),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_mutexattr_setrobust
# define pthread_mutexattr_setrobust rpl_pthread_mutexattr_setrobust
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_setrobust, int,
+_GL_FUNCDECL_RPL (pthread_mutexattr_setrobust, int,
(pthread_mutexattr_t *attr, int robust),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutexattr_setrobust, int,
(pthread_mutexattr_t *attr, int robust));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_SETROBUST@
-_GL_FUNCATTR_SYS (pthread_mutexattr_setrobust, int,
+_GL_FUNCDECL_SYS (pthread_mutexattr_setrobust, int,
(pthread_mutexattr_t *attr, int robust),
_GL_ARG_NONNULL ((1)));
# endif
# undef pthread_mutexattr_destroy
# define pthread_mutexattr_destroy rpl_pthread_mutexattr_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr),
+_GL_FUNCDECL_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
# else
# if !@HAVE_PTHREAD_MUTEXATTR_DESTROY@
-_GL_FUNCATTR_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr),
+_GL_FUNCDECL_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
# undef pthread_mutex_lock
# define pthread_mutex_lock rpl_pthread_mutex_lock
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
# else
# if !@HAVE_PTHREAD_MUTEX_LOCK@
-_GL_FUNCATTR_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
# undef pthread_mutex_trylock
# define pthread_mutex_trylock rpl_pthread_mutex_trylock
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
# else
# if !@HAVE_PTHREAD_MUTEX_TRYLOCK@
-_GL_FUNCATTR_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
# undef pthread_mutex_timedlock
# define pthread_mutex_timedlock rpl_pthread_mutex_timedlock
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_timedlock, int,
+_GL_FUNCDECL_RPL (pthread_mutex_timedlock, int,
(pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
const struct timespec *restrict abstime));
# else
# if !@HAVE_PTHREAD_MUTEX_TIMEDLOCK@
-_GL_FUNCATTR_SYS (pthread_mutex_timedlock, int,
+_GL_FUNCDECL_SYS (pthread_mutex_timedlock, int,
(pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_mutex_unlock
# define pthread_mutex_unlock rpl_pthread_mutex_unlock
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
# else
# if !@HAVE_PTHREAD_MUTEX_UNLOCK@
-_GL_FUNCATTR_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
# undef pthread_mutex_destroy
# define pthread_mutex_destroy rpl_pthread_mutex_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
# else
# if !@HAVE_PTHREAD_MUTEX_DESTROY@
-_GL_FUNCATTR_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex),
+_GL_FUNCDECL_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
# undef pthread_rwlock_init
# define pthread_rwlock_init rpl_pthread_rwlock_init
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_init, int,
+_GL_FUNCDECL_RPL (pthread_rwlock_init, int,
(pthread_rwlock_t *restrict lock,
const pthread_rwlockattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
const pthread_rwlockattr_t *restrict attr));
# else
# if !@HAVE_PTHREAD_RWLOCK_INIT@
-_GL_FUNCATTR_SYS (pthread_rwlock_init, int,
+_GL_FUNCDECL_SYS (pthread_rwlock_init, int,
(pthread_rwlock_t *restrict lock,
const pthread_rwlockattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# undef pthread_rwlockattr_init
# define pthread_rwlockattr_init rpl_pthread_rwlockattr_init
# endif
-_GL_FUNCATTR_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr),
+_GL_FUNCDECL_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
# else
# if !@HAVE_PTHREAD_RWLOCKATTR_INIT@
-_GL_FUNCATTR_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr),
+_GL_FUNCDECL_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
# undef pthread_rwlockattr_destroy
# define pthread_rwlockattr_destroy rpl_pthread_rwlockattr_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_rwlockattr_destroy, int,
+_GL_FUNCDECL_RPL (pthread_rwlockattr_destroy, int,
(pthread_rwlockattr_t *attr), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlockattr_destroy, int,
(pthread_rwlockattr_t *attr));
# else
# if !@HAVE_PTHREAD_RWLOCKATTR_DESTROY@
-_GL_FUNCATTR_SYS (pthread_rwlockattr_destroy, int,
+_GL_FUNCDECL_SYS (pthread_rwlockattr_destroy, int,
(pthread_rwlockattr_t *attr), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlockattr_destroy, int,
# undef pthread_rwlock_rdlock
# define pthread_rwlock_rdlock rpl_pthread_rwlock_rdlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_RDLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
# undef pthread_rwlock_wrlock
# define pthread_rwlock_wrlock rpl_pthread_rwlock_wrlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_WRLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
# undef pthread_rwlock_tryrdlock
# define pthread_rwlock_tryrdlock rpl_pthread_rwlock_tryrdlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_TRYRDLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
# undef pthread_rwlock_trywrlock
# define pthread_rwlock_trywrlock rpl_pthread_rwlock_trywrlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_TRYWRLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
# undef pthread_rwlock_timedrdlock
# define pthread_rwlock_timedrdlock rpl_pthread_rwlock_timedrdlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_timedrdlock, int,
+_GL_FUNCDECL_RPL (pthread_rwlock_timedrdlock, int,
(pthread_rwlock_t *restrict lock,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
const struct timespec *restrict abstime));
# else
# if !@HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_timedrdlock, int,
+_GL_FUNCDECL_SYS (pthread_rwlock_timedrdlock, int,
(pthread_rwlock_t *restrict lock,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_rwlock_timedwrlock
# define pthread_rwlock_timedwrlock rpl_pthread_rwlock_timedwrlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_timedwrlock, int,
+_GL_FUNCDECL_RPL (pthread_rwlock_timedwrlock, int,
(pthread_rwlock_t *restrict lock,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
const struct timespec *restrict abstime));
# else
# if !@HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_timedwrlock, int,
+_GL_FUNCDECL_SYS (pthread_rwlock_timedwrlock, int,
(pthread_rwlock_t *restrict lock,
const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_rwlock_unlock
# define pthread_rwlock_unlock rpl_pthread_rwlock_unlock
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_UNLOCK@
-_GL_FUNCATTR_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
# undef pthread_rwlock_destroy
# define pthread_rwlock_destroy rpl_pthread_rwlock_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
# else
# if !@HAVE_PTHREAD_RWLOCK_DESTROY@
-_GL_FUNCATTR_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
# undef pthread_cond_init
# define pthread_cond_init rpl_pthread_cond_init
# endif
-_GL_FUNCATTR_RPL (pthread_cond_init, int,
+_GL_FUNCDECL_RPL (pthread_cond_init, int,
(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
const pthread_condattr_t *restrict attr));
# else
# if !@HAVE_PTHREAD_COND_INIT@
-_GL_FUNCATTR_SYS (pthread_cond_init, int,
+_GL_FUNCDECL_SYS (pthread_cond_init, int,
(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# undef pthread_condattr_init
# define pthread_condattr_init rpl_pthread_condattr_init
# endif
-_GL_FUNCATTR_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr),
+_GL_FUNCDECL_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr));
# else
# if !@HAVE_PTHREAD_CONDATTR_INIT@
-_GL_FUNCATTR_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr),
+_GL_FUNCDECL_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr));
# undef pthread_condattr_destroy
# define pthread_condattr_destroy rpl_pthread_condattr_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr),
+_GL_FUNCDECL_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
# else
# if !@HAVE_PTHREAD_CONDATTR_DESTROY@
-_GL_FUNCATTR_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr),
+_GL_FUNCDECL_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
# undef pthread_cond_wait
# define pthread_cond_wait rpl_pthread_cond_wait
# endif
-_GL_FUNCATTR_RPL (pthread_cond_wait, int,
+_GL_FUNCDECL_RPL (pthread_cond_wait, int,
(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex),
_GL_ARG_NONNULL ((1, 2)));
pthread_mutex_t *restrict mutex));
# else
# if !@HAVE_PTHREAD_COND_WAIT@
-_GL_FUNCATTR_SYS (pthread_cond_wait, int,
+_GL_FUNCDECL_SYS (pthread_cond_wait, int,
(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex),
_GL_ARG_NONNULL ((1, 2)));
# undef pthread_cond_timedwait
# define pthread_cond_timedwait rpl_pthread_cond_timedwait
# endif
-_GL_FUNCATTR_RPL (pthread_cond_timedwait, int,
+_GL_FUNCDECL_RPL (pthread_cond_timedwait, int,
(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime),
const struct timespec *restrict abstime));
# else
# if !@HAVE_PTHREAD_COND_TIMEDWAIT@
-_GL_FUNCATTR_SYS (pthread_cond_timedwait, int,
+_GL_FUNCDECL_SYS (pthread_cond_timedwait, int,
(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime),
# undef pthread_cond_signal
# define pthread_cond_signal rpl_pthread_cond_signal
# endif
-_GL_FUNCATTR_RPL (pthread_cond_signal, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_RPL (pthread_cond_signal, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_cond_signal, int, (pthread_cond_t *cond));
# else
# if !@HAVE_PTHREAD_COND_SIGNAL@
-_GL_FUNCATTR_SYS (pthread_cond_signal, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_SYS (pthread_cond_signal, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_signal, int, (pthread_cond_t *cond));
# undef pthread_cond_broadcast
# define pthread_cond_broadcast rpl_pthread_cond_broadcast
# endif
-_GL_FUNCATTR_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond));
# else
# if !@HAVE_PTHREAD_COND_BROADCAST@
-_GL_FUNCATTR_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond));
# undef pthread_cond_destroy
# define pthread_cond_destroy rpl_pthread_cond_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond));
# else
# if !@HAVE_PTHREAD_COND_DESTROY@
-_GL_FUNCATTR_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond),
+_GL_FUNCDECL_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond));
# undef pthread_key_create
# define pthread_key_create rpl_pthread_key_create
# endif
-_GL_FUNCATTR_RPL (pthread_key_create, int,
+_GL_FUNCDECL_RPL (pthread_key_create, int,
(pthread_key_t *keyp, void (*destructor) (void *)),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_key_create, int,
(pthread_key_t *keyp, void (*destructor) (void *)));
# else
# if !@HAVE_PTHREAD_KEY_CREATE@
-_GL_FUNCATTR_SYS (pthread_key_create, int,
+_GL_FUNCDECL_SYS (pthread_key_create, int,
(pthread_key_t *keyp, void (*destructor) (void *)),
_GL_ARG_NONNULL ((1)));
# endif
# define pthread_setspecific rpl_pthread_setspecific
# endif
_GL_FUNCDECL_RPL (pthread_setspecific, int,
- (pthread_key_t key, const void *value));
+ (pthread_key_t key, const void *value), );
_GL_CXXALIAS_RPL (pthread_setspecific, int,
(pthread_key_t key, const void *value));
# else
# if !@HAVE_PTHREAD_SETSPECIFIC@
_GL_FUNCDECL_SYS (pthread_setspecific, int,
- (pthread_key_t key, const void *value));
+ (pthread_key_t key, const void *value), );
# endif
_GL_CXXALIAS_SYS (pthread_setspecific, int,
(pthread_key_t key, const void *value));
# undef pthread_getspecific
# define pthread_getspecific rpl_pthread_getspecific
# endif
-_GL_FUNCDECL_RPL (pthread_getspecific, void *, (pthread_key_t key));
+_GL_FUNCDECL_RPL (pthread_getspecific, void *, (pthread_key_t key), );
_GL_CXXALIAS_RPL (pthread_getspecific, void *, (pthread_key_t key));
# else
# if !@HAVE_PTHREAD_GETSPECIFIC@
-_GL_FUNCDECL_SYS (pthread_getspecific, void *, (pthread_key_t key));
+_GL_FUNCDECL_SYS (pthread_getspecific, void *, (pthread_key_t key), );
# endif
_GL_CXXALIAS_SYS (pthread_getspecific, void *, (pthread_key_t key));
# endif
# undef pthread_key_delete
# define pthread_key_delete rpl_pthread_key_delete
# endif
-_GL_FUNCDECL_RPL (pthread_key_delete, int, (pthread_key_t key));
+_GL_FUNCDECL_RPL (pthread_key_delete, int, (pthread_key_t key), );
_GL_CXXALIAS_RPL (pthread_key_delete, int, (pthread_key_t key));
# else
# if !@HAVE_PTHREAD_KEY_DELETE@
-_GL_FUNCDECL_SYS (pthread_key_delete, int, (pthread_key_t key));
+_GL_FUNCDECL_SYS (pthread_key_delete, int, (pthread_key_t key), );
# endif
_GL_CXXALIAS_SYS (pthread_key_delete, int, (pthread_key_t key));
# endif
# undef pthread_spin_init
# define pthread_spin_init rpl_pthread_spin_init
# endif
-_GL_FUNCATTR_RPL (pthread_spin_init, int,
+_GL_FUNCDECL_RPL (pthread_spin_init, int,
(pthread_spinlock_t *lock, int shared_across_processes),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_spin_init, int,
(pthread_spinlock_t *lock, int shared_across_processes));
# else
# if !@HAVE_PTHREAD_SPIN_INIT@
-_GL_FUNCATTR_SYS (pthread_spin_init, int,
+_GL_FUNCDECL_SYS (pthread_spin_init, int,
(pthread_spinlock_t *lock, int shared_across_processes),
_GL_ARG_NONNULL ((1)));
# endif
# undef pthread_spin_lock
# define pthread_spin_lock rpl_pthread_spin_lock
# endif
-_GL_FUNCATTR_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock));
# else
# if !@HAVE_PTHREAD_SPIN_LOCK@
-_GL_FUNCATTR_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock));
# undef pthread_spin_trylock
# define pthread_spin_trylock rpl_pthread_spin_trylock
# endif
-_GL_FUNCATTR_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
# else
# if !@HAVE_PTHREAD_SPIN_TRYLOCK@
-_GL_FUNCATTR_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
# undef pthread_spin_unlock
# define pthread_spin_unlock rpl_pthread_spin_unlock
# endif
-_GL_FUNCATTR_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
# else
# if !@HAVE_PTHREAD_SPIN_UNLOCK@
-_GL_FUNCATTR_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
# undef pthread_spin_destroy
# define pthread_spin_destroy rpl_pthread_spin_destroy
# endif
-_GL_FUNCATTR_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
# else
# if !@HAVE_PTHREAD_SPIN_DESTROY@
-_GL_FUNCATTR_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock),
+_GL_FUNCDECL_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
# endif
_GL_FUNCDECL_RPL (forkpty, int,
(int *amaster, char *name,
- struct termios const *termp, struct winsize const *winp));
+ struct termios const *termp, struct winsize const *winp), );
_GL_CXXALIAS_RPL (forkpty, int,
(int *amaster, char *name,
struct termios const *termp, struct winsize const *winp));
# if !@HAVE_FORKPTY@
_GL_FUNCDECL_SYS (forkpty, int,
(int *amaster, char *name,
- struct termios const *termp, struct winsize const *winp));
+ struct termios const *termp, struct winsize const *winp), );
# endif
_GL_CXXALIAS_SYS (forkpty, int,
(int *amaster, char *name,
# endif
_GL_FUNCDECL_RPL (openpty, int,
(int *amaster, int *aslave, char *name,
- struct termios const *termp, struct winsize const *winp));
+ struct termios const *termp, struct winsize const *winp), );
_GL_CXXALIAS_RPL (openpty, int,
(int *amaster, int *aslave, char *name,
struct termios const *termp, struct winsize const *winp));
# if !@HAVE_OPENPTY@
_GL_FUNCDECL_SYS (openpty, int,
(int *amaster, int *aslave, char *name,
- struct termios const *termp, struct winsize const *winp));
+ struct termios const *termp, struct winsize const *winp), );
# endif
_GL_CXXALIAS_SYS (openpty, int,
(int *amaster, int *aslave, char *name,
# undef sched_yield
# define sched_yield rpl_sched_yield
# endif
-_GL_FUNCDECL_RPL (sched_yield, int, (void));
+_GL_FUNCDECL_RPL (sched_yield, int, (void), );
_GL_CXXALIAS_RPL (sched_yield, int, (void));
# else
# if !@HAVE_SCHED_YIELD@
-_GL_FUNCDECL_SYS (sched_yield, int, (void));
+_GL_FUNCDECL_SYS (sched_yield, int, (void), );
# endif
_GL_CXXALIAS_SYS (sched_yield, int, (void));
# endif
If one is found, it is returned. Otherwise, a new element equal to KEY
is inserted in the tree and is returned. */
# if @REPLACE_TSEARCH@
-_GL_FUNCATTR_RPL (tsearch, void *,
+_GL_FUNCDECL_RPL (tsearch, void *,
(const void *key, void **vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_gl_search_compar_fn compar));
# else
# if !@HAVE_TSEARCH@
-_GL_FUNCATTR_SYS (tsearch, void *,
+_GL_FUNCDECL_SYS (tsearch, void *,
(const void *key, void **vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
/* Searches an element in the tree *VROOTP that compares equal to KEY.
If one is found, it is returned. Otherwise, NULL is returned. */
# if @REPLACE_TSEARCH@
-_GL_FUNCATTR_RPL (tfind, void *,
+_GL_FUNCDECL_RPL (tfind, void *,
(const void *key, void *const *vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_gl_search_compar_fn compar));
# else
# if !@HAVE_TSEARCH@
-_GL_FUNCATTR_SYS (tfind, void *,
+_GL_FUNCDECL_SYS (tfind, void *,
(const void *key, void *const *vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
If one is found, it is removed from the tree, and its parent node is
returned. Otherwise, NULL is returned. */
# if @REPLACE_TSEARCH@
-_GL_FUNCATTR_RPL (tdelete, void *,
+_GL_FUNCDECL_RPL (tdelete, void *,
(const void *restrict key, void **restrict vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_gl_search_compar_fn compar));
# else
# if !@HAVE_TSEARCH@
-_GL_FUNCATTR_SYS (tdelete, void *,
+_GL_FUNCDECL_SYS (tdelete, void *,
(const void *restrict key, void **restrict vrootp,
_gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
2. an indicator which visit of the node this is,
3. the level of the node in the tree (0 for the root). */
# if @REPLACE_TWALK@
-_GL_FUNCATTR_RPL (twalk, void,
+_GL_FUNCDECL_RPL (twalk, void,
(const void *vroot, _gl_search_action_fn action),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (twalk, void,
(const void *vroot, _gl_search_action_fn action));
# else
# if !@HAVE_TWALK@
-_GL_FUNCATTR_SYS (twalk, void,
+_GL_FUNCDECL_SYS (twalk, void,
(const void *vroot, _gl_search_action_fn action),
_GL_ARG_NONNULL ((2)));
# endif
#if @GNULIB_SIG2STR@
# if !@HAVE_SIG2STR@
-_GL_FUNCDECL_SYS (sig2str, int, (int signo, char *str));
+_GL_FUNCDECL_SYS (sig2str, int, (int signo, char *str), );
# endif
_GL_CXXALIAS_SYS (sig2str, int, (int signo, char *str));
# if __GLIBC__ >= 2
#if @GNULIB_SIG2STR@
# if !@HAVE_STR2SIG@
-_GL_FUNCDECL_SYS (str2sig, int, (char const *str, int *signo_p));
+_GL_FUNCDECL_SYS (str2sig, int, (char const *str, int *signo_p), );
# endif
_GL_CXXALIAS_SYS (str2sig, int, (char const *str, int *signo_p));
# if __GLIBC__ >= 2
_GL_FUNCDECL_RPL (pthread_sigmask, int,
(int how,
const sigset_t *restrict new_mask,
- sigset_t *restrict old_mask));
+ sigset_t *restrict old_mask), );
_GL_CXXALIAS_RPL (pthread_sigmask, int,
(int how,
const sigset_t *restrict new_mask,
_GL_FUNCDECL_SYS (pthread_sigmask, int,
(int how,
const sigset_t *restrict new_mask,
- sigset_t *restrict old_mask));
+ sigset_t *restrict old_mask), );
# endif
_GL_CXXALIAS_SYS (pthread_sigmask, int,
(int how,
# undef raise
# define raise rpl_raise
# endif
-_GL_FUNCDECL_RPL (raise, int, (int sig));
+_GL_FUNCDECL_RPL (raise, int, (int sig), );
_GL_CXXALIAS_RPL (raise, int, (int sig));
# else
# if !@HAVE_RAISE@
-_GL_FUNCDECL_SYS (raise, int, (int sig));
+_GL_FUNCDECL_SYS (raise, int, (int sig), );
# endif
_GL_CXXALIAS_SYS (raise, int, (int sig));
# endif
# undef sigismember
# endif
# else
-_GL_FUNCATTR_SYS (sigismember, int, (const sigset_t *set, int sig),
+_GL_FUNCDECL_SYS (sigismember, int, (const sigset_t *set, int sig),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigismember, int, (const sigset_t *set, int sig));
# undef sigemptyset
# endif
# else
-_GL_FUNCATTR_SYS (sigemptyset, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (sigemptyset, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigemptyset, int, (sigset_t *set));
_GL_CXXALIASWARN (sigemptyset);
# undef sigaddset
# endif
# else
-_GL_FUNCATTR_SYS (sigaddset, int, (sigset_t *set, int sig),
+_GL_FUNCDECL_SYS (sigaddset, int, (sigset_t *set, int sig),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigaddset, int, (sigset_t *set, int sig));
# undef sigdelset
# endif
# else
-_GL_FUNCATTR_SYS (sigdelset, int, (sigset_t *set, int sig),
+_GL_FUNCDECL_SYS (sigdelset, int, (sigset_t *set, int sig),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigdelset, int, (sigset_t *set, int sig));
# undef sigfillset
# endif
# else
-_GL_FUNCATTR_SYS (sigfillset, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (sigfillset, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigfillset, int, (sigset_t *set));
_GL_CXXALIASWARN (sigfillset);
/* Return the set of those blocked signals that are pending. */
# if !@HAVE_POSIX_SIGNALBLOCKING@
-_GL_FUNCATTR_SYS (sigpending, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (sigpending, int, (sigset_t *set), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (sigpending, int, (sigset_t *set));
_GL_CXXALIASWARN (sigpending);
_GL_FUNCDECL_SYS (sigprocmask, int,
(int operation,
const sigset_t *restrict set,
- sigset_t *restrict old_set));
+ sigset_t *restrict old_set), );
# endif
_GL_CXXALIAS_SYS (sigprocmask, int,
(int operation,
# define signal rpl_signal
# endif
_GL_FUNCDECL_RPL (signal, _gl_function_taking_int_returning_void_t,
- (int sig, _gl_function_taking_int_returning_void_t func));
+ (int sig, _gl_function_taking_int_returning_void_t func), );
_GL_CXXALIAS_RPL (signal, _gl_function_taking_int_returning_void_t,
(int sig, _gl_function_taking_int_returning_void_t func));
# else
because it occurs in <sys/signal.h>, not <signal.h> directly. */
# if defined __OpenBSD__
_GL_FUNCDECL_SYS (signal, _gl_function_taking_int_returning_void_t,
- (int sig, _gl_function_taking_int_returning_void_t func));
+ (int sig, _gl_function_taking_int_returning_void_t func), );
# endif
_GL_CXXALIAS_SYS (signal, _gl_function_taking_int_returning_void_t,
(int sig, _gl_function_taking_int_returning_void_t func));
# endif
_GL_FUNCDECL_SYS (sigaction, int, (int, const struct sigaction *restrict,
- struct sigaction *restrict));
+ struct sigaction *restrict), );
# elif !@HAVE_STRUCT_SIGACTION_SA_SIGACTION@
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn rpl_posix_spawn
# endif
-_GL_FUNCATTR_RPL (posix_spawn, int,
+_GL_FUNCDECL_RPL (posix_spawn, int,
(pid_t *_Restrict_ __pid,
const char *_Restrict_ __path,
const posix_spawn_file_actions_t *_Restrict_ __file_actions,
char *const envp[_Restrict_arr_]));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn, int,
+_GL_FUNCDECL_SYS (posix_spawn, int,
(pid_t *_Restrict_ __pid,
const char *_Restrict_ __path,
const posix_spawn_file_actions_t *_Restrict_ __file_actions,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnp rpl_posix_spawnp
# endif
-_GL_FUNCATTR_RPL (posix_spawnp, int,
+_GL_FUNCDECL_RPL (posix_spawnp, int,
(pid_t *__pid, const char *__file,
const posix_spawn_file_actions_t *__file_actions,
const posix_spawnattr_t *__attrp,
char *const argv[], char *const envp[]));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnp, int,
+_GL_FUNCDECL_SYS (posix_spawnp, int,
(pid_t *__pid, const char *__file,
const posix_spawn_file_actions_t *__file_actions,
const posix_spawnattr_t *__attrp,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_init rpl_posix_spawnattr_init
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr),
+_GL_FUNCDECL_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr),
+_GL_FUNCDECL_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_destroy rpl_posix_spawnattr_destroy
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr),
+_GL_FUNCDECL_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr),
+_GL_FUNCDECL_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getsigdefault rpl_posix_spawnattr_getsigdefault
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getsigdefault, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigdefault),
_GL_ARG_NONNULL ((1, 2))) __THROW;
sigset_t *_Restrict_ __sigdefault));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_getsigdefault, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigdefault),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setsigdefault rpl_posix_spawnattr_setsigdefault
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setsigdefault, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigdefault),
_GL_ARG_NONNULL ((1, 2))) __THROW;
const sigset_t *_Restrict_ __sigdefault));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_setsigdefault, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigdefault),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getsigmask rpl_posix_spawnattr_getsigmask
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getsigmask, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigmask),
_GL_ARG_NONNULL ((1, 2))) __THROW;
sigset_t *_Restrict_ __sigmask));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_getsigmask, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigmask),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setsigmask rpl_posix_spawnattr_setsigmask
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setsigmask, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigmask),
_GL_ARG_NONNULL ((1, 2))) __THROW;
const sigset_t *_Restrict_ __sigmask));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_setsigmask, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigmask),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getflags rpl_posix_spawnattr_getflags
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getflags, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
short int *_Restrict_ __flags),
_GL_ARG_NONNULL ((1, 2))) __THROW;
short int *_Restrict_ __flags));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_getflags, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
short int *_Restrict_ __flags),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setflags rpl_posix_spawnattr_setflags
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setflags, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setflags, int,
(posix_spawnattr_t *__attr, short int __flags),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setflags, int,
(posix_spawnattr_t *__attr, short int __flags));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_setflags, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setflags, int,
(posix_spawnattr_t *__attr, short int __flags),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getpgroup rpl_posix_spawnattr_getpgroup
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getpgroup, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
pid_t *_Restrict_ __pgroup),
_GL_ARG_NONNULL ((1, 2))) __THROW;
pid_t *_Restrict_ __pgroup));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_getpgroup, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
pid_t *_Restrict_ __pgroup),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setpgroup rpl_posix_spawnattr_setpgroup
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setpgroup, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setpgroup, int,
(posix_spawnattr_t *__attr, pid_t __pgroup),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setpgroup, int,
(posix_spawnattr_t *__attr, pid_t __pgroup));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawnattr_setpgroup, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setpgroup, int,
(posix_spawnattr_t *__attr, pid_t __pgroup),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getschedpolicy rpl_posix_spawnattr_getschedpolicy
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getschedpolicy, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
int *_Restrict_ __schedpolicy),
_GL_ARG_NONNULL ((1, 2))) __THROW;
int *_Restrict_ __schedpolicy));
# else
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDULER == 0
-_GL_FUNCATTR_SYS (posix_spawnattr_getschedpolicy, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
int *_Restrict_ __schedpolicy),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setschedpolicy rpl_posix_spawnattr_setschedpolicy
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setschedpolicy, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setschedpolicy, int,
(posix_spawnattr_t *__attr, int __schedpolicy),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setschedpolicy, int,
(posix_spawnattr_t *__attr, int __schedpolicy));
# else
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDULER == 0
-_GL_FUNCATTR_SYS (posix_spawnattr_setschedpolicy, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setschedpolicy, int,
(posix_spawnattr_t *__attr, int __schedpolicy),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_getschedparam rpl_posix_spawnattr_getschedparam
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_getschedparam, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
struct sched_param *_Restrict_ __schedparam),
_GL_ARG_NONNULL ((1, 2))) __THROW;
struct sched_param *_Restrict_ __schedparam));
# else
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0
-_GL_FUNCATTR_SYS (posix_spawnattr_getschedparam, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
struct sched_param *_Restrict_ __schedparam),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_setschedparam rpl_posix_spawnattr_setschedparam
# endif
-_GL_FUNCATTR_RPL (posix_spawnattr_setschedparam, int,
+_GL_FUNCDECL_RPL (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
const struct sched_param *_Restrict_ __schedparam),
_GL_ARG_NONNULL ((1, 2))) __THROW;
const struct sched_param *_Restrict_ __schedparam));
# else
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0
-_GL_FUNCATTR_SYS (posix_spawnattr_setschedparam, int,
+_GL_FUNCDECL_SYS (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
const struct sched_param *_Restrict_ __schedparam),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_init rpl_posix_spawn_file_actions_init
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_init, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_init, int,
(posix_spawn_file_actions_t *__file_actions),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_init, int,
(posix_spawn_file_actions_t *__file_actions));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_init, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_init, int,
(posix_spawn_file_actions_t *__file_actions),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_destroy rpl_posix_spawn_file_actions_destroy
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_destroy, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_destroy, int,
(posix_spawn_file_actions_t *__file_actions),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_destroy, int,
(posix_spawn_file_actions_t *__file_actions));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_destroy, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_destroy, int,
(posix_spawn_file_actions_t *__file_actions),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_addopen rpl_posix_spawn_file_actions_addopen
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_addopen, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_addopen, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd,
const char *_Restrict_ __path, int __oflag, mode_t __mode),
const char *_Restrict_ __path, int __oflag, mode_t __mode));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_addopen, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_addopen, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd,
const char *_Restrict_ __path, int __oflag, mode_t __mode),
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_addclose rpl_posix_spawn_file_actions_addclose
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_addclose, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_addclose, int,
(posix_spawn_file_actions_t *__file_actions, int __fd),
_GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_addclose, int,
(posix_spawn_file_actions_t *__file_actions, int __fd));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_addclose, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_addclose, int,
(posix_spawn_file_actions_t *__file_actions, int __fd),
_GL_ARG_NONNULL ((1))) __THROW;
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_adddup2 rpl_posix_spawn_file_actions_adddup2
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_adddup2, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
int __fd, int __newfd),
_GL_ARG_NONNULL ((1))) __THROW;
int __fd, int __newfd));
# else
# if !@HAVE_POSIX_SPAWN@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_adddup2, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
int __fd, int __newfd),
_GL_ARG_NONNULL ((1))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_addchdir rpl_posix_spawn_file_actions_addchdir
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_addchdir, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
const char *_Restrict_ __path),
_GL_ARG_NONNULL ((1, 2))) __THROW;
const char *_Restrict_ __path));
# else
# if !@HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_addchdir, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
const char *_Restrict_ __path),
_GL_ARG_NONNULL ((1, 2))) __THROW;
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawn_file_actions_addfchdir rpl_posix_spawn_file_actions_addfchdir
# endif
-_GL_FUNCATTR_RPL (posix_spawn_file_actions_addfchdir, int,
+_GL_FUNCDECL_RPL (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd),
_GL_ARG_NONNULL ((1))) __THROW;
int __fd));
# else
# if !@HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR@
-_GL_FUNCATTR_SYS (posix_spawn_file_actions_addfchdir, int,
+_GL_FUNCDECL_SYS (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd),
_GL_ARG_NONNULL ((1))) __THROW;
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure codes are ENOMEM
and the possible failure codes from write(), excluding EINTR. */
-_GL_FUNCATTR_SYS (dzprintf, off64_t,
+_GL_FUNCDECL_SYS (dzprintf, off64_t,
(int fd, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define dprintf rpl_dprintf
# endif
-_GL_FUNCATTR_RPL (dprintf, int, (int fd, const char *restrict format, ...),
+_GL_FUNCDECL_RPL (dprintf, int, (int fd, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (dprintf, int, (int fd, const char *restrict format, ...));
# else
# if !@HAVE_DPRINTF@
-_GL_FUNCATTR_SYS (dprintf, int, (int fd, const char *restrict format, ...),
+_GL_FUNCDECL_SYS (dprintf, int, (int fd, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((2)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define fclose rpl_fclose
# endif
-_GL_FUNCATTR_RPL (fclose, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (fclose, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (fclose, int, (FILE *stream));
# else
_GL_CXXALIAS_SYS (fclose, int, (FILE *stream));
# undef fdopen
# define fdopen rpl_fdopen
# endif
-_GL_FUNCATTR_RPL (fdopen, FILE *,
+_GL_FUNCDECL_RPL (fdopen, FILE *,
(int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate fdopen with fclose or rpl_fclose. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (fdopen, FILE *,
+_GL_FUNCDECL_SYS (fdopen, FILE *,
(int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (fdopen, FILE *,
+_GL_FUNCDECL_SYS (fdopen, FILE *,
(int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
# if @GNULIB_FCLOSE@ && (__GNUC__ >= 11 && !defined __clang__) && !defined fdopen
/* For -Wmismatched-dealloc: Associate fdopen with fclose or rpl_fclose. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (fdopen, FILE *,
+_GL_FUNCDECL_SYS (fdopen, FILE *,
(int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (fdopen, FILE *,
+_GL_FUNCDECL_SYS (fdopen, FILE *,
(int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define fflush rpl_fflush
# endif
-_GL_FUNCDECL_RPL (fflush, int, (FILE *gl_stream));
+_GL_FUNCDECL_RPL (fflush, int, (FILE *gl_stream), );
_GL_CXXALIAS_RPL (fflush, int, (FILE *gl_stream));
# else
_GL_CXXALIAS_SYS (fflush, int, (FILE *gl_stream));
# undef fgetc
# define fgetc rpl_fgetc
# endif
-_GL_FUNCATTR_RPL (fgetc, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (fgetc, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (fgetc, int, (FILE *stream));
# else
_GL_CXXALIAS_SYS (fgetc, int, (FILE *stream));
# undef fgets
# define fgets rpl_fgets
# endif
-_GL_FUNCATTR_RPL (fgets, char *,
+_GL_FUNCDECL_RPL (fgets, char *,
(char *restrict s, int n, FILE *restrict stream),
_GL_ARG_NONNULL ((1, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fgets, char *,
# undef fopen
# define fopen rpl_fopen
# endif
-_GL_FUNCATTR_RPL (fopen, FILE *,
+_GL_FUNCDECL_RPL (fopen, FILE *,
(const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_NODISCARD);
# else
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate fopen with fclose or rpl_fclose. */
-_GL_FUNCATTR_SYS (fopen, FILE *,
+_GL_FUNCDECL_SYS (fopen, FILE *,
(const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_NODISCARD);
#else
# if @GNULIB_FCLOSE@ && (__GNUC__ >= 11 && !defined __clang__) && !defined fopen
/* For -Wmismatched-dealloc: Associate fopen with fclose or rpl_fclose. */
-_GL_FUNCATTR_SYS (fopen, FILE *,
+_GL_FUNCDECL_SYS (fopen, FILE *,
(const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1));
# endif
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure causes are ENOMEM
and the possible failure causes from fwrite(). */
-_GL_FUNCATTR_SYS (fzprintf, off64_t,
+_GL_FUNCDECL_SYS (fzprintf, off64_t,
(FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# endif
# define GNULIB_overrides_fprintf 1
# if @GNULIB_FPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@
-_GL_FUNCATTR_RPL (fprintf, int,
+_GL_FUNCDECL_RPL (fprintf, int,
(FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# else
-_GL_FUNCATTR_RPL (fprintf, int,
+_GL_FUNCDECL_RPL (fprintf, int,
(FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define fpurge rpl_fpurge
# endif
-_GL_FUNCATTR_RPL (fpurge, int, (FILE *gl_stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (fpurge, int, (FILE *gl_stream), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (fpurge, int, (FILE *gl_stream));
# else
# if !@HAVE_DECL_FPURGE@
-_GL_FUNCATTR_SYS (fpurge, int, (FILE *gl_stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (fpurge, int, (FILE *gl_stream), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (fpurge, int, (FILE *gl_stream));
# endif
# undef fputc
# define fputc rpl_fputc
# endif
-_GL_FUNCATTR_RPL (fputc, int, (int c, FILE *stream), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream), _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (fputc, int, (int c, FILE *stream));
# else
_GL_CXXALIAS_SYS (fputc, int, (int c, FILE *stream));
# undef fputs
# define fputs rpl_fputs
# endif
-_GL_FUNCATTR_RPL (fputs, int,
+_GL_FUNCDECL_RPL (fputs, int,
(const char *restrict string, FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (fputs, int,
# undef fread
# define fread rpl_fread
# endif
-_GL_FUNCATTR_RPL (fread, size_t,
+_GL_FUNCDECL_RPL (fread, size_t,
(void *restrict ptr, size_t s, size_t n,
FILE *restrict stream),
_GL_ARG_NONNULL ((4)) _GL_ATTRIBUTE_NODISCARD);
# undef freopen
# define freopen rpl_freopen
# endif
-_GL_FUNCATTR_RPL (freopen, FILE *,
+_GL_FUNCDECL_RPL (freopen, FILE *,
(const char *restrict filename, const char *restrict mode,
FILE *restrict stream),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
# undef fscanf
# define fscanf rpl_fscanf
# endif
-_GL_FUNCATTR_RPL (fscanf, int,
+_GL_FUNCDECL_RPL (fscanf, int,
(FILE *restrict stream, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 3)
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# undef fseek
# define fseek rpl_fseek
# endif
-_GL_FUNCATTR_RPL (fseek, int, (FILE *fp, long offset, int whence),
+_GL_FUNCDECL_RPL (fseek, int, (FILE *fp, long offset, int whence),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (fseek, int, (FILE *fp, long offset, int whence));
# else
# undef fseeko
# define fseeko rpl_fseeko
# endif
-_GL_FUNCATTR_RPL (fseeko, int, (FILE *fp, off_t offset, int whence),
+_GL_FUNCDECL_RPL (fseeko, int, (FILE *fp, off_t offset, int whence),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (fseeko, int, (FILE *fp, off_t offset, int whence));
# else
# if ! @HAVE_DECL_FSEEKO@
-_GL_FUNCATTR_SYS (fseeko, int, (FILE *fp, off_t offset, int whence),
+_GL_FUNCDECL_SYS (fseeko, int, (FILE *fp, off_t offset, int whence),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (fseeko, int, (FILE *fp, off_t offset, int whence));
# undef ftell
# define ftell rpl_ftell
# endif
-_GL_FUNCATTR_RPL (ftell, long, (FILE *fp),
+_GL_FUNCDECL_RPL (ftell, long, (FILE *fp),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ftell, long, (FILE *fp));
# else
# undef ftello
# define ftello rpl_ftello
# endif
-_GL_FUNCATTR_RPL (ftello, off_t, (FILE *fp),
+_GL_FUNCDECL_RPL (ftello, off_t, (FILE *fp),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ftello, off_t, (FILE *fp));
# else
# if ! @HAVE_DECL_FTELLO@
-_GL_FUNCATTR_SYS (ftello, off_t, (FILE *fp),
+_GL_FUNCDECL_SYS (ftello, off_t, (FILE *fp),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (ftello, off_t, (FILE *fp));
# undef fwrite
# define fwrite rpl_fwrite
# endif
-_GL_FUNCATTR_RPL (fwrite, size_t,
+_GL_FUNCDECL_RPL (fwrite, size_t,
(const void *restrict ptr, size_t s, size_t n,
FILE *restrict stream),
_GL_ARG_NONNULL ((1, 4)));
# undef getc
# define getc rpl_fgetc
# endif
-_GL_FUNCATTR_RPL (fgetc, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (fgetc, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL_1 (getc, rpl_fgetc, int, (FILE *stream));
# else
_GL_CXXALIAS_SYS (getc, int, (FILE *stream));
# undef getchar
# define getchar rpl_getchar
# endif
-_GL_FUNCDECL_RPL (getchar, int, (void));
+_GL_FUNCDECL_RPL (getchar, int, (void), );
_GL_CXXALIAS_RPL (getchar, int, (void));
# else
_GL_CXXALIAS_SYS (getchar, int, (void));
# undef getdelim
# define getdelim rpl_getdelim
# endif
-_GL_FUNCATTR_RPL (getdelim, ssize_t,
+_GL_FUNCDECL_RPL (getdelim, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
int delimiter,
FILE *restrict stream),
FILE *restrict stream));
# else
# if !@HAVE_DECL_GETDELIM@
-_GL_FUNCATTR_SYS (getdelim, ssize_t,
+_GL_FUNCDECL_SYS (getdelim, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
int delimiter,
FILE *restrict stream),
# undef getline
# define getline rpl_getline
# endif
-_GL_FUNCATTR_RPL (getline, ssize_t,
+_GL_FUNCDECL_RPL (getline, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
FILE *restrict stream));
# else
# if !@HAVE_DECL_GETLINE@
-_GL_FUNCATTR_SYS (getline, ssize_t,
+_GL_FUNCDECL_SYS (getline, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
# if @HAVE_DECL_GETW@
# if defined __APPLE__ && defined __MACH__
/* The presence of the declaration depends on _POSIX_C_SOURCE. */
-_GL_FUNCDECL_SYS (getw, int, (FILE *restrict stream));
+_GL_FUNCDECL_SYS (getw, int, (FILE *restrict stream), );
# endif
_GL_CXXALIAS_SYS (getw, int, (FILE *restrict stream));
# endif
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is through
obstack_alloc_failed_handler. */
-_GL_FUNCATTR_SYS (obstack_zprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (obstack_zprintf, ptrdiff_t,
(struct obstack *obs, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (obstack_zprintf, ptrdiff_t,
(struct obstack *obs, const char *format, ...));
-_GL_FUNCATTR_SYS (obstack_vzprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (obstack_vzprintf, ptrdiff_t,
(struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define obstack_printf rpl_obstack_printf
# endif
-_GL_FUNCATTR_RPL (obstack_printf, int,
+_GL_FUNCDECL_RPL (obstack_printf, int,
(struct obstack *obs, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
(struct obstack *obs, const char *format, ...));
# else
# if !@HAVE_DECL_OBSTACK_PRINTF@
-_GL_FUNCATTR_SYS (obstack_printf, int,
+_GL_FUNCDECL_SYS (obstack_printf, int,
(struct obstack *obs, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define obstack_vprintf rpl_obstack_vprintf
# endif
-_GL_FUNCATTR_RPL (obstack_vprintf, int,
+_GL_FUNCDECL_RPL (obstack_vprintf, int,
(struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
(struct obstack *obs, const char *format, va_list args));
# else
# if !@HAVE_DECL_OBSTACK_PRINTF@
-_GL_FUNCATTR_SYS (obstack_vprintf, int,
+_GL_FUNCDECL_SYS (obstack_vprintf, int,
(struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
#if @GNULIB_PCLOSE@
# if !@HAVE_PCLOSE@
-_GL_FUNCATTR_SYS (pclose, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (pclose, int, (FILE *stream), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pclose, int, (FILE *stream));
_GL_CXXALIASWARN (pclose);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define perror rpl_perror
# endif
-_GL_FUNCDECL_RPL (perror, void, (const char *string));
+_GL_FUNCDECL_RPL (perror, void, (const char *string), );
_GL_CXXALIAS_RPL (perror, void, (const char *string));
# else
_GL_CXXALIAS_SYS (perror, void, (const char *string));
# undef popen
# define popen rpl_popen
# endif
-_GL_FUNCATTR_RPL (popen, FILE *,
+_GL_FUNCDECL_RPL (popen, FILE *,
(const char *cmd, const char *mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (pclose, 1)
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (popen, FILE *, (const char *cmd, const char *mode));
# else
# if !@HAVE_POPEN@ || (__GNUC__ >= 11 && !defined __clang__)
-_GL_FUNCATTR_SYS (popen, FILE *,
+_GL_FUNCDECL_SYS (popen, FILE *,
(const char *cmd, const char *mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (pclose, 1)
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_NODISCARD);
# if @GNULIB_PCLOSE@ \
&& (__GNUC__ >= 11 && !defined __clang__) && !defined popen
/* For -Wmismatched-dealloc: Associate popen with pclose or rpl_pclose. */
-_GL_FUNCATTR_SYS (popen, FILE *,
+_GL_FUNCDECL_SYS (popen, FILE *,
(const char *cmd, const char *mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (pclose, 1)
_GL_ATTRIBUTE_MALLOC);
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure causes are ENOMEM
and the possible failure causes from fwrite(). */
-_GL_FUNCATTR_SYS (zprintf, off64_t, (const char *restrict format, ...),
+_GL_FUNCDECL_SYS (zprintf, off64_t, (const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 2)
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_SYS (zprintf, off64_t, (const char *restrict format, ...));
# define printf __printf__
# endif
# if @GNULIB_PRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@
-_GL_FUNCATTR_RPL_1 (__printf__, int,
+_GL_FUNCDECL_RPL_1 (__printf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
_GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 2)
_GL_ARG_NONNULL ((1)));
# else
-_GL_FUNCATTR_RPL_1 (__printf__, int,
+_GL_FUNCDECL_RPL_1 (__printf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
_GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)),
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define printf rpl_printf
# endif
-_GL_FUNCATTR_RPL (printf, int,
+_GL_FUNCDECL_RPL (printf, int,
(const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 2)
_GL_ARG_NONNULL ((1)));
# undef putc
# define putc rpl_fputc
# endif
-_GL_FUNCATTR_RPL (fputc, int, (int c, FILE *stream), _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream), _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL_1 (putc, rpl_fputc, int, (int c, FILE *stream));
# else
_GL_CXXALIAS_SYS (putc, int, (int c, FILE *stream));
# undef putchar
# define putchar rpl_putchar
# endif
-_GL_FUNCDECL_RPL (putchar, int, (int c));
+_GL_FUNCDECL_RPL (putchar, int, (int c), );
_GL_CXXALIAS_RPL (putchar, int, (int c));
# else
_GL_CXXALIAS_SYS (putchar, int, (int c));
# undef puts
# define puts rpl_puts
# endif
-_GL_FUNCATTR_RPL (puts, int, (const char *string), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (puts, int, (const char *string), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (puts, int, (const char *string));
# else
_GL_CXXALIAS_SYS (puts, int, (const char *string));
# if @HAVE_DECL_PUTW@
# if defined __APPLE__ && defined __MACH__
/* The presence of the declaration depends on _POSIX_C_SOURCE. */
-_GL_FUNCDECL_SYS (putw, int, (int w, FILE *restrict stream));
+_GL_FUNCDECL_SYS (putw, int, (int w, FILE *restrict stream), );
# endif
_GL_CXXALIAS_SYS (putw, int, (int w, FILE *restrict stream));
# endif
# undef remove
# define remove rpl_remove
# endif
-_GL_FUNCATTR_RPL (remove, int, (const char *name), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (remove, int, (const char *name), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (remove, int, (const char *name));
# else
_GL_CXXALIAS_SYS (remove, int, (const char *name));
# undef rename
# define rename rpl_rename
# endif
-_GL_FUNCATTR_RPL (rename, int,
+_GL_FUNCDECL_RPL (rename, int,
(const char *old_filename, const char *new_filename),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (rename, int,
# undef renameat
# define renameat rpl_renameat
# endif
-_GL_FUNCATTR_RPL (renameat, int,
+_GL_FUNCDECL_RPL (renameat, int,
(int fd1, char const *file1, int fd2, char const *file2),
_GL_ARG_NONNULL ((2, 4)));
_GL_CXXALIAS_RPL (renameat, int,
(int fd1, char const *file1, int fd2, char const *file2));
# else
# if !@HAVE_RENAMEAT@
-_GL_FUNCATTR_SYS (renameat, int,
+_GL_FUNCDECL_SYS (renameat, int,
(int fd1, char const *file1, int fd2, char const *file2),
_GL_ARG_NONNULL ((2, 4)));
# endif
/* Don't break __attribute__((format(scanf,M,N))). */
# define scanf __scanf__
# endif
-_GL_FUNCATTR_RPL_1 (__scanf__, int,
+_GL_FUNCDECL_RPL_1 (__scanf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
_GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_scanf)),
# undef scanf
# define scanf rpl_scanf
# endif
-_GL_FUNCATTR_RPL (scanf, int, (const char *restrict format, ...),
+_GL_FUNCDECL_RPL (scanf, int, (const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2)
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (scanf, int, (const char *restrict format, ...));
Failure code EOVERFLOW can only occur when a width > INT_MAX is used.
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
-_GL_FUNCATTR_SYS (snzprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (snzprintf, ptrdiff_t,
(char *restrict str, size_t size,
const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
# define snprintf rpl_snprintf
# endif
# define GNULIB_overrides_snprintf 1
-_GL_FUNCATTR_RPL (snprintf, int,
+_GL_FUNCDECL_RPL (snprintf, int,
(char *restrict str, size_t size,
const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
const char *restrict format, ...));
# else
# if !@HAVE_DECL_SNPRINTF@
-_GL_FUNCATTR_SYS (snprintf, int,
+_GL_FUNCDECL_SYS (snprintf, int,
(char *restrict str, size_t size,
const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
Failure code EOVERFLOW can only occur when a width > INT_MAX is used.
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
-_GL_FUNCATTR_SYS (szprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (szprintf, ptrdiff_t,
(char *restrict str,
const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
# define sprintf rpl_sprintf
# endif
# define GNULIB_overrides_sprintf 1
-_GL_FUNCATTR_RPL (sprintf, int,
+_GL_FUNCDECL_RPL (sprintf, int,
(char *restrict str, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tmpfile rpl_tmpfile
# endif
-_GL_FUNCATTR_RPL (tmpfile, FILE *, (void),
+_GL_FUNCDECL_RPL (tmpfile, FILE *, (void),
_GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD);
# else
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate tmpfile with fclose or rpl_fclose. */
-_GL_FUNCATTR_SYS (tmpfile, FILE *, (void),
+_GL_FUNCDECL_SYS (tmpfile, FILE *, (void),
_GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD);
# if @GNULIB_FCLOSE@ \
&& (__GNUC__ >= 11 && !defined __clang__) && !defined tmpfile
/* For -Wmismatched-dealloc: Associate tmpfile with fclose or rpl_fclose. */
-_GL_FUNCATTR_SYS (tmpfile, FILE *, (void),
+_GL_FUNCDECL_SYS (tmpfile, FILE *, (void),
_GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC);
# endif
Failure code EOVERFLOW can only occur when a width > INT_MAX is used.
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
-_GL_FUNCATTR_SYS (aszprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (aszprintf, ptrdiff_t,
(char **result, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_SYS (aszprintf, ptrdiff_t,
(char **result, const char *format, ...));
-_GL_FUNCATTR_SYS (vaszprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (vaszprintf, ptrdiff_t,
(char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
# define asprintf rpl_asprintf
# endif
# define GNULIB_overrides_asprintf
-_GL_FUNCATTR_RPL (asprintf, int,
+_GL_FUNCDECL_RPL (asprintf, int,
(char **result, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2))
(char **result, const char *format, ...));
# else
# if !@HAVE_VASPRINTF@
-_GL_FUNCATTR_SYS (asprintf, int,
+_GL_FUNCDECL_SYS (asprintf, int,
(char **result, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2))
# define vasprintf rpl_vasprintf
# endif
# define GNULIB_overrides_vasprintf 1
-_GL_FUNCATTR_RPL (vasprintf, int,
+_GL_FUNCDECL_RPL (vasprintf, int,
(char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
(char **result, const char *format, va_list args));
# else
# if !@HAVE_VASPRINTF@
-_GL_FUNCATTR_SYS (vasprintf, int,
+_GL_FUNCDECL_SYS (vasprintf, int,
(char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure codes are ENOMEM
and the possible failure codes from write(), excluding EINTR. */
-_GL_FUNCATTR_SYS (vdzprintf, off64_t,
+_GL_FUNCDECL_SYS (vdzprintf, off64_t,
(int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define vdprintf rpl_vdprintf
# endif
-_GL_FUNCATTR_RPL (vdprintf, int,
+_GL_FUNCDECL_RPL (vdprintf, int,
(int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
(int fd, const char *restrict format, va_list args));
# else
# if !@HAVE_VDPRINTF@
-_GL_FUNCATTR_SYS (vdprintf, int,
+_GL_FUNCDECL_SYS (vdprintf, int,
(int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure causes are ENOMEM
and the possible failure causes from fwrite(). */
-_GL_FUNCATTR_SYS (vfzprintf, off64_t,
+_GL_FUNCDECL_SYS (vfzprintf, off64_t,
(FILE *restrict fp,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
# endif
# define GNULIB_overrides_vfprintf 1
# if @GNULIB_VFPRINTF_POSIX@
-_GL_FUNCATTR_RPL (vfprintf, int,
+_GL_FUNCDECL_RPL (vfprintf, int,
(FILE *restrict fp,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
# else
-_GL_FUNCATTR_RPL (vfprintf, int,
+_GL_FUNCDECL_RPL (vfprintf, int,
(FILE *restrict fp,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 0)
# undef vfscanf
# define vfscanf rpl_vfscanf
# endif
-_GL_FUNCATTR_RPL (vfscanf, int,
+_GL_FUNCDECL_RPL (vfscanf, int,
(FILE *restrict stream,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 0)
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure causes are ENOMEM
and the possible failure causes from fwrite(). */
-_GL_FUNCATTR_SYS (vzprintf, off64_t,
+_GL_FUNCDECL_SYS (vzprintf, off64_t,
(const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 0)
_GL_ARG_NONNULL ((1)));
# endif
# define GNULIB_overrides_vprintf 1
# if @GNULIB_VPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@
-_GL_FUNCATTR_RPL (vprintf, int, (const char *restrict format, va_list args),
+_GL_FUNCDECL_RPL (vprintf, int, (const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 0)
_GL_ARG_NONNULL ((1)));
# else
-_GL_FUNCATTR_RPL (vprintf, int, (const char *restrict format, va_list args),
+_GL_FUNCDECL_RPL (vprintf, int, (const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 0)
_GL_ARG_NONNULL ((1)));
# endif
# undef vscanf
# define vscanf rpl_vscanf
# endif
-_GL_FUNCATTR_RPL (vscanf, int, (const char *restrict format, va_list args),
+_GL_FUNCDECL_RPL (vscanf, int, (const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 0)
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (vscanf, int, (const char *restrict format, va_list args));
Failure code EOVERFLOW can only occur when a width > INT_MAX is used.
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
-_GL_FUNCATTR_SYS (vsnzprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (vsnzprintf, ptrdiff_t,
(char *restrict str, size_t size,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
# define vsnprintf rpl_vsnprintf
# endif
# define GNULIB_overrides_vsnprintf 1
-_GL_FUNCATTR_RPL (vsnprintf, int,
+_GL_FUNCDECL_RPL (vsnprintf, int,
(char *restrict str, size_t size,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
const char *restrict format, va_list args));
# else
# if !@HAVE_DECL_VSNPRINTF@
-_GL_FUNCATTR_SYS (vsnprintf, int,
+_GL_FUNCDECL_SYS (vsnprintf, int,
(char *restrict str, size_t size,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
Failure code EOVERFLOW can only occur when a width > INT_MAX is used.
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
-_GL_FUNCATTR_SYS (vszprintf, ptrdiff_t,
+_GL_FUNCDECL_SYS (vszprintf, ptrdiff_t,
(char *restrict str,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
# define vsprintf rpl_vsprintf
# endif
# define GNULIB_overrides_vsprintf 1
-_GL_FUNCATTR_RPL (vsprintf, int,
+_GL_FUNCDECL_RPL (vsprintf, int,
(char *restrict str,
const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
# undef _Exit
# define _Exit rpl__Exit
# endif
-_GL_FUNCDECL_RPL (_Exit, _Noreturn void, (int status));
+_GL_FUNCDECL_RPL (_Exit, _Noreturn void, (int status), );
_GL_CXXALIAS_RPL (_Exit, void, (int status));
# else
# if !@HAVE__EXIT@
-_GL_FUNCDECL_SYS (_Exit, _Noreturn void, (int status));
+_GL_FUNCDECL_SYS (_Exit, _Noreturn void, (int status), );
# endif
_GL_CXXALIAS_SYS (_Exit, void, (int status));
# endif
# undef abort
# define abort rpl_abort
# endif
-_GL_FUNCDECL_RPL (abort, _Noreturn void, (void));
+_GL_FUNCDECL_RPL (abort, _Noreturn void, (void), );
_GL_CXXALIAS_RPL (abort, void, (void));
# else
_GL_CXXALIAS_SYS (abort, void, (void));
# define free rpl_free
# endif
# if defined __cplusplus && (__GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2)
-_GL_FUNCDECL_RPL (free, void, (void *ptr)) _GL_ATTRIBUTE_NOTHROW;
+_GL_FUNCDECL_RPL (free, void, (void *ptr), ) _GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCDECL_RPL (free, void, (void *ptr));
+_GL_FUNCDECL_RPL (free, void, (void *ptr), );
# endif
_GL_CXXALIAS_RPL (free, void, (void *ptr));
# else
# undef aligned_alloc
# define aligned_alloc rpl_aligned_alloc
# endif
-_GL_FUNCATTR_RPL (aligned_alloc, void *,
+_GL_FUNCDECL_RPL (aligned_alloc, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate aligned_alloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 16) > 2
-_GL_FUNCATTR_SYS (aligned_alloc, void *,
+_GL_FUNCDECL_SYS (aligned_alloc, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (aligned_alloc, void *,
+_GL_FUNCDECL_SYS (aligned_alloc, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
&& (__GNUC__ >= 11 && !defined __clang__) && !defined aligned_alloc
/* For -Wmismatched-dealloc: Associate aligned_alloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 16) > 2
-_GL_FUNCATTR_SYS (aligned_alloc, void *,
+_GL_FUNCDECL_SYS (aligned_alloc, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (aligned_alloc, void *,
+_GL_FUNCDECL_SYS (aligned_alloc, void *,
(size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
/* Parse a signed decimal integer.
Returns the value of the integer. Errors are not detected. */
# if !@HAVE_ATOLL@
-_GL_FUNCATTR_SYS (atoll, long long,
+_GL_FUNCDECL_SYS (atoll, long long,
(const char *string),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# undef calloc
# define calloc rpl_calloc
# endif
-_GL_FUNCATTR_RPL (calloc, void *,
+_GL_FUNCDECL_RPL (calloc, void *,
(size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate calloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (calloc, void *,
+_GL_FUNCDECL_SYS (calloc, void *,
(size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (calloc, void *,
+_GL_FUNCDECL_SYS (calloc, void *,
(size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
&& (__GNUC__ >= 11 && !defined __clang__) && !defined calloc
/* For -Wmismatched-dealloc: Associate calloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (calloc, void *,
+_GL_FUNCDECL_SYS (calloc, void *,
(size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (calloc, void *,
+_GL_FUNCDECL_SYS (calloc, void *,
(size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define canonicalize_file_name rpl_canonicalize_file_name
# endif
-_GL_FUNCATTR_RPL (canonicalize_file_name, char *,
+_GL_FUNCDECL_RPL (canonicalize_file_name, char *,
(const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
# else
# if !@HAVE_CANONICALIZE_FILE_NAME@ || (__GNUC__ >= 11 && !defined __clang__)
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (canonicalize_file_name, char *,
+_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
(const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (canonicalize_file_name, char *,
+_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
(const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
/* For -Wmismatched-dealloc: Associate canonicalize_file_name with free or
rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (canonicalize_file_name, char *,
+_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
(const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (canonicalize_file_name, char *,
+_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
(const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# undef getloadavg
# define getloadavg rpl_getloadavg
# endif
-_GL_FUNCATTR_RPL (getloadavg, int, (double loadavg[], int nelem),
+_GL_FUNCDECL_RPL (getloadavg, int, (double loadavg[], int nelem),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (getloadavg, int, (double loadavg[], int nelem));
# else
# if !@HAVE_DECL_GETLOADAVG@
-_GL_FUNCATTR_SYS (getloadavg, int, (double loadavg[], int nelem),
+_GL_FUNCDECL_SYS (getloadavg, int, (double loadavg[], int nelem),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (getloadavg, int, (double loadavg[], int nelem));
# define getprogname rpl_getprogname
# endif
# if @HAVE_DECL_PROGRAM_INVOCATION_NAME@
-_GL_FUNCATTR_RPL (getprogname, const char *, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (getprogname, const char *, (void), _GL_ATTRIBUTE_PURE);
# else
-_GL_FUNCDECL_RPL (getprogname, const char *, (void));
+_GL_FUNCDECL_RPL (getprogname, const char *, (void), );
# endif
_GL_CXXALIAS_RPL (getprogname, const char *, (void));
# else
# if !@HAVE_GETPROGNAME@
# if @HAVE_DECL_PROGRAM_INVOCATION_NAME@
-_GL_FUNCATTR_SYS (getprogname, const char *, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (getprogname, const char *, (void), _GL_ATTRIBUTE_PURE);
# else
-_GL_FUNCDECL_SYS (getprogname, const char *, (void));
+_GL_FUNCDECL_SYS (getprogname, const char *, (void), );
# endif
# endif
_GL_CXXALIAS_SYS (getprogname, const char *, (void));
# undef getsubopt
# define getsubopt rpl_getsubopt
# endif
-_GL_FUNCATTR_RPL (getsubopt, int,
+_GL_FUNCDECL_RPL (getsubopt, int,
(char **optionp, char *const *tokens, char **valuep),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getsubopt, int,
(char **optionp, char *const *tokens, char **valuep));
# else
# if !@HAVE_GETSUBOPT@
-_GL_FUNCATTR_SYS (getsubopt, int,
+_GL_FUNCDECL_SYS (getsubopt, int,
(char **optionp, char *const *tokens, char **valuep),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
/* Change the ownership and access permission of the slave side of the
pseudo-terminal whose master side is specified by FD. */
# if !@HAVE_GRANTPT@
-_GL_FUNCDECL_SYS (grantpt, int, (int fd));
+_GL_FUNCDECL_SYS (grantpt, int, (int fd), );
# endif
_GL_CXXALIAS_SYS (grantpt, int, (int fd));
_GL_CXXALIASWARN (grantpt);
# undef malloc
# define malloc rpl_malloc
# endif
-_GL_FUNCATTR_RPL (malloc, void *,
+_GL_FUNCDECL_RPL (malloc, void *,
(size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate malloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (malloc, void *,
+_GL_FUNCDECL_SYS (malloc, void *,
(size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (malloc, void *,
+_GL_FUNCDECL_SYS (malloc, void *,
(size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
&& (__GNUC__ >= 11 && !defined __clang__) && !defined malloc
/* For -Wmismatched-dealloc: Associate malloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (malloc, void *,
+_GL_FUNCDECL_SYS (malloc, void *,
(size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (malloc, void *,
+_GL_FUNCDECL_SYS (malloc, void *,
(size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# undef mbstowcs
# define mbstowcs rpl_mbstowcs
# endif
-_GL_FUNCATTR_RPL (mbstowcs, size_t,
+_GL_FUNCDECL_RPL (mbstowcs, size_t,
(wchar_t *restrict dest, const char *restrict src,
size_t len),
_GL_ARG_NONNULL ((2)));
# define mbtowc rpl_mbtowc
# endif
_GL_FUNCDECL_RPL (mbtowc, int,
- (wchar_t *restrict pwc, const char *restrict s, size_t n));
+ (wchar_t *restrict pwc, const char *restrict s, size_t n), );
_GL_CXXALIAS_RPL (mbtowc, int,
(wchar_t *restrict pwc, const char *restrict s, size_t n));
# else
# if !@HAVE_MBTOWC@
_GL_FUNCDECL_SYS (mbtowc, int,
- (wchar_t *restrict pwc, const char *restrict s, size_t n));
+ (wchar_t *restrict pwc, const char *restrict s, size_t n), );
# endif
_GL_CXXALIAS_SYS (mbtowc, int,
(wchar_t *restrict pwc, const char *restrict s, size_t n));
Returns TEMPLATE, or a null pointer if it cannot get a unique name.
The directory is created mode 700. */
# if !@HAVE_MKDTEMP@
-_GL_FUNCATTR_SYS (mkdtemp, char *,
+_GL_FUNCDECL_SYS (mkdtemp, char *,
(char * /*template*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef mkostemp
# define mkostemp rpl_mkostemp
# endif
-_GL_FUNCATTR_RPL (mkostemp, int, (char * /*template*/, int /*flags*/),
+_GL_FUNCDECL_RPL (mkostemp, int, (char * /*template*/, int /*flags*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (mkostemp, int, (char * /*template*/, int /*flags*/));
# else
# if !@HAVE_MKOSTEMP@
-_GL_FUNCATTR_SYS (mkostemp, int, (char * /*template*/, int /*flags*/),
+_GL_FUNCDECL_SYS (mkostemp, int, (char * /*template*/, int /*flags*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (mkostemp, int, (char * /*template*/, int /*flags*/));
# undef mkostemps
# define mkostemps rpl_mkostemps
# endif
-_GL_FUNCATTR_RPL (mkostemps, int,
+_GL_FUNCDECL_RPL (mkostemps, int,
(char * /*template*/, int /*suffixlen*/, int /*flags*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (mkostemps, int,
(char * /*template*/, int /*suffixlen*/, int /*flags*/));
# else
# if !@HAVE_MKOSTEMPS@
-_GL_FUNCATTR_SYS (mkostemps, int,
+_GL_FUNCDECL_SYS (mkostemps, int,
(char * /*template*/, int /*suffixlen*/, int /*flags*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mkstemp rpl_mkstemp
# endif
-_GL_FUNCATTR_RPL (mkstemp, int, (char * /*template*/),
+_GL_FUNCDECL_RPL (mkstemp, int, (char * /*template*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (mkstemp, int, (char * /*template*/));
# else
# if ! @HAVE_MKSTEMP@
-_GL_FUNCATTR_SYS (mkstemp, int, (char * /*template*/),
+_GL_FUNCDECL_SYS (mkstemp, int, (char * /*template*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (mkstemp, int, (char * /*template*/));
Returns the open file descriptor if successful, otherwise -1 and errno
set. */
# if !@HAVE_MKSTEMPS@
-_GL_FUNCATTR_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/),
+_GL_FUNCDECL_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/));
# undef posix_memalign
# define posix_memalign rpl_posix_memalign
# endif
-_GL_FUNCATTR_RPL (posix_memalign, int,
+_GL_FUNCDECL_RPL (posix_memalign, int,
(void **memptr, size_t alignment, size_t size),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (posix_memalign, int,
# undef posix_openpt
# define posix_openpt rpl_posix_openpt
# endif
-_GL_FUNCATTR_RPL (posix_openpt, int, (int flags), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_RPL (posix_openpt, int, (int flags), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (posix_openpt, int, (int flags));
# else
# if !@HAVE_POSIX_OPENPT@
-_GL_FUNCATTR_SYS (posix_openpt, int, (int flags), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_SYS (posix_openpt, int, (int flags), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (posix_openpt, int, (int flags));
# endif
# undef ptsname
# define ptsname rpl_ptsname
# endif
-_GL_FUNCATTR_RPL (ptsname, char *, (int fd), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_RPL (ptsname, char *, (int fd), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ptsname, char *, (int fd));
# else
# if !@HAVE_PTSNAME@
-_GL_FUNCATTR_SYS (ptsname, char *, (int fd), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_SYS (ptsname, char *, (int fd), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (ptsname, char *, (int fd));
# endif
# undef ptsname_r
# define ptsname_r rpl_ptsname_r
# endif
-_GL_FUNCDECL_RPL (ptsname_r, int, (int fd, char *buf, size_t len));
+_GL_FUNCDECL_RPL (ptsname_r, int, (int fd, char *buf, size_t len), );
_GL_CXXALIAS_RPL (ptsname_r, int, (int fd, char *buf, size_t len));
# else
# if !@HAVE_PTSNAME_R@
-_GL_FUNCDECL_SYS (ptsname_r, int, (int fd, char *buf, size_t len));
+_GL_FUNCDECL_SYS (ptsname_r, int, (int fd, char *buf, size_t len), );
# endif
_GL_CXXALIAS_SYS (ptsname_r, int, (int fd, char *buf, size_t len));
# endif
# undef putenv
# define putenv rpl_putenv
# endif
-_GL_FUNCATTR_RPL (putenv, int, (char *string), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (putenv, int, (char *string), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (putenv, int, (char *string));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# undef qsort_r
# define qsort_r rpl_qsort_r
# endif
-_GL_FUNCATTR_RPL (qsort_r, void, (void *base, size_t nmemb, size_t size,
+_GL_FUNCDECL_RPL (qsort_r, void, (void *base, size_t nmemb, size_t size,
_gl_qsort_r_compar_fn compare,
void *arg),
_GL_ARG_NONNULL ((1, 4)));
void *arg));
# else
# if !@HAVE_QSORT_R@
-_GL_FUNCATTR_SYS (qsort_r, void, (void *base, size_t nmemb, size_t size,
+_GL_FUNCDECL_SYS (qsort_r, void, (void *base, size_t nmemb, size_t size,
_gl_qsort_r_compar_fn compare,
void *arg),
_GL_ARG_NONNULL ((1, 4)));
# undef rand
# define rand rpl_rand
# endif
-_GL_FUNCDECL_RPL (rand, int, (void));
+_GL_FUNCDECL_RPL (rand, int, (void), );
_GL_CXXALIAS_RPL (rand, int, (void));
# else
_GL_CXXALIAS_SYS (rand, int, (void));
# undef random
# define random rpl_random
# endif
-_GL_FUNCDECL_RPL (random, long, (void));
+_GL_FUNCDECL_RPL (random, long, (void), );
_GL_CXXALIAS_RPL (random, long, (void));
# else
# if !@HAVE_RANDOM@
-_GL_FUNCDECL_SYS (random, long, (void));
+_GL_FUNCDECL_SYS (random, long, (void), );
# endif
/* Need to cast, because on Haiku, the return type is
int. */
# undef srandom
# define srandom rpl_srandom
# endif
-_GL_FUNCDECL_RPL (srandom, void, (unsigned int seed));
+_GL_FUNCDECL_RPL (srandom, void, (unsigned int seed), );
_GL_CXXALIAS_RPL (srandom, void, (unsigned int seed));
# else
# if !@HAVE_RANDOM@
-_GL_FUNCDECL_SYS (srandom, void, (unsigned int seed));
+_GL_FUNCDECL_SYS (srandom, void, (unsigned int seed), );
# endif
/* Need to cast, because on FreeBSD, the first parameter is
unsigned long seed. */
# undef initstate
# define initstate rpl_initstate
# endif
-_GL_FUNCATTR_RPL (initstate, char *,
+_GL_FUNCDECL_RPL (initstate, char *,
(unsigned int seed, char *buf, size_t buf_size),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (initstate, char *,
(unsigned int seed, char *buf, size_t buf_size));
# else
# if !@HAVE_INITSTATE@ || !@HAVE_DECL_INITSTATE@
-_GL_FUNCATTR_SYS (initstate, char *,
+_GL_FUNCDECL_SYS (initstate, char *,
(unsigned int seed, char *buf, size_t buf_size),
_GL_ARG_NONNULL ((2)));
# endif
# undef setstate
# define setstate rpl_setstate
# endif
-_GL_FUNCATTR_RPL (setstate, char *, (char *arg_state), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (setstate, char *, (char *arg_state), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (setstate, char *, (char *arg_state));
# else
# if !@HAVE_SETSTATE@ || !@HAVE_DECL_SETSTATE@
-_GL_FUNCATTR_SYS (setstate, char *, (char *arg_state), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (setstate, char *, (char *arg_state), _GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on Mac OS X 10.13, HP-UX, Solaris the first parameter
is const char *arg_state. */
# undef random_r
# define random_r rpl_random_r
# endif
-_GL_FUNCATTR_RPL (random_r, int, (struct random_data *buf, int32_t *result),
+_GL_FUNCDECL_RPL (random_r, int, (struct random_data *buf, int32_t *result),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (random_r, int, (struct random_data *buf, int32_t *result));
# else
# if !@HAVE_RANDOM_R@
-_GL_FUNCATTR_SYS (random_r, int, (struct random_data *buf, int32_t *result),
+_GL_FUNCDECL_SYS (random_r, int, (struct random_data *buf, int32_t *result),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (random_r, int, (struct random_data *buf, int32_t *result));
# undef srandom_r
# define srandom_r rpl_srandom_r
# endif
-_GL_FUNCATTR_RPL (srandom_r, int,
+_GL_FUNCDECL_RPL (srandom_r, int,
(unsigned int seed, struct random_data *rand_state),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (srandom_r, int,
(unsigned int seed, struct random_data *rand_state));
# else
# if !@HAVE_RANDOM_R@
-_GL_FUNCATTR_SYS (srandom_r, int,
+_GL_FUNCDECL_SYS (srandom_r, int,
(unsigned int seed, struct random_data *rand_state),
_GL_ARG_NONNULL ((2)));
# endif
# undef initstate_r
# define initstate_r rpl_initstate_r
# endif
-_GL_FUNCATTR_RPL (initstate_r, int,
+_GL_FUNCDECL_RPL (initstate_r, int,
(unsigned int seed, char *buf, size_t buf_size,
struct random_data *rand_state),
_GL_ARG_NONNULL ((2, 4)));
struct random_data *rand_state));
# else
# if !@HAVE_RANDOM_R@
-_GL_FUNCATTR_SYS (initstate_r, int,
+_GL_FUNCDECL_SYS (initstate_r, int,
(unsigned int seed, char *buf, size_t buf_size,
struct random_data *rand_state),
_GL_ARG_NONNULL ((2, 4)));
# undef setstate_r
# define setstate_r rpl_setstate_r
# endif
-_GL_FUNCATTR_RPL (setstate_r, int,
+_GL_FUNCDECL_RPL (setstate_r, int,
(char *arg_state, struct random_data *rand_state),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (setstate_r, int,
(char *arg_state, struct random_data *rand_state));
# else
# if !@HAVE_RANDOM_R@
-_GL_FUNCATTR_SYS (setstate_r, int,
+_GL_FUNCDECL_SYS (setstate_r, int,
(char *arg_state, struct random_data *rand_state),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef realloc
# define realloc rpl_realloc
# endif
-_GL_FUNCATTR_RPL (realloc, void *,
+_GL_FUNCDECL_RPL (realloc, void *,
(void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (realloc, void *, (void *ptr, size_t size));
# if __GNUC__ >= 11 && !defined __clang__
/* For -Wmismatched-dealloc: Associate realloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (realloc, void *,
+_GL_FUNCDECL_SYS (realloc, void *,
(void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (realloc, void *,
+_GL_FUNCDECL_SYS (realloc, void *,
(void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD);
# endif
&& (__GNUC__ >= 11 && !defined __clang__) && !defined realloc
/* For -Wmismatched-dealloc: Associate realloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
-_GL_FUNCATTR_SYS (realloc, void *,
+_GL_FUNCDECL_SYS (realloc, void *,
(void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (realloc, void *,
+_GL_FUNCDECL_SYS (realloc, void *,
(void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# undef reallocarray
# define reallocarray rpl_reallocarray
# endif
-_GL_FUNCATTR_RPL (reallocarray, void *,
+_GL_FUNCDECL_RPL (reallocarray, void *,
(void *ptr, size_t nmemb, size_t size),
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (reallocarray, void *,
(void *ptr, size_t nmemb, size_t size));
# else
# if ! @HAVE_REALLOCARRAY@
-_GL_FUNCATTR_SYS (reallocarray, void *,
+_GL_FUNCDECL_SYS (reallocarray, void *,
(void *ptr, size_t nmemb, size_t size),
_GL_ATTRIBUTE_NODISCARD);
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define realpath rpl_realpath
# endif
-_GL_FUNCATTR_RPL (realpath, char *,
+_GL_FUNCDECL_RPL (realpath, char *,
(const char *restrict name, char *restrict resolved),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (realpath, char *,
(const char *restrict name, char *restrict resolved));
# else
# if !@HAVE_REALPATH@
-_GL_FUNCATTR_SYS (realpath, char *,
+_GL_FUNCDECL_SYS (realpath, char *,
(const char *restrict name, char *restrict resolved),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
/* Test a user response to a question.
Return 1 if it is affirmative, 0 if it is negative, or -1 if not clear. */
# if !@HAVE_RPMATCH@
-_GL_FUNCATTR_SYS (rpmatch, int, (const char *response),
+_GL_FUNCDECL_SYS (rpmatch, int, (const char *response),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (rpmatch, int, (const char *response));
#if @GNULIB_SECURE_GETENV@
/* Look up NAME in the environment, returning 0 in insecure situations. */
# if !@HAVE_SECURE_GETENV@
-_GL_FUNCATTR_SYS (secure_getenv, char *,
+_GL_FUNCDECL_SYS (secure_getenv, char *,
(char const *name),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef setenv
# define setenv rpl_setenv
# endif
-_GL_FUNCATTR_RPL (setenv, int,
+_GL_FUNCDECL_RPL (setenv, int,
(const char *name, const char *value, int replace),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (setenv, int,
(const char *name, const char *value, int replace));
# else
# if !@HAVE_DECL_SETENV@
-_GL_FUNCATTR_SYS (setenv, int,
+_GL_FUNCDECL_SYS (setenv, int,
(const char *name, const char *value, int replace),
_GL_ARG_NONNULL ((1)));
# endif
# define strtod rpl_strtod
# endif
# define GNULIB_defined_strtod_function 1
-_GL_FUNCATTR_RPL (strtod, double,
+_GL_FUNCDECL_RPL (strtod, double,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtod, double,
(const char *restrict str, char **restrict endp));
# else
# if !@HAVE_STRTOD@
-_GL_FUNCATTR_SYS (strtod, double,
+_GL_FUNCDECL_SYS (strtod, double,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
# define strtof rpl_strtof
# endif
# define GNULIB_defined_strtof_function 1
-_GL_FUNCATTR_RPL (strtof, float,
+_GL_FUNCDECL_RPL (strtof, float,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtof, float,
(const char *restrict str, char **restrict endp));
# else
# if !@HAVE_STRTOF@
-_GL_FUNCATTR_SYS (strtof, float,
+_GL_FUNCDECL_SYS (strtof, float,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
# define strtold rpl_strtold
# endif
# define GNULIB_defined_strtold_function 1
-_GL_FUNCATTR_RPL (strtold, long double,
+_GL_FUNCDECL_RPL (strtold, long double,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtold, long double,
(const char *restrict str, char **restrict endp));
# else
# if !@HAVE_STRTOLD@
-_GL_FUNCATTR_SYS (strtold, long double,
+_GL_FUNCDECL_SYS (strtold, long double,
(const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
# define strtol rpl_strtol
# endif
# define GNULIB_defined_strtol_function 1
-_GL_FUNCATTR_RPL (strtol, long,
+_GL_FUNCDECL_RPL (strtol, long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
int base));
# else
# if !@HAVE_STRTOL@
-_GL_FUNCATTR_SYS (strtol, long,
+_GL_FUNCDECL_SYS (strtol, long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
# define strtoll rpl_strtoll
# endif
# define GNULIB_defined_strtoll_function 1
-_GL_FUNCATTR_RPL (strtoll, long long,
+_GL_FUNCDECL_RPL (strtoll, long long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
int base));
# else
# if !@HAVE_STRTOLL@
-_GL_FUNCATTR_SYS (strtoll, long long,
+_GL_FUNCDECL_SYS (strtoll, long long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
# define strtoul rpl_strtoul
# endif
# define GNULIB_defined_strtoul_function 1
-_GL_FUNCATTR_RPL (strtoul, unsigned long,
+_GL_FUNCDECL_RPL (strtoul, unsigned long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
int base));
# else
# if !@HAVE_STRTOUL@
-_GL_FUNCATTR_SYS (strtoul, unsigned long,
+_GL_FUNCDECL_SYS (strtoul, unsigned long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
# define strtoull rpl_strtoull
# endif
# define GNULIB_defined_strtoull_function 1
-_GL_FUNCATTR_RPL (strtoull, unsigned long long,
+_GL_FUNCDECL_RPL (strtoull, unsigned long long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
int base));
# else
# if !@HAVE_STRTOULL@
-_GL_FUNCATTR_SYS (strtoull, unsigned long long,
+_GL_FUNCDECL_SYS (strtoull, unsigned long long,
(const char *restrict string, char **restrict endptr,
int base),
_GL_ARG_NONNULL ((1)));
/* Unlock the slave side of the pseudo-terminal whose master side is specified
by FD, so that it can be opened. */
# if !@HAVE_UNLOCKPT@
-_GL_FUNCDECL_SYS (unlockpt, int, (int fd));
+_GL_FUNCDECL_SYS (unlockpt, int, (int fd), );
# endif
_GL_CXXALIAS_SYS (unlockpt, int, (int fd));
_GL_CXXALIASWARN (unlockpt);
# undef unsetenv
# define unsetenv rpl_unsetenv
# endif
-_GL_FUNCATTR_RPL (unsetenv, int, (const char *name), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (unsetenv, int, (const char *name), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (unsetenv, int, (const char *name));
# else
# if !@HAVE_DECL_UNSETENV@
-_GL_FUNCATTR_SYS (unsetenv, int, (const char *name), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (unsetenv, int, (const char *name), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (unsetenv, int, (const char *name));
# endif
# undef wctomb
# define wctomb rpl_wctomb
# endif
-_GL_FUNCDECL_RPL (wctomb, int, (char *s, wchar_t wc));
+_GL_FUNCDECL_RPL (wctomb, int, (char *s, wchar_t wc), );
_GL_CXXALIAS_RPL (wctomb, int, (char *s, wchar_t wc));
# else
_GL_CXXALIAS_SYS (wctomb, int, (char *s, wchar_t wc));
this function, even if the block is dead after the call. */
#if @GNULIB_EXPLICIT_BZERO@
# if ! @HAVE_EXPLICIT_BZERO@
-_GL_FUNCATTR_SYS (explicit_bzero, void,
+_GL_FUNCDECL_SYS (explicit_bzero, void,
(void *__dest, size_t __n), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (explicit_bzero, void, (void *__dest, size_t __n));
/* Find the index of the least-significant set bit. */
#if @GNULIB_FFSL@
# if !@HAVE_FFSL@
-_GL_FUNCDECL_SYS (ffsl, int, (long int i));
+_GL_FUNCDECL_SYS (ffsl, int, (long int i), );
# endif
_GL_CXXALIAS_SYS (ffsl, int, (long int i));
_GL_CXXALIASWARN (ffsl);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define ffsll rpl_ffsll
# endif
-_GL_FUNCDECL_RPL (ffsll, int, (long long int i));
+_GL_FUNCDECL_RPL (ffsll, int, (long long int i), );
_GL_CXXALIAS_RPL (ffsll, int, (long long int i));
# else
# if !@HAVE_FFSLL@
-_GL_FUNCDECL_SYS (ffsll, int, (long long int i));
+_GL_FUNCDECL_SYS (ffsll, int, (long long int i), );
# endif
_GL_CXXALIAS_SYS (ffsll, int, (long long int i));
# endif
# undef memchr
# define memchr rpl_memchr
# endif
-_GL_FUNCATTR_RPL (memchr, void *, (void const *__s, int __c, size_t __n),
+_GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define memmem rpl_memmem
# endif
-_GL_FUNCATTR_RPL (memmem, void *,
+_GL_FUNCDECL_RPL (memmem, void *,
(void const *__haystack, size_t __haystack_len,
void const *__needle, size_t __needle_len),
_GL_ATTRIBUTE_PURE
void const *__needle, size_t __needle_len));
# else
# if ! @HAVE_DECL_MEMMEM@
-_GL_FUNCATTR_SYS (memmem, void *,
+_GL_FUNCDECL_SYS (memmem, void *,
(void const *__haystack, size_t __haystack_len,
void const *__needle, size_t __needle_len),
_GL_ATTRIBUTE_PURE
# undef mempcpy
# define mempcpy rpl_mempcpy
# endif
-_GL_FUNCATTR_RPL (mempcpy, void *,
+_GL_FUNCDECL_RPL (mempcpy, void *,
(void *restrict __dest, void const *restrict __src,
size_t __n),
_GL_ARG_NONNULL ((1, 2)));
size_t __n));
# else
# if !@HAVE_MEMPCPY@
-_GL_FUNCATTR_SYS (mempcpy, void *,
+_GL_FUNCDECL_SYS (mempcpy, void *,
(void *restrict __dest, void const *restrict __src,
size_t __n),
_GL_ARG_NONNULL ((1, 2)));
/* Search backwards through a block for a byte (specified as an int). */
#if @GNULIB_MEMRCHR@
# if ! @HAVE_DECL_MEMRCHR@
-_GL_FUNCATTR_SYS (memrchr, void *, (void const *, int, size_t),
+_GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
# endif
# undef memset_explicit
# define memset_explicit rpl_memset_explicit
# endif
-_GL_FUNCATTR_RPL (memset_explicit, void *,
+_GL_FUNCDECL_RPL (memset_explicit, void *,
(void *__dest, int __c, size_t __n), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (memset_explicit, void *, (void *__dest, int __c, size_t __n));
# else
# if !@HAVE_MEMSET_EXPLICIT@
-_GL_FUNCATTR_SYS (memset_explicit, void *,
+_GL_FUNCDECL_SYS (memset_explicit, void *,
(void *__dest, int __c, size_t __n), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (memset_explicit, void *, (void *__dest, int __c, size_t __n));
occur within N bytes. */
#if @GNULIB_RAWMEMCHR@
# if ! @HAVE_RAWMEMCHR@
-_GL_FUNCATTR_SYS (rawmemchr, void *, (void const *__s, int __c_in),
+_GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
# endif
# undef stpcpy
# define stpcpy rpl_stpcpy
# endif
-_GL_FUNCATTR_RPL (stpcpy, char *,
+_GL_FUNCDECL_RPL (stpcpy, char *,
(char *restrict __dst, char const *restrict __src),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (stpcpy, char *,
(char *restrict __dst, char const *restrict __src));
# else
# if !@HAVE_STPCPY@
-_GL_FUNCATTR_SYS (stpcpy, char *,
+_GL_FUNCDECL_SYS (stpcpy, char *,
(char *restrict __dst, char const *restrict __src),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef stpncpy
# define stpncpy rpl_stpncpy
# endif
-_GL_FUNCATTR_RPL (stpncpy, char *,
+_GL_FUNCDECL_RPL (stpncpy, char *,
(char *restrict __dst, char const *restrict __src,
size_t __n),
_GL_ARG_NONNULL ((1, 2)));
size_t __n));
# else
# if ! @HAVE_STPNCPY@
-_GL_FUNCATTR_SYS (stpncpy, char *,
+_GL_FUNCDECL_SYS (stpncpy, char *,
(char *restrict __dst, char const *restrict __src,
size_t __n),
_GL_ARG_NONNULL ((1, 2)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strchrnul rpl_strchrnul
# endif
-_GL_FUNCATTR_RPL (strchrnul, char *, (const char *__s, int __c_in),
+_GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strchrnul, char *,
(const char *str, int ch));
# else
# if ! @HAVE_STRCHRNUL@
-_GL_FUNCATTR_SYS (strchrnul, char *, (char const *__s, int __c_in),
+_GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
# endif
# undef strdup
# define strdup rpl_strdup
# endif
-_GL_FUNCATTR_RPL (strdup, char *,
+_GL_FUNCDECL_RPL (strdup, char *,
(char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# if (!@HAVE_DECL_STRDUP@ || (__GNUC__ >= 11 && !defined __clang__)) \
&& !defined strdup
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (strdup, char *,
+_GL_FUNCDECL_SYS (strdup, char *,
(char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (strdup, char *,
+_GL_FUNCDECL_SYS (strdup, char *,
(char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# if (__GNUC__ >= 11 && !defined __clang__) && !defined strdup
/* For -Wmismatched-dealloc: Associate strdup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (strdup, char *,
+_GL_FUNCDECL_SYS (strdup, char *,
(char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (strdup, char *,
+_GL_FUNCDECL_SYS (strdup, char *,
(char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# undef strncat
# define strncat rpl_strncat
# endif
-_GL_FUNCATTR_RPL (strncat, char *,
+_GL_FUNCDECL_RPL (strncat, char *,
(char *restrict dest, const char *restrict src, size_t n),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (strncat, char *,
# undef strndup
# define strndup rpl_strndup
# endif
-_GL_FUNCATTR_RPL (strndup, char *,
+_GL_FUNCDECL_RPL (strndup, char *,
(char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# if !@HAVE_DECL_STRNDUP@ \
|| ((__GNUC__ >= 11 && !defined __clang__) && !defined strndup)
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (strndup, char *,
+_GL_FUNCDECL_SYS (strndup, char *,
(char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (strndup, char *,
+_GL_FUNCDECL_SYS (strndup, char *,
(char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# if (__GNUC__ >= 11 && !defined __clang__) && !defined strndup
/* For -Wmismatched-dealloc: Associate strndup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (strndup, char *,
+_GL_FUNCDECL_SYS (strndup, char *,
(char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (strndup, char *,
+_GL_FUNCDECL_SYS (strndup, char *,
(char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# undef strnlen
# define strnlen rpl_strnlen
# endif
-_GL_FUNCATTR_RPL (strnlen, size_t, (char const *__s, size_t __maxlen),
+_GL_FUNCDECL_RPL (strnlen, size_t, (char const *__s, size_t __maxlen),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strnlen, size_t, (char const *__s, size_t __maxlen));
# else
# if ! @HAVE_DECL_STRNLEN@
-_GL_FUNCATTR_SYS (strnlen, size_t, (char const *__s, size_t __maxlen),
+_GL_FUNCDECL_SYS (strnlen, size_t, (char const *__s, size_t __maxlen),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
# endif
/* Find the first occurrence in S of any character in ACCEPT. */
#if @GNULIB_STRPBRK@
# if ! @HAVE_STRPBRK@
-_GL_FUNCATTR_SYS (strpbrk, char *, (char const *__s, char const *__accept),
+_GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# endif
See also strtok_r(). */
#if @GNULIB_STRSEP@
# if ! @HAVE_STRSEP@
-_GL_FUNCATTR_SYS (strsep, char *,
+_GL_FUNCDECL_SYS (strsep, char *,
(char **restrict __stringp, char const *restrict __delim),
_GL_ARG_NONNULL ((1, 2)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strstr rpl_strstr
# endif
-_GL_FUNCATTR_RPL (strstr, char *, (const char *haystack, const char *needle),
+_GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strcasestr rpl_strcasestr
# endif
-_GL_FUNCATTR_RPL (strcasestr, char *,
+_GL_FUNCDECL_RPL (strcasestr, char *,
(const char *haystack, const char *needle),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
(const char *haystack, const char *needle));
# else
# if ! @HAVE_STRCASESTR@
-_GL_FUNCATTR_SYS (strcasestr, char *,
+_GL_FUNCDECL_SYS (strcasestr, char *,
(const char *haystack, const char *needle),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# undef strtok_r
# define strtok_r rpl_strtok_r
# endif
-_GL_FUNCATTR_RPL (strtok_r, char *,
+_GL_FUNCDECL_RPL (strtok_r, char *,
(char *restrict s, char const *restrict delim,
char **restrict save_ptr),
_GL_ARG_NONNULL ((2, 3)));
# undef strtok_r
# endif
# if ! @HAVE_DECL_STRTOK_R@
-_GL_FUNCATTR_SYS (strtok_r, char *,
+_GL_FUNCDECL_SYS (strtok_r, char *,
(char *restrict s, char const *restrict delim,
char **restrict save_ptr),
_GL_ARG_NONNULL ((2, 3)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mbslen rpl_mbslen
# endif
-_GL_FUNCATTR_RPL (mbslen, size_t, (const char *string),
+_GL_FUNCDECL_RPL (mbslen, size_t, (const char *string),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
# else
-_GL_FUNCATTR_SYS (mbslen, size_t, (const char *string),
+_GL_FUNCDECL_SYS (mbslen, size_t, (const char *string),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mbschr rpl_mbschr /* avoid collision with HP-UX function */
# endif
-_GL_FUNCATTR_RPL (mbschr, char *, (const char *string, int c),
+_GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
# else
-_GL_FUNCATTR_SYS (mbschr, char *, (const char *string, int c),
+_GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mbsrchr rpl_mbsrchr /* avoid collision with system function */
# endif
-_GL_FUNCATTR_RPL (mbsrchr, char *, (const char *string, int c),
+_GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
# else
-_GL_FUNCATTR_SYS (mbsrchr, char *, (const char *string, int c),
+_GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
# endif
-_GL_FUNCATTR_RPL (mbspbrk, char *, (const char *string, const char *accept),
+_GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
# else
-_GL_FUNCATTR_SYS (mbspbrk, char *, (const char *string, const char *accept),
+_GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
# undef strerror
# define strerror rpl_strerror
# endif
-_GL_FUNCDECL_RPL (strerror, char *, (int));
+_GL_FUNCDECL_RPL (strerror, char *, (int), );
_GL_CXXALIAS_RPL (strerror, char *, (int));
# else
_GL_CXXALIAS_SYS (strerror, char *, (int));
# undef strerror_r
# define strerror_r rpl_strerror_r
# endif
-_GL_FUNCATTR_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen),
+_GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
# else
# if !@HAVE_DECL_STRERROR_R@
-_GL_FUNCATTR_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen),
+_GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
# undef strerrorname_np
# define strerrorname_np rpl_strerrorname_np
# endif
-_GL_FUNCDECL_RPL (strerrorname_np, const char *, (int errnum));
+_GL_FUNCDECL_RPL (strerrorname_np, const char *, (int errnum), );
_GL_CXXALIAS_RPL (strerrorname_np, const char *, (int errnum));
# else
# if !@HAVE_STRERRORNAME_NP@
-_GL_FUNCDECL_SYS (strerrorname_np, const char *, (int errnum));
+_GL_FUNCDECL_SYS (strerrorname_np, const char *, (int errnum), );
# endif
_GL_CXXALIAS_SYS (strerrorname_np, const char *, (int errnum));
# endif
/* Return an abbreviation string for the signal number SIG. */
#if @GNULIB_SIGABBREV_NP@
# if ! @HAVE_SIGABBREV_NP@
-_GL_FUNCDECL_SYS (sigabbrev_np, const char *, (int sig));
+_GL_FUNCDECL_SYS (sigabbrev_np, const char *, (int sig), );
# endif
_GL_CXXALIAS_SYS (sigabbrev_np, const char *, (int sig));
_GL_CXXALIASWARN (sigabbrev_np);
/* Return an English description string for the signal number SIG. */
#if @GNULIB_SIGDESCR_NP@
# if ! @HAVE_SIGDESCR_NP@
-_GL_FUNCDECL_SYS (sigdescr_np, const char *, (int sig));
+_GL_FUNCDECL_SYS (sigdescr_np, const char *, (int sig), );
# endif
_GL_CXXALIAS_SYS (sigdescr_np, const char *, (int sig));
_GL_CXXALIASWARN (sigdescr_np);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strsignal rpl_strsignal
# endif
-_GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
+_GL_FUNCDECL_RPL (strsignal, char *, (int __sig), );
_GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
# else
# if ! @HAVE_DECL_STRSIGNAL@
-_GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
+_GL_FUNCDECL_SYS (strsignal, char *, (int __sig), );
# endif
/* Need to cast, because on Cygwin 1.5.x systems, the return type is
'const char *'. */
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strverscmp rpl_strverscmp
# endif
-_GL_FUNCATTR_RPL (strverscmp, int, (const char *, const char *),
+_GL_FUNCDECL_RPL (strverscmp, int, (const char *, const char *),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (strverscmp, int, (const char *, const char *));
# else
# if !@HAVE_STRVERSCMP@
-_GL_FUNCATTR_SYS (strverscmp, int, (const char *, const char *),
+_GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# endif
/* Find the index of the least-significant set bit. */
#if @GNULIB_FFS@
# if !@HAVE_FFS@
-_GL_FUNCDECL_SYS (ffs, int, (int i));
+_GL_FUNCDECL_SYS (ffs, int, (int i), );
# endif
_GL_CXXALIAS_SYS (ffs, int, (int i));
_GL_CXXALIASWARN (ffs);
# define ioctl rpl_ioctl
# endif
_GL_FUNCDECL_RPL (ioctl, int,
- (int fd, int request, ... /* {void *,char *} arg */));
+ (int fd, int request, ... /* {void *,char *} arg */), );
_GL_CXXALIAS_RPL (ioctl, int,
(int fd, int request, ... /* {void *,char *} arg */));
# else
# if @SYS_IOCTL_H_HAVE_WINSOCK2_H@ || 1
_GL_FUNCDECL_SYS (ioctl, int,
- (int fd, int request, ... /* {void *,char *} arg */));
+ (int fd, int request, ... /* {void *,char *} arg */), );
# endif
_GL_CXXALIAS_SYS (ioctl, int,
(int fd, int request, ... /* {void *,char *} arg */));
# undef getrandom
# define getrandom rpl_getrandom
# endif
-_GL_FUNCATTR_RPL (getrandom, ssize_t,
+_GL_FUNCDECL_RPL (getrandom, ssize_t,
(void *buffer, size_t length, unsigned int flags),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getrandom, ssize_t,
(void *buffer, size_t length, unsigned int flags));
# else
# if !@HAVE_GETRANDOM@
-_GL_FUNCATTR_SYS (getrandom, ssize_t,
+_GL_FUNCDECL_SYS (getrandom, ssize_t,
(void *buffer, size_t length, unsigned int flags),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
#if @GNULIB_GETRUSAGE@
# if !@HAVE_GETRUSAGE@
-_GL_FUNCATTR_SYS (getrusage, int, (int who, struct rusage *usage_p),
+_GL_FUNCDECL_SYS (getrusage, int, (int who, struct rusage *usage_p),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (getrusage, int, (int who, struct rusage *usage_p));
# endif
_GL_FUNCDECL_RPL (pselect, int,
(int, fd_set *restrict, fd_set *restrict, fd_set *restrict,
- struct timespec const *restrict, const sigset_t *restrict));
+ struct timespec const *restrict, const sigset_t *restrict), );
_GL_CXXALIAS_RPL (pselect, int,
(int, fd_set *restrict, fd_set *restrict, fd_set *restrict,
struct timespec const *restrict, const sigset_t *restrict));
# if !@HAVE_PSELECT@
_GL_FUNCDECL_SYS (pselect, int,
(int, fd_set *restrict, fd_set *restrict, fd_set *restrict,
- struct timespec const *restrict, const sigset_t *restrict));
+ struct timespec const *restrict, const sigset_t *restrict), );
# endif
/* Need to cast, because on AIX 7, the second, third, fourth argument may be
void *restrict, void *restrict, void *restrict. */
# endif
_GL_FUNCDECL_RPL (select, int,
(int, fd_set *restrict, fd_set *restrict, fd_set *restrict,
- struct timeval *restrict));
+ struct timeval *restrict), );
_GL_CXXALIAS_RPL (select, int,
(int, fd_set *restrict, fd_set *restrict, fd_set *restrict,
timeval *restrict));
# undef socket
# define socket rpl_socket
# endif
-_GL_FUNCDECL_RPL (socket, int, (int domain, int type, int protocol));
+_GL_FUNCDECL_RPL (socket, int, (int domain, int type, int protocol), );
_GL_CXXALIAS_RPL (socket, int, (int domain, int type, int protocol));
# else
_GL_CXXALIAS_SYS (socket, int, (int domain, int type, int protocol));
# undef connect
# define connect rpl_connect
# endif
-_GL_FUNCATTR_RPL (connect, int,
+_GL_FUNCDECL_RPL (connect, int,
(int fd, const struct sockaddr *addr, socklen_t addrlen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (connect, int,
_GL_FUNCDECL_RPL (accept, int,
(int fd,
struct sockaddr *restrict addr,
- socklen_t *restrict addrlen));
+ socklen_t *restrict addrlen), );
_GL_CXXALIAS_RPL (accept, int,
(int fd,
struct sockaddr *restrict addr,
# undef bind
# define bind rpl_bind
# endif
-_GL_FUNCATTR_RPL (bind, int,
+_GL_FUNCDECL_RPL (bind, int,
(int fd, const struct sockaddr *addr, socklen_t addrlen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (bind, int,
# undef getpeername
# define getpeername rpl_getpeername
# endif
-_GL_FUNCATTR_RPL (getpeername, int,
+_GL_FUNCDECL_RPL (getpeername, int,
(int fd, struct sockaddr *restrict addr,
socklen_t *restrict addrlen),
_GL_ARG_NONNULL ((2, 3)));
# undef getsockname
# define getsockname rpl_getsockname
# endif
-_GL_FUNCATTR_RPL (getsockname, int,
+_GL_FUNCDECL_RPL (getsockname, int,
(int fd, struct sockaddr *restrict addr,
socklen_t *restrict addrlen),
_GL_ARG_NONNULL ((2, 3)));
# undef getsockopt
# define getsockopt rpl_getsockopt
# endif
-_GL_FUNCATTR_RPL (getsockopt, int,
+_GL_FUNCDECL_RPL (getsockopt, int,
(int fd, int level, int optname,
void *restrict optval, socklen_t *restrict optlen),
_GL_ARG_NONNULL ((4, 5)));
# undef listen
# define listen rpl_listen
# endif
-_GL_FUNCDECL_RPL (listen, int, (int fd, int backlog));
+_GL_FUNCDECL_RPL (listen, int, (int fd, int backlog), );
_GL_CXXALIAS_RPL (listen, int, (int fd, int backlog));
# else
_GL_CXXALIAS_SYS (listen, int, (int fd, int backlog));
# undef recv
# define recv rpl_recv
# endif
-_GL_FUNCATTR_RPL (recv, ssize_t, (int fd, void *buf, size_t len, int flags),
+_GL_FUNCDECL_RPL (recv, ssize_t, (int fd, void *buf, size_t len, int flags),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (recv, ssize_t, (int fd, void *buf, size_t len, int flags));
# else
# undef send
# define send rpl_send
# endif
-_GL_FUNCATTR_RPL (send, ssize_t,
+_GL_FUNCDECL_RPL (send, ssize_t,
(int fd, const void *buf, size_t len, int flags),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (send, ssize_t,
# undef recvfrom
# define recvfrom rpl_recvfrom
# endif
-_GL_FUNCATTR_RPL (recvfrom, ssize_t,
+_GL_FUNCDECL_RPL (recvfrom, ssize_t,
(int fd, void *restrict buf, size_t len, int flags,
struct sockaddr *restrict from,
socklen_t *restrict fromlen),
# undef sendto
# define sendto rpl_sendto
# endif
-_GL_FUNCATTR_RPL (sendto, ssize_t,
+_GL_FUNCDECL_RPL (sendto, ssize_t,
(int fd, const void *buf, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen),
_GL_ARG_NONNULL ((2)));
# undef setsockopt
# define setsockopt rpl_setsockopt
# endif
-_GL_FUNCATTR_RPL (setsockopt, int, (int fd, int level, int optname,
+_GL_FUNCDECL_RPL (setsockopt, int, (int fd, int level, int optname,
const void * optval, socklen_t optlen),
_GL_ARG_NONNULL ((4)));
_GL_CXXALIAS_RPL (setsockopt, int, (int fd, int level, int optname,
# undef shutdown
# define shutdown rpl_shutdown
# endif
-_GL_FUNCDECL_RPL (shutdown, int, (int fd, int how));
+_GL_FUNCDECL_RPL (shutdown, int, (int fd, int how), );
_GL_CXXALIAS_RPL (shutdown, int, (int fd, int how));
# else
_GL_CXXALIAS_SYS (shutdown, int, (int fd, int how));
# endif
_GL_FUNCDECL_RPL (accept4, int,
(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
- int flags));
+ int flags), );
_GL_CXXALIAS_RPL (accept4, int,
(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
int flags));
# else
_GL_FUNCDECL_SYS (accept4, int,
(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
- int flags));
+ int flags), );
_GL_CXXALIAS_SYS (accept4, int,
(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
int flags));
# undef chmod
# define chmod rpl_chmod
# endif
-_GL_FUNCATTR_RPL (chmod, int, (const char *filename, mode_t mode),
+_GL_FUNCDECL_RPL (chmod, int, (const char *filename, mode_t mode),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (chmod, int, (const char *filename, mode_t mode));
# elif defined _WIN32 && !defined __CYGWIN__
# undef fchmodat
# define fchmodat rpl_fchmodat
# endif
-_GL_FUNCATTR_RPL (fchmodat, int,
+_GL_FUNCDECL_RPL (fchmodat, int,
(int fd, char const *file, mode_t mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fchmodat, int,
(int fd, char const *file, mode_t mode, int flag));
# else
# if !@HAVE_FCHMODAT@
-_GL_FUNCATTR_SYS (fchmodat, int,
+_GL_FUNCDECL_SYS (fchmodat, int,
(int fd, char const *file, mode_t mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef fstat
# define fstat rpl_fstat
# endif
-_GL_FUNCATTR_RPL (fstat, int, (int fd, struct stat *buf),
+_GL_FUNCDECL_RPL (fstat, int, (int fd, struct stat *buf),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (fstat, int, (int fd, struct stat *buf));
# else
# undef fstatat
# define fstatat rpl_fstatat
# endif
-_GL_FUNCATTR_RPL (fstatat, int,
+_GL_FUNCDECL_RPL (fstatat, int,
(int fd, char const *restrict name, struct stat *restrict st,
int flags),
_GL_ARG_NONNULL ((2, 3)));
int flags));
# else
# if !@HAVE_FSTATAT@
-_GL_FUNCATTR_SYS (fstatat, int,
+_GL_FUNCDECL_SYS (fstatat, int,
(int fd, char const *restrict name, struct stat *restrict st,
int flags),
_GL_ARG_NONNULL ((2, 3)));
# undef futimens
# define futimens rpl_futimens
# endif
-_GL_FUNCDECL_RPL (futimens, int, (int fd, struct timespec const times[2]));
+_GL_FUNCDECL_RPL (futimens, int, (int fd, struct timespec const times[2]), );
_GL_CXXALIAS_RPL (futimens, int, (int fd, struct timespec const times[2]));
# else
# if !@HAVE_FUTIMENS@
-_GL_FUNCDECL_SYS (futimens, int, (int fd, struct timespec const times[2]));
+_GL_FUNCDECL_SYS (futimens, int, (int fd, struct timespec const times[2]), );
# endif
_GL_CXXALIAS_SYS (futimens, int, (int fd, struct timespec const times[2]));
# endif
#if @GNULIB_GETUMASK@
# if !@HAVE_GETUMASK@
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCDECL_SYS (getumask, mode_t, (void)) _GL_ATTRIBUTE_NOTHROW;
+_GL_FUNCDECL_SYS (getumask, mode_t, (void), ) _GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCDECL_SYS (getumask, mode_t, (void));
+_GL_FUNCDECL_SYS (getumask, mode_t, (void), );
# endif
# endif
_GL_CXXALIAS_SYS (getumask, mode_t, (void));
/* Change the mode of FILENAME to MODE, without dereferencing it if FILENAME
denotes a symbolic link. */
# if !@HAVE_LCHMOD@ || defined __hpux
-_GL_FUNCATTR_SYS (lchmod, int, (const char *filename, mode_t mode),
+_GL_FUNCDECL_SYS (lchmod, int, (const char *filename, mode_t mode),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (lchmod, int, (const char *filename, mode_t mode));
# undef mkdir
# define mkdir rpl_mkdir
# endif
-_GL_FUNCATTR_RPL (mkdir, int, (char const *name, mode_t mode),
+_GL_FUNCDECL_RPL (mkdir, int, (char const *name, mode_t mode),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mkdir, int, (char const *name, mode_t mode));
# elif defined _WIN32 && !defined __CYGWIN__
#if @GNULIB_MKDIRAT@
# if !@HAVE_MKDIRAT@
-_GL_FUNCATTR_SYS (mkdirat, int, (int fd, char const *file, mode_t mode),
+_GL_FUNCDECL_SYS (mkdirat, int, (int fd, char const *file, mode_t mode),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mkdirat, int, (int fd, char const *file, mode_t mode));
# undef mkfifo
# define mkfifo rpl_mkfifo
# endif
-_GL_FUNCATTR_RPL (mkfifo, int, (char const *file, mode_t mode),
+_GL_FUNCDECL_RPL (mkfifo, int, (char const *file, mode_t mode),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mkfifo, int, (char const *file, mode_t mode));
# else
# if !@HAVE_MKFIFO@
-_GL_FUNCATTR_SYS (mkfifo, int, (char const *file, mode_t mode),
+_GL_FUNCDECL_SYS (mkfifo, int, (char const *file, mode_t mode),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mkfifo, int, (char const *file, mode_t mode));
# undef mkfifoat
# define mkfifoat rpl_mkfifoat
# endif
-_GL_FUNCATTR_RPL (mkfifoat, int, (int fd, char const *file, mode_t mode),
+_GL_FUNCDECL_RPL (mkfifoat, int, (int fd, char const *file, mode_t mode),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mkfifoat, int, (int fd, char const *file, mode_t mode));
# else
# if !@HAVE_MKFIFOAT@
-_GL_FUNCATTR_SYS (mkfifoat, int, (int fd, char const *file, mode_t mode),
+_GL_FUNCDECL_SYS (mkfifoat, int, (int fd, char const *file, mode_t mode),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mkfifoat, int, (int fd, char const *file, mode_t mode));
# undef mknod
# define mknod rpl_mknod
# endif
-_GL_FUNCATTR_RPL (mknod, int, (char const *file, mode_t mode, dev_t dev),
+_GL_FUNCDECL_RPL (mknod, int, (char const *file, mode_t mode, dev_t dev),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mknod, int, (char const *file, mode_t mode, dev_t dev));
# else
# if !@HAVE_MKNOD@
-_GL_FUNCATTR_SYS (mknod, int, (char const *file, mode_t mode, dev_t dev),
+_GL_FUNCDECL_SYS (mknod, int, (char const *file, mode_t mode, dev_t dev),
_GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on OSF/1 5.1, the third parameter is '...'. */
# undef mknodat
# define mknodat rpl_mknodat
# endif
-_GL_FUNCATTR_RPL (mknodat, int,
+_GL_FUNCDECL_RPL (mknodat, int,
(int fd, char const *file, mode_t mode, dev_t dev),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mknodat, int,
(int fd, char const *file, mode_t mode, dev_t dev));
# else
# if !@HAVE_MKNODAT@
-_GL_FUNCATTR_SYS (mknodat, int,
+_GL_FUNCDECL_SYS (mknodat, int,
(int fd, char const *file, mode_t mode, dev_t dev),
_GL_ARG_NONNULL ((2)));
# endif
# undef lstat
# define lstat rpl_lstat
# endif
-_GL_FUNCATTR_RPL (lstat, int,
+_GL_FUNCDECL_RPL (lstat, int,
(const char *restrict name, struct stat *restrict buf),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (lstat, int,
# undef utimensat
# define utimensat rpl_utimensat
# endif
-_GL_FUNCATTR_RPL (utimensat, int, (int fd, char const *name,
+_GL_FUNCDECL_RPL (utimensat, int, (int fd, char const *name,
struct timespec const times[2], int flag),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (utimensat, int, (int fd, char const *name,
struct timespec const times[2], int flag));
# else
# if !@HAVE_UTIMENSAT@
-_GL_FUNCATTR_SYS (utimensat, int, (int fd, char const *name,
+_GL_FUNCDECL_SYS (utimensat, int, (int fd, char const *name,
struct timespec const times[2], int flag),
_GL_ARG_NONNULL ((2)));
# endif
# undef gettimeofday
# define gettimeofday rpl_gettimeofday
# endif
-_GL_FUNCATTR_RPL (gettimeofday, int,
+_GL_FUNCDECL_RPL (gettimeofday, int,
(struct timeval *restrict, void *restrict),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (gettimeofday, int,
(struct timeval *restrict, void *restrict));
# else
# if !@HAVE_GETTIMEOFDAY@
-_GL_FUNCATTR_SYS (gettimeofday, int,
+_GL_FUNCDECL_SYS (gettimeofday, int,
(struct timeval *restrict, void *restrict),
_GL_ARG_NONNULL ((1)));
# endif
#if @GNULIB_WAITPID@
# if defined _WIN32 && ! defined __CYGWIN__
-_GL_FUNCDECL_SYS (waitpid, pid_t, (pid_t pid, int *statusp, int options));
+_GL_FUNCDECL_SYS (waitpid, pid_t, (pid_t pid, int *statusp, int options), );
# endif
/* Need to cast, because on Cygwin, the second parameter is
__wait_status_ptr_t statusp. */
Return -1, with errno set, upon failure. errno = ENOSYS means that the
function is unsupported. */
# if !@HAVE_DECL_TCGETSID@
-_GL_FUNCDECL_SYS (tcgetsid, pid_t, (int fd));
+_GL_FUNCDECL_SYS (tcgetsid, pid_t, (int fd), );
# endif
_GL_CXXALIAS_SYS (tcgetsid, pid_t, (int fd));
_GL_CXXALIASWARN (tcgetsid);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_create rpl_thrd_create
# endif
-_GL_FUNCATTR_RPL (thrd_create, int, (thrd_t *, thrd_start_t, void *),
+_GL_FUNCDECL_RPL (thrd_create, int, (thrd_t *, thrd_start_t, void *),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (thrd_create, int, (thrd_t *, thrd_start_t, void *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (thrd_create, int, (thrd_t *, thrd_start_t, void *),
+_GL_FUNCDECL_SYS (thrd_create, int, (thrd_t *, thrd_start_t, void *),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (thrd_create, int, (thrd_t *, thrd_start_t, void *));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_current rpl_thrd_current
# endif
-_GL_FUNCATTR_RPL (thrd_current, thrd_t, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (thrd_current, thrd_t, (void), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (thrd_current, thrd_t, (void));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (thrd_current, thrd_t, (void), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (thrd_current, thrd_t, (void), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (thrd_current, thrd_t, (void));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_equal rpl_thrd_equal
# endif
-_GL_FUNCATTR_RPL (thrd_equal, int, (thrd_t, thrd_t), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (thrd_equal, int, (thrd_t, thrd_t), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (thrd_equal, int, (thrd_t, thrd_t));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (thrd_equal, int, (thrd_t, thrd_t), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (thrd_equal, int, (thrd_t, thrd_t), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (thrd_equal, int, (thrd_t, thrd_t));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_sleep rpl_thrd_sleep
# endif
-_GL_FUNCATTR_RPL (thrd_sleep, int,
+_GL_FUNCDECL_RPL (thrd_sleep, int,
(const struct timespec *, struct timespec *),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (thrd_sleep, int,
(const struct timespec *, struct timespec *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (thrd_sleep, int,
+_GL_FUNCDECL_SYS (thrd_sleep, int,
(const struct timespec *, struct timespec *),
_GL_ARG_NONNULL ((1)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_yield rpl_thrd_yield
# endif
-_GL_FUNCDECL_RPL (thrd_yield, void, (void));
+_GL_FUNCDECL_RPL (thrd_yield, void, (void), );
_GL_CXXALIAS_RPL (thrd_yield, void, (void));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (thrd_yield, void, (void));
+_GL_FUNCDECL_SYS (thrd_yield, void, (void), );
# endif
_GL_CXXALIAS_SYS (thrd_yield, void, (void));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_detach rpl_thrd_detach
# endif
-_GL_FUNCDECL_RPL (thrd_detach, int, (thrd_t));
+_GL_FUNCDECL_RPL (thrd_detach, int, (thrd_t), );
_GL_CXXALIAS_RPL (thrd_detach, int, (thrd_t));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (thrd_detach, int, (thrd_t));
+_GL_FUNCDECL_SYS (thrd_detach, int, (thrd_t), );
# endif
_GL_CXXALIAS_SYS (thrd_detach, int, (thrd_t));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_join rpl_thrd_join
# endif
-_GL_FUNCDECL_RPL (thrd_join, int, (thrd_t, int *));
+_GL_FUNCDECL_RPL (thrd_join, int, (thrd_t, int *), );
_GL_CXXALIAS_RPL (thrd_join, int, (thrd_t, int *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (thrd_join, int, (thrd_t, int *));
+_GL_FUNCDECL_SYS (thrd_join, int, (thrd_t, int *), );
# endif
_GL_CXXALIAS_SYS (thrd_join, int, (thrd_t, int *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_exit rpl_thrd_exit
# endif
-_GL_FUNCDECL_RPL (thrd_exit, _Noreturn void, (int));
+_GL_FUNCDECL_RPL (thrd_exit, _Noreturn void, (int), );
_GL_CXXALIAS_RPL (thrd_exit, void, (int));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (thrd_exit, _Noreturn void, (int));
+_GL_FUNCDECL_SYS (thrd_exit, _Noreturn void, (int), );
# endif
/* Need to cast because of AIX with xlclang++. */
_GL_CXXALIAS_SYS_CAST (thrd_exit, void, (int));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_init rpl_mtx_init
# endif
-_GL_FUNCATTR_RPL (mtx_init, int, (mtx_t *, int), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mtx_init, int, (mtx_t *, int), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mtx_init, int, (mtx_t *, int));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_init, int, (mtx_t *, int), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (mtx_init, int, (mtx_t *, int), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mtx_init, int, (mtx_t *, int));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_lock rpl_mtx_lock
# endif
-_GL_FUNCATTR_RPL (mtx_lock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mtx_lock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mtx_lock, int, (mtx_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_lock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (mtx_lock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mtx_lock, int, (mtx_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_trylock rpl_mtx_trylock
# endif
-_GL_FUNCATTR_RPL (mtx_trylock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mtx_trylock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mtx_trylock, int, (mtx_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_trylock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (mtx_trylock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mtx_trylock, int, (mtx_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_timedlock rpl_mtx_timedlock
# endif
-_GL_FUNCATTR_RPL (mtx_timedlock, int, (mtx_t *, const struct timespec *),
+_GL_FUNCDECL_RPL (mtx_timedlock, int, (mtx_t *, const struct timespec *),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (mtx_timedlock, int, (mtx_t *, const struct timespec *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_timedlock, int, (mtx_t *, const struct timespec *),
+_GL_FUNCDECL_SYS (mtx_timedlock, int, (mtx_t *, const struct timespec *),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (mtx_timedlock, int, (mtx_t *, const struct timespec *));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_unlock rpl_mtx_unlock
# endif
-_GL_FUNCATTR_RPL (mtx_unlock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mtx_unlock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mtx_unlock, int, (mtx_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_unlock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (mtx_unlock, int, (mtx_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mtx_unlock, int, (mtx_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_destroy rpl_mtx_destroy
# endif
-_GL_FUNCATTR_RPL (mtx_destroy, void, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mtx_destroy, void, (mtx_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mtx_destroy, void, (mtx_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (mtx_destroy, void, (mtx_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (mtx_destroy, void, (mtx_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (mtx_destroy, void, (mtx_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define call_once rpl_call_once
# endif
-_GL_FUNCATTR_RPL (call_once, void, (once_flag *, void (*) (void)),
+_GL_FUNCDECL_RPL (call_once, void, (once_flag *, void (*) (void)),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (call_once, void, (once_flag *, void (*) (void)));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (call_once, void, (once_flag *, void (*) (void)),
+_GL_FUNCDECL_SYS (call_once, void, (once_flag *, void (*) (void)),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS_CAST (call_once, void, (once_flag *, void (*) (void)));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_init rpl_cnd_init
# endif
-_GL_FUNCATTR_RPL (cnd_init, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (cnd_init, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (cnd_init, int, (cnd_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_init, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (cnd_init, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (cnd_init, int, (cnd_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_wait rpl_cnd_wait
# endif
-_GL_FUNCATTR_RPL (cnd_wait, int, (cnd_t *, mtx_t *), _GL_ARG_NONNULL ((1, 2)));
+_GL_FUNCDECL_RPL (cnd_wait, int, (cnd_t *, mtx_t *), _GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (cnd_wait, int, (cnd_t *, mtx_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_wait, int, (cnd_t *, mtx_t *), _GL_ARG_NONNULL ((1, 2)));
+_GL_FUNCDECL_SYS (cnd_wait, int, (cnd_t *, mtx_t *), _GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (cnd_wait, int, (cnd_t *, mtx_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_timedwait rpl_cnd_timedwait
# endif
-_GL_FUNCATTR_RPL (cnd_timedwait, int,
+_GL_FUNCDECL_RPL (cnd_timedwait, int,
(cnd_t *, mtx_t *, const struct timespec *),
_GL_ARG_NONNULL ((1, 2, 3)));
_GL_CXXALIAS_RPL (cnd_timedwait, int,
(cnd_t *, mtx_t *, const struct timespec *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_timedwait, int,
+_GL_FUNCDECL_SYS (cnd_timedwait, int,
(cnd_t *, mtx_t *, const struct timespec *),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_signal rpl_cnd_signal
# endif
-_GL_FUNCATTR_RPL (cnd_signal, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (cnd_signal, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (cnd_signal, int, (cnd_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_signal, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (cnd_signal, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (cnd_signal, int, (cnd_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_broadcast rpl_cnd_broadcast
# endif
-_GL_FUNCATTR_RPL (cnd_broadcast, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (cnd_broadcast, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (cnd_broadcast, int, (cnd_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_broadcast, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (cnd_broadcast, int, (cnd_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (cnd_broadcast, int, (cnd_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_destroy rpl_cnd_destroy
# endif
-_GL_FUNCATTR_RPL (cnd_destroy, void, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (cnd_destroy, void, (cnd_t *), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (cnd_destroy, void, (cnd_t *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (cnd_destroy, void, (cnd_t *), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (cnd_destroy, void, (cnd_t *), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (cnd_destroy, void, (cnd_t *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tss_create rpl_tss_create
# endif
-_GL_FUNCATTR_RPL (tss_create, int, (tss_t *, tss_dtor_t),
+_GL_FUNCDECL_RPL (tss_create, int, (tss_t *, tss_dtor_t),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (tss_create, int, (tss_t *, tss_dtor_t));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCATTR_SYS (tss_create, int, (tss_t *, tss_dtor_t),
+_GL_FUNCDECL_SYS (tss_create, int, (tss_t *, tss_dtor_t),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (tss_create, int, (tss_t *, tss_dtor_t));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tss_set rpl_tss_set
# endif
-_GL_FUNCDECL_RPL (tss_set, int, (tss_t, void *));
+_GL_FUNCDECL_RPL (tss_set, int, (tss_t, void *), );
_GL_CXXALIAS_RPL (tss_set, int, (tss_t, void *));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (tss_set, int, (tss_t, void *));
+_GL_FUNCDECL_SYS (tss_set, int, (tss_t, void *), );
# endif
_GL_CXXALIAS_SYS (tss_set, int, (tss_t, void *));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tss_get rpl_tss_get
# endif
-_GL_FUNCDECL_RPL (tss_get, void *, (tss_t));
+_GL_FUNCDECL_RPL (tss_get, void *, (tss_t), );
_GL_CXXALIAS_RPL (tss_get, void *, (tss_t));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (tss_get, void *, (tss_t));
+_GL_FUNCDECL_SYS (tss_get, void *, (tss_t), );
# endif
_GL_CXXALIAS_SYS (tss_get, void *, (tss_t));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tss_delete rpl_tss_delete
# endif
-_GL_FUNCDECL_RPL (tss_delete, void, (tss_t));
+_GL_FUNCDECL_RPL (tss_delete, void, (tss_t), );
_GL_CXXALIAS_RPL (tss_delete, void, (tss_t));
# else
# if !@HAVE_THREADS_H@
-_GL_FUNCDECL_SYS (tss_delete, void, (tss_t));
+_GL_FUNCDECL_SYS (tss_delete, void, (tss_t), );
# endif
_GL_CXXALIAS_SYS (tss_delete, void, (tss_t));
# endif
# undef timespec_get
# define timespec_get rpl_timespec_get
# endif
-_GL_FUNCATTR_RPL (timespec_get, int, (struct timespec *ts, int base),
+_GL_FUNCDECL_RPL (timespec_get, int, (struct timespec *ts, int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (timespec_get, int, (struct timespec *ts, int base));
# else
# if !@HAVE_TIMESPEC_GET@
-_GL_FUNCATTR_SYS (timespec_get, int, (struct timespec *ts, int base),
+_GL_FUNCDECL_SYS (timespec_get, int, (struct timespec *ts, int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (timespec_get, int, (struct timespec *ts, int base));
# undef timespec_getres
# define timespec_getres rpl_timespec_getres
# endif
-_GL_FUNCATTR_RPL (timespec_getres, int, (struct timespec *ts, int base),
+_GL_FUNCDECL_RPL (timespec_getres, int, (struct timespec *ts, int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (timespec_getres, int, (struct timespec *ts, int base));
# else
# if !@HAVE_TIMESPEC_GETRES@
-_GL_FUNCATTR_SYS (timespec_getres, int, (struct timespec *ts, int base),
+_GL_FUNCDECL_SYS (timespec_getres, int, (struct timespec *ts, int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (timespec_getres, int, (struct timespec *ts, int base));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define time rpl_time
# endif
-_GL_FUNCDECL_RPL (time, time_t, (time_t *__tp));
+_GL_FUNCDECL_RPL (time, time_t, (time_t *__tp), );
_GL_CXXALIAS_RPL (time, time_t, (time_t *__tp));
# else
_GL_CXXALIAS_SYS (time, time_t, (time_t *__tp));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define nanosleep rpl_nanosleep
# endif
-_GL_FUNCATTR_RPL (nanosleep, int,
+_GL_FUNCDECL_RPL (nanosleep, int,
(struct timespec const *__rqtp, struct timespec *__rmtp),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (nanosleep, int,
(struct timespec const *__rqtp, struct timespec *__rmtp));
# else
# if ! @HAVE_NANOSLEEP@
-_GL_FUNCATTR_SYS (nanosleep, int,
+_GL_FUNCDECL_SYS (nanosleep, int,
(struct timespec const *__rqtp, struct timespec *__rmtp),
_GL_ARG_NONNULL ((1)));
# endif
# undef tzset
# define tzset rpl_tzset
# endif
-_GL_FUNCDECL_RPL (tzset, void, (void));
+_GL_FUNCDECL_RPL (tzset, void, (void), );
_GL_CXXALIAS_RPL (tzset, void, (void));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mktime rpl_mktime
# endif
-_GL_FUNCATTR_RPL (mktime, time_t, (struct tm *__tp), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (mktime, time_t, (struct tm *__tp), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (mktime, time_t, (struct tm *__tp));
# else
_GL_CXXALIAS_SYS (mktime, time_t, (struct tm *__tp));
# undef localtime_r
# define localtime_r rpl_localtime_r
# endif
-_GL_FUNCATTR_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
+_GL_FUNCDECL_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result));
# else
# if ! @HAVE_DECL_LOCALTIME_R@
-_GL_FUNCATTR_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
+_GL_FUNCDECL_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef gmtime_r
# define gmtime_r rpl_gmtime_r
# endif
-_GL_FUNCATTR_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
+_GL_FUNCDECL_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result));
# else
# if ! @HAVE_DECL_LOCALTIME_R@
-_GL_FUNCATTR_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
+_GL_FUNCDECL_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef localtime
# define localtime rpl_localtime
# endif
-_GL_FUNCATTR_RPL (localtime, struct tm *, (time_t const *__timer),
+_GL_FUNCDECL_RPL (localtime, struct tm *, (time_t const *__timer),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (localtime, struct tm *, (time_t const *__timer));
# else
# undef gmtime
# define gmtime rpl_gmtime
# endif
-_GL_FUNCATTR_RPL (gmtime, struct tm *, (time_t const *__timer),
+_GL_FUNCDECL_RPL (gmtime, struct tm *, (time_t const *__timer),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (gmtime, struct tm *, (time_t const *__timer));
# else
<https://pubs.opengroup.org/onlinepubs/9699919799/functions/strptime.html>. */
# if @GNULIB_STRPTIME@
# if ! @HAVE_STRPTIME@
-_GL_FUNCATTR_SYS (strptime, char *, (char const *restrict __buf,
+_GL_FUNCDECL_SYS (strptime, char *, (char const *restrict __buf,
char const *restrict __format,
struct tm *restrict __tm),
_GL_ARG_NONNULL ((1, 2, 3)));
# ifndef __cplusplus
_GL_ATTRIBUTE_DEPRECATED
# endif
-_GL_FUNCATTR_RPL (ctime, char *, (time_t const *__tp),
+_GL_FUNCDECL_RPL (ctime, char *, (time_t const *__tp),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (ctime, char *, (time_t const *__tp));
# else
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strftime rpl_strftime
# endif
-_GL_FUNCATTR_RPL (strftime, size_t,
+_GL_FUNCDECL_RPL (strftime, size_t,
(char *restrict __buf, size_t __bufsize,
const char *restrict __fmt, const struct tm *restrict __tp),
_GL_ARG_NONNULL ((1, 3, 4)));
May return NULL if NAME is invalid (this is platform dependent) or
upon memory allocation failure. */
# if !@HAVE_TZALLOC@
-_GL_FUNCDECL_SYS (tzalloc, timezone_t, (char const *__name));
+_GL_FUNCDECL_SYS (tzalloc, timezone_t, (char const *__name), );
_GL_CXXALIAS_SYS (tzalloc, timezone_t, (char const *__name));
# endif
Frees a time zone object.
The argument must have been returned by tzalloc(). */
# if !@HAVE_TZALLOC@
-_GL_FUNCDECL_SYS (tzfree, void, (timezone_t __tz));
+_GL_FUNCDECL_SYS (tzfree, void, (timezone_t __tz), );
_GL_CXXALIAS_SYS (tzfree, void, (timezone_t __tz));
# endif
# undef localtime_rz
# define localtime_rz rpl_localtime_rz
# endif
-_GL_FUNCATTR_RPL (localtime_rz, struct tm *,
+_GL_FUNCDECL_RPL (localtime_rz, struct tm *,
(timezone_t __tz, time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((2, 3)));
struct tm *restrict __result));
# else
# if !@HAVE_TZALLOC@
-_GL_FUNCATTR_SYS (localtime_rz, struct tm *,
+_GL_FUNCDECL_SYS (localtime_rz, struct tm *,
(timezone_t __tz, time_t const *restrict __timer,
struct tm *restrict __result),
_GL_ARG_NONNULL ((2, 3)));
# undef mktime_z
# define mktime_z rpl_mktime_z
# endif
-_GL_FUNCATTR_RPL (mktime_z, time_t,
+_GL_FUNCDECL_RPL (mktime_z, time_t,
(timezone_t __tz, struct tm *restrict __tm),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mktime_z, time_t,
(timezone_t __tz, struct tm *restrict __tm));
# else
# if !@HAVE_TZALLOC@
-_GL_FUNCATTR_SYS (mktime_z, time_t,
+_GL_FUNCDECL_SYS (mktime_z, time_t,
(timezone_t __tz, struct tm *restrict __tm),
_GL_ARG_NONNULL ((2)));
# endif
# undef timegm
# define timegm rpl_timegm
# endif
-_GL_FUNCATTR_RPL (timegm, time_t, (struct tm *__tm), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (timegm, time_t, (struct tm *__tm), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (timegm, time_t, (struct tm *__tm));
# else
# if ! @HAVE_TIMEGM@
-_GL_FUNCATTR_SYS (timegm, time_t, (struct tm *__tm), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (timegm, time_t, (struct tm *__tm), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (timegm, time_t, (struct tm *__tm));
# endif
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (btoc32, wint_t, (int c), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (btoc32, wint_t, (int c), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (btoc32, wint_t, (int c));
_GL_CXXALIASWARN (btoc32);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isalnum, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isalnum, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isalnum, int, (wint_t wc));
_GL_CXXALIASWARN (c32isalnum);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isalpha, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isalpha, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isalpha, int, (wint_t wc));
_GL_CXXALIASWARN (c32isalpha);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isblank, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isblank, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isblank, int, (wint_t wc));
_GL_CXXALIASWARN (c32isblank);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32iscntrl, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32iscntrl, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32iscntrl, int, (wint_t wc));
_GL_CXXALIASWARN (c32iscntrl);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isdigit, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isdigit, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isdigit, int, (wint_t wc));
_GL_CXXALIASWARN (c32isdigit);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isgraph, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isgraph, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isgraph, int, (wint_t wc));
_GL_CXXALIASWARN (c32isgraph);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32islower, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32islower, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32islower, int, (wint_t wc));
_GL_CXXALIASWARN (c32islower);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isprint, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isprint, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isprint, int, (wint_t wc));
_GL_CXXALIASWARN (c32isprint);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32ispunct, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32ispunct, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32ispunct, int, (wint_t wc));
_GL_CXXALIASWARN (c32ispunct);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isspace, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isspace, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isspace, int, (wint_t wc));
_GL_CXXALIASWARN (c32isspace);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isupper, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isupper, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isupper, int, (wint_t wc));
_GL_CXXALIASWARN (c32isupper);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32isxdigit, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32isxdigit, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32isxdigit, int, (wint_t wc));
_GL_CXXALIASWARN (c32isxdigit);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32tolower, wint_t, (wint_t wc));
+_GL_FUNCDECL_SYS (c32tolower, wint_t, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32tolower, wint_t, (wint_t wc));
_GL_CXXALIASWARN (c32tolower);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32toupper, wint_t, (wint_t wc));
+_GL_FUNCDECL_SYS (c32toupper, wint_t, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32toupper, wint_t, (wint_t wc));
_GL_CXXALIASWARN (c32toupper);
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32width, int, (char32_t wc));
+_GL_FUNCDECL_SYS (c32width, int, (char32_t wc), );
# endif
_GL_CXXALIAS_SYS (c32width, int, (char32_t wc));
_GL_CXXALIASWARN (c32width);
# undef c32rtomb
# define c32rtomb rpl_c32rtomb
# endif
-_GL_FUNCDECL_RPL (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps));
+_GL_FUNCDECL_RPL (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps), );
_GL_CXXALIAS_RPL (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps));
# else
# if !@HAVE_C32RTOMB@
-_GL_FUNCDECL_SYS (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps));
+_GL_FUNCDECL_SYS (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps), );
# endif
_GL_CXXALIAS_SYS (c32rtomb, size_t, (char *s, char32_t wc, mbstate_t *ps));
# endif
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32snrtombs, size_t,
+_GL_FUNCDECL_SYS (c32snrtombs, size_t,
(char *dest, const char32_t **srcp, size_t srclen, size_t len,
mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32srtombs, size_t,
+_GL_FUNCDECL_SYS (c32srtombs, size_t,
(char *dest, const char32_t **srcp, size_t len,
mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32stombs, size_t,
+_GL_FUNCDECL_SYS (c32stombs, size_t,
(char *dest, const char32_t *src, size_t len),
_GL_ARG_NONNULL ((2)));
# endif
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32swidth, int, (const char32_t *s, size_t n),
+_GL_FUNCDECL_SYS (c32swidth, int, (const char32_t *s, size_t n),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (c32swidth, int, (const char32_t *s, size_t n));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_SYS (c32tob, int, (wint_t wc));
+_GL_FUNCDECL_SYS (c32tob, int, (wint_t wc), );
# endif
_GL_CXXALIAS_SYS (c32tob, int, (wint_t wc));
_GL_CXXALIASWARN (c32tob);
# define mbrtoc32 rpl_mbrtoc32
# endif
_GL_FUNCDECL_RPL (mbrtoc32, size_t,
- (char32_t *pc, const char *s, size_t n, mbstate_t *ps));
+ (char32_t *pc, const char *s, size_t n, mbstate_t *ps), );
_GL_CXXALIAS_RPL (mbrtoc32, size_t,
(char32_t *pc, const char *s, size_t n, mbstate_t *ps));
# else
# if !@HAVE_MBRTOC32@
_GL_FUNCDECL_SYS (mbrtoc32, size_t,
- (char32_t *pc, const char *s, size_t n, mbstate_t *ps));
+ (char32_t *pc, const char *s, size_t n, mbstate_t *ps), );
# endif
_GL_CXXALIAS_SYS (mbrtoc32, size_t,
(char32_t *pc, const char *s, size_t n, mbstate_t *ps));
# define mbrtoc16 rpl_mbrtoc16
# endif
_GL_FUNCDECL_RPL (mbrtoc16, size_t,
- (char16_t *pc, const char *s, size_t n, mbstate_t *ps));
+ (char16_t *pc, const char *s, size_t n, mbstate_t *ps), );
_GL_CXXALIAS_RPL (mbrtoc16, size_t,
(char16_t *pc, const char *s, size_t n, mbstate_t *ps));
# else
# if !@HAVE_MBRTOC16@
_GL_FUNCDECL_SYS (mbrtoc16, size_t,
- (char16_t *pc, const char *s, size_t n, mbstate_t *ps));
+ (char16_t *pc, const char *s, size_t n, mbstate_t *ps), );
# endif
_GL_CXXALIAS_SYS (mbrtoc16, size_t,
(char16_t *pc, const char *s, size_t n, mbstate_t *ps));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (mbsnrtoc32s, size_t,
+_GL_FUNCDECL_SYS (mbsnrtoc32s, size_t,
(char32_t *dest, const char **srcp, size_t srclen, size_t len,
mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (mbsrtoc32s, size_t,
+_GL_FUNCDECL_SYS (mbsrtoc32s, size_t,
(char32_t *dest, const char **srcp, size_t len,
mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (mbstoc32s, size_t,
+_GL_FUNCDECL_SYS (mbstoc32s, size_t,
(char32_t *dest, const char *src, size_t len),
_GL_ARG_NONNULL ((2)));
# endif
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32_get_type_test, c32_type_test_t, (const char *name),
+_GL_FUNCDECL_SYS (c32_get_type_test, c32_type_test_t, (const char *name),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (c32_get_type_test, c32_type_test_t, (const char *name));
_GL_END_C_LINKAGE
# else
_GL_FUNCDECL_SYS (c32_apply_type_test, int,
- (wint_t wc, c32_type_test_t property));
+ (wint_t wc, c32_type_test_t property), );
# endif
# else
-_GL_FUNCATTR_SYS (c32_apply_type_test, int,
+_GL_FUNCDECL_SYS (c32_apply_type_test, int,
(wint_t wc, c32_type_test_t property),
_GL_ARG_NONNULL ((2)));
# endif
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32_get_mapping, c32_mapping_t, (const char *name),
+_GL_FUNCDECL_SYS (c32_get_mapping, c32_mapping_t, (const char *name),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (c32_get_mapping, c32_mapping_t, (const char *name));
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCATTR_SYS (c32_apply_mapping, wint_t,
+_GL_FUNCDECL_SYS (c32_apply_mapping, wint_t,
(wint_t wc, c32_mapping_t mapping),
_GL_ARG_NONNULL ((2)));
# endif
# undef access
# define access rpl_access
# endif
-_GL_FUNCATTR_RPL (access, int, (const char *file, int mode),
+_GL_FUNCDECL_RPL (access, int, (const char *file, int mode),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (access, int, (const char *file, int mode));
# elif defined _WIN32 && !defined __CYGWIN__
# undef chown
# define chown rpl_chown
# endif
-_GL_FUNCATTR_RPL (chown, int, (const char *file, uid_t uid, gid_t gid),
+_GL_FUNCDECL_RPL (chown, int, (const char *file, uid_t uid, gid_t gid),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (chown, int, (const char *file, uid_t uid, gid_t gid));
# else
# if !@HAVE_CHOWN@
-_GL_FUNCATTR_SYS (chown, int, (const char *file, uid_t uid, gid_t gid),
+_GL_FUNCDECL_SYS (chown, int, (const char *file, uid_t uid, gid_t gid),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (chown, int, (const char *file, uid_t uid, gid_t gid));
# undef close
# define close rpl_close
# endif
-_GL_FUNCDECL_RPL (close, int, (int fd));
+_GL_FUNCDECL_RPL (close, int, (int fd), );
_GL_CXXALIAS_RPL (close, int, (int fd));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# endif
_GL_FUNCDECL_RPL (copy_file_range, ssize_t, (int ifd, off_t *ipos,
int ofd, off_t *opos,
- size_t len, unsigned flags));
+ size_t len, unsigned flags), );
_GL_CXXALIAS_RPL (copy_file_range, ssize_t, (int ifd, off_t *ipos,
int ofd, off_t *opos,
size_t len, unsigned flags));
# if !@HAVE_COPY_FILE_RANGE@
_GL_FUNCDECL_SYS (copy_file_range, ssize_t, (int ifd, off_t *ipos,
int ofd, off_t *opos,
- size_t len, unsigned flags));
+ size_t len, unsigned flags), );
# endif
_GL_CXXALIAS_SYS (copy_file_range, ssize_t, (int ifd, off_t *ipos,
int ofd, off_t *opos,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define dup rpl_dup
# endif
-_GL_FUNCATTR_RPL (dup, int, (int oldfd), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_RPL (dup, int, (int oldfd), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (dup, int, (int oldfd));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define dup2 rpl_dup2
# endif
-_GL_FUNCDECL_RPL (dup2, int, (int oldfd, int newfd));
+_GL_FUNCDECL_RPL (dup2, int, (int oldfd, int newfd), );
_GL_CXXALIAS_RPL (dup2, int, (int oldfd, int newfd));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# undef dup3
# define dup3 rpl_dup3
# endif
-_GL_FUNCDECL_RPL (dup3, int, (int oldfd, int newfd, int flags));
+_GL_FUNCDECL_RPL (dup3, int, (int oldfd, int newfd, int flags), );
_GL_CXXALIAS_RPL (dup3, int, (int oldfd, int newfd, int flags));
# else
# if !@HAVE_DUP3@
-_GL_FUNCDECL_SYS (dup3, int, (int oldfd, int newfd, int flags));
+_GL_FUNCDECL_SYS (dup3, int, (int oldfd, int newfd, int flags), );
# endif
_GL_CXXALIAS_SYS (dup3, int, (int oldfd, int newfd, int flags));
# endif
/* Like access(), except that it uses the effective user id and group id of
the current process. */
# if !@HAVE_EUIDACCESS@
-_GL_FUNCATTR_SYS (euidaccess, int, (const char *filename, int mode),
+_GL_FUNCDECL_SYS (euidaccess, int, (const char *filename, int mode),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (euidaccess, int, (const char *filename, int mode));
# undef execl
# define execl rpl_execl
# endif
-_GL_FUNCATTR_RPL (execl, int, (const char *program, const char *arg, ...),
+_GL_FUNCDECL_RPL (execl, int, (const char *program, const char *arg, ...),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (execl, int, (const char *program, const char *arg, ...));
# else
# undef execle
# define execle rpl_execle
# endif
-_GL_FUNCATTR_RPL (execle, int, (const char *program, const char *arg, ...),
+_GL_FUNCDECL_RPL (execle, int, (const char *program, const char *arg, ...),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (execle, int, (const char *program, const char *arg, ...));
# else
# undef execlp
# define execlp rpl_execlp
# endif
-_GL_FUNCATTR_RPL (execlp, int, (const char *program, const char *arg, ...),
+_GL_FUNCDECL_RPL (execlp, int, (const char *program, const char *arg, ...),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (execlp, int, (const char *program, const char *arg, ...));
# else
# undef execv
# define execv rpl_execv
# endif
-_GL_FUNCATTR_RPL (execv, int, (const char *program, char * const *argv),
+_GL_FUNCDECL_RPL (execv, int, (const char *program, char * const *argv),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (execv, int, (const char *program, char * const *argv));
# else
# undef execve
# define execve rpl_execve
# endif
-_GL_FUNCATTR_RPL (execve, int,
+_GL_FUNCDECL_RPL (execve, int,
(const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (execve, int,
# undef execvp
# define execvp rpl_execvp
# endif
-_GL_FUNCATTR_RPL (execvp, int, (const char *program, char * const *argv),
+_GL_FUNCDECL_RPL (execvp, int, (const char *program, char * const *argv),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (execvp, int, (const char *program, char * const *argv));
# else
# undef execvpe
# define execvpe rpl_execvpe
# endif
-_GL_FUNCATTR_RPL (execvpe, int,
+_GL_FUNCDECL_RPL (execvpe, int,
(const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (execvpe, int,
(const char *program, char * const *argv, char * const *env));
# else
# if !@HAVE_DECL_EXECVPE@
-_GL_FUNCATTR_SYS (execvpe, int,
+_GL_FUNCDECL_SYS (execvpe, int,
(const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
# endif
char * const *env));
# elif @HAVE_EXECVPE@
# if !@HAVE_DECL_EXECVPE@
-_GL_FUNCATTR_SYS (execvpe, int,
+_GL_FUNCDECL_SYS (execvpe, int,
(const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
# endif
# undef faccessat
# define faccessat rpl_faccessat
# endif
-_GL_FUNCATTR_RPL (faccessat, int,
+_GL_FUNCDECL_RPL (faccessat, int,
(int fd, char const *name, int mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (faccessat, int,
(int fd, char const *name, int mode, int flag));
# else
# if !@HAVE_FACCESSAT@
-_GL_FUNCATTR_SYS (faccessat, int,
+_GL_FUNCDECL_SYS (faccessat, int,
(int fd, char const *file, int mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef fchdir
# define fchdir rpl_fchdir
# endif
-_GL_FUNCATTR_RPL (fchdir, int, (int /*fd*/), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_RPL (fchdir, int, (int /*fd*/), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fchdir, int, (int /*fd*/));
# else
# if !@HAVE_FCHDIR@ || !@HAVE_DECL_FCHDIR@
-_GL_FUNCATTR_SYS (fchdir, int, (int /*fd*/), _GL_ATTRIBUTE_NODISCARD);
+_GL_FUNCDECL_SYS (fchdir, int, (int /*fd*/), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (fchdir, int, (int /*fd*/));
# endif
# undef fchownat
# define fchownat rpl_fchownat
# endif
-_GL_FUNCATTR_RPL (fchownat, int, (int fd, char const *file,
+_GL_FUNCDECL_RPL (fchownat, int, (int fd, char const *file,
uid_t owner, gid_t group, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fchownat, int, (int fd, char const *file,
uid_t owner, gid_t group, int flag));
# else
# if !@HAVE_FCHOWNAT@
-_GL_FUNCATTR_SYS (fchownat, int, (int fd, char const *file,
+_GL_FUNCDECL_SYS (fchownat, int, (int fd, char const *file,
uid_t owner, gid_t group, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef fdatasync
# define fdatasync rpl_fdatasync
# endif
-_GL_FUNCDECL_RPL (fdatasync, int, (int fd));
+_GL_FUNCDECL_RPL (fdatasync, int, (int fd), );
_GL_CXXALIAS_RPL (fdatasync, int, (int fd));
# else
# if !@HAVE_FDATASYNC@|| !@HAVE_DECL_FDATASYNC@
-_GL_FUNCDECL_SYS (fdatasync, int, (int fd));
+_GL_FUNCDECL_SYS (fdatasync, int, (int fd), );
# endif
_GL_CXXALIAS_SYS (fdatasync, int, (int fd));
# endif
See POSIX:2008 specification
<https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html>. */
# if !@HAVE_FSYNC@
-_GL_FUNCDECL_SYS (fsync, int, (int fd));
+_GL_FUNCDECL_SYS (fsync, int, (int fd), );
# endif
_GL_CXXALIAS_SYS (fsync, int, (int fd));
_GL_CXXALIASWARN (fsync);
# undef ftruncate
# define ftruncate rpl_ftruncate
# endif
-_GL_FUNCATTR_RPL (ftruncate, int,
+_GL_FUNCDECL_RPL (ftruncate, int,
(int fd, off_t length), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ftruncate, int,
(int fd, off_t length));
# else
# if !@HAVE_FTRUNCATE@
-_GL_FUNCATTR_SYS (ftruncate, int,
+_GL_FUNCDECL_SYS (ftruncate, int,
(int fd, off_t length), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (ftruncate, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define getcwd rpl_getcwd
# endif
-_GL_FUNCATTR_RPL (getcwd, char *, (char *buf, size_t size),
+_GL_FUNCDECL_RPL (getcwd, char *, (char *buf, size_t size),
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getcwd, char *, (char *buf, size_t size));
# elif defined _WIN32 && !defined __CYGWIN__
# undef getdomainname
# define getdomainname rpl_getdomainname
# endif
-_GL_FUNCATTR_RPL (getdomainname, int,
+_GL_FUNCDECL_RPL (getdomainname, int,
(char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getdomainname, int,
(char *name, size_t len));
# else
# if !@HAVE_DECL_GETDOMAINNAME@
-_GL_FUNCATTR_SYS (getdomainname, int,
+_GL_FUNCDECL_SYS (getdomainname, int,
(char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef getdtablesize
# define getdtablesize rpl_getdtablesize
# endif
-_GL_FUNCDECL_RPL (getdtablesize, int, (void));
+_GL_FUNCDECL_RPL (getdtablesize, int, (void), );
_GL_CXXALIAS_RPL (getdtablesize, int, (void));
# else
# if !@HAVE_GETDTABLESIZE@
-_GL_FUNCDECL_SYS (getdtablesize, int, (void));
+_GL_FUNCDECL_SYS (getdtablesize, int, (void), );
# endif
/* Need to cast, because on AIX, the parameter list is
(...). */
# undef getentropy
# define getentropy rpl_getentropy
# endif
-_GL_FUNCATTR_RPL (getentropy, int,
+_GL_FUNCDECL_RPL (getentropy, int,
(void *buffer, size_t length), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getentropy, int,
(void *buffer, size_t length));
# else
# if !@HAVE_GETENTROPY@
-_GL_FUNCATTR_SYS (getentropy, int,
+_GL_FUNCDECL_SYS (getentropy, int,
(void *buffer, size_t length), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getentropy, int,
# undef getgroups
# define getgroups rpl_getgroups
# endif
-_GL_FUNCATTR_RPL (getgroups, int,
+_GL_FUNCDECL_RPL (getgroups, int,
(int n, gid_t *groups), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getgroups, int,
(int n, gid_t *groups));
# else
# if !@HAVE_GETGROUPS@
-_GL_FUNCATTR_SYS (getgroups, int,
+_GL_FUNCDECL_SYS (getgroups, int,
(int n, gid_t *groups), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getgroups, int,
# undef gethostname
# define gethostname rpl_gethostname
# endif
-_GL_FUNCATTR_RPL (gethostname, int, (char *name, size_t len),
+_GL_FUNCDECL_RPL (gethostname, int, (char *name, size_t len),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (gethostname, int, (char *name, size_t len));
# else
# if !@HAVE_GETHOSTNAME@
-_GL_FUNCATTR_SYS (gethostname, int, (char *name, size_t len),
+_GL_FUNCDECL_SYS (gethostname, int, (char *name, size_t len),
_GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on Solaris 10 and OSF/1 5.1 systems, the second
$USERNAME on native Windows platforms.
*/
# if !@HAVE_DECL_GETLOGIN@
-_GL_FUNCDECL_SYS (getlogin, char *, (void));
+_GL_FUNCDECL_SYS (getlogin, char *, (void), );
# endif
_GL_CXXALIAS_SYS (getlogin, char *, (void));
_GL_CXXALIASWARN (getlogin);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define getlogin_r rpl_getlogin_r
# endif
-_GL_FUNCATTR_RPL (getlogin_r, int, (char *name, size_t size),
+_GL_FUNCDECL_RPL (getlogin_r, int, (char *name, size_t size),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (getlogin_r, int, (char *name, size_t size));
# else
# if !@HAVE_DECL_GETLOGIN_R@
-_GL_FUNCATTR_SYS (getlogin_r, int, (char *name, size_t size),
+_GL_FUNCDECL_SYS (getlogin_r, int, (char *name, size_t size),
_GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on Solaris 10 systems, the second argument is
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define getpagesize rpl_getpagesize
# endif
-_GL_FUNCDECL_RPL (getpagesize, int, (void));
+_GL_FUNCDECL_RPL (getpagesize, int, (void), );
_GL_CXXALIAS_RPL (getpagesize, int, (void));
# else
/* On HP-UX, getpagesize exists, but it is not declared in <unistd.h> even if
the compiler options -D_HPUX_SOURCE -D_XOPEN_SOURCE=600 are used. */
# if defined __hpux
-_GL_FUNCDECL_SYS (getpagesize, int, (void));
+_GL_FUNCDECL_SYS (getpagesize, int, (void), );
# endif
# if !@HAVE_GETPAGESIZE@
# if !defined getpagesize
# undef getpass
# define getpass rpl_getpass
# endif
-_GL_FUNCATTR_RPL (getpass, char *, (const char *prompt),
+_GL_FUNCDECL_RPL (getpass, char *, (const char *prompt),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (getpass, char *, (const char *prompt));
# else
# if !@HAVE_GETPASS@
-_GL_FUNCATTR_SYS (getpass, char *, (const char *prompt),
+_GL_FUNCDECL_SYS (getpass, char *, (const char *prompt),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (getpass, char *, (const char *prompt));
# undef getusershell
# define getusershell rpl_getusershell
# endif
-_GL_FUNCDECL_RPL (getusershell, char *, (void));
+_GL_FUNCDECL_RPL (getusershell, char *, (void), );
_GL_CXXALIAS_RPL (getusershell, char *, (void));
# else
# if !@HAVE_DECL_GETUSERSHELL@
-_GL_FUNCDECL_SYS (getusershell, char *, (void));
+_GL_FUNCDECL_SYS (getusershell, char *, (void), );
# endif
_GL_CXXALIAS_SYS (getusershell, char *, (void));
# endif
# undef setusershell
# define setusershell rpl_setusershell
# endif
-_GL_FUNCDECL_RPL (setusershell, void, (void));
+_GL_FUNCDECL_RPL (setusershell, void, (void), );
_GL_CXXALIAS_RPL (setusershell, void, (void));
# else
# if !@HAVE_DECL_GETUSERSHELL@
-_GL_FUNCDECL_SYS (setusershell, void, (void));
+_GL_FUNCDECL_SYS (setusershell, void, (void), );
# endif
_GL_CXXALIAS_SYS (setusershell, void, (void));
# endif
# undef endusershell
# define endusershell rpl_endusershell
# endif
-_GL_FUNCDECL_RPL (endusershell, void, (void));
+_GL_FUNCDECL_RPL (endusershell, void, (void), );
_GL_CXXALIAS_RPL (endusershell, void, (void));
# else
# if !@HAVE_DECL_GETUSERSHELL@
-_GL_FUNCDECL_SYS (endusershell, void, (void));
+_GL_FUNCDECL_SYS (endusershell, void, (void), );
# endif
_GL_CXXALIAS_SYS (endusershell, void, (void));
# endif
#if @GNULIB_GROUP_MEMBER@
/* Determine whether group id is in calling user's group list. */
# if !@HAVE_GROUP_MEMBER@
-_GL_FUNCDECL_SYS (group_member, int, (gid_t gid));
+_GL_FUNCDECL_SYS (group_member, int, (gid_t gid), );
# endif
_GL_CXXALIAS_SYS (group_member, int, (gid_t gid));
_GL_CXXALIASWARN (group_member);
# define isatty rpl_isatty
# endif
# define GNULIB_defined_isatty 1
-_GL_FUNCDECL_RPL (isatty, int, (int fd));
+_GL_FUNCDECL_RPL (isatty, int, (int fd), );
_GL_CXXALIAS_RPL (isatty, int, (int fd));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# undef lchown
# define lchown rpl_lchown
# endif
-_GL_FUNCATTR_RPL (lchown, int, (char const *file, uid_t owner, gid_t group),
+_GL_FUNCDECL_RPL (lchown, int, (char const *file, uid_t owner, gid_t group),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (lchown, int, (char const *file, uid_t owner, gid_t group));
# else
# if !@HAVE_LCHOWN@
-_GL_FUNCATTR_SYS (lchown, int, (char const *file, uid_t owner, gid_t group),
+_GL_FUNCDECL_SYS (lchown, int, (char const *file, uid_t owner, gid_t group),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (lchown, int, (char const *file, uid_t owner, gid_t group));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define link rpl_link
# endif
-_GL_FUNCATTR_RPL (link, int, (const char *path1, const char *path2),
+_GL_FUNCDECL_RPL (link, int, (const char *path1, const char *path2),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (link, int, (const char *path1, const char *path2));
# else
# if !@HAVE_LINK@
-_GL_FUNCATTR_SYS (link, int, (const char *path1, const char *path2),
+_GL_FUNCDECL_SYS (link, int, (const char *path1, const char *path2),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (link, int, (const char *path1, const char *path2));
# undef linkat
# define linkat rpl_linkat
# endif
-_GL_FUNCATTR_RPL (linkat, int,
+_GL_FUNCDECL_RPL (linkat, int,
(int fd1, const char *path1, int fd2, const char *path2,
int flag),
_GL_ARG_NONNULL ((2, 4)) _GL_ATTRIBUTE_NODISCARD);
int flag));
# else
# if !@HAVE_LINKAT@
-_GL_FUNCATTR_SYS (linkat, int,
+_GL_FUNCDECL_SYS (linkat, int,
(int fd1, const char *path1, int fd2, const char *path2,
int flag),
_GL_ARG_NONNULL ((2, 4)) _GL_ATTRIBUTE_NODISCARD);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define lseek rpl_lseek
# endif
-_GL_FUNCDECL_RPL (lseek, off_t, (int fd, off_t offset, int whence));
+_GL_FUNCDECL_RPL (lseek, off_t, (int fd, off_t offset, int whence), );
_GL_CXXALIAS_RPL (lseek, off_t, (int fd, off_t offset, int whence));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
Store the read-end as fd[0] and the write-end as fd[1].
Return 0 upon success, or -1 with errno set upon failure. */
# if !@HAVE_PIPE@
-_GL_FUNCATTR_SYS (pipe, int, (int fd[2]),
+_GL_FUNCDECL_SYS (pipe, int, (int fd[2]),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (pipe, int, (int fd[2]));
# undef pipe2
# define pipe2 rpl_pipe2
# endif
-_GL_FUNCATTR_RPL (pipe2, int, (int fd[2], int flags),
+_GL_FUNCDECL_RPL (pipe2, int, (int fd[2], int flags),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (pipe2, int, (int fd[2], int flags));
# else
-_GL_FUNCATTR_SYS (pipe2, int, (int fd[2], int flags),
+_GL_FUNCDECL_SYS (pipe2, int, (int fd[2], int flags),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_SYS (pipe2, int, (int fd[2], int flags));
# endif
# undef pread
# define pread rpl_pread
# endif
-_GL_FUNCATTR_RPL (pread, ssize_t,
+_GL_FUNCDECL_RPL (pread, ssize_t,
(int fd, void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (pread, ssize_t,
(int fd, void *buf, size_t bufsize, off_t offset));
# else
# if !@HAVE_PREAD@
-_GL_FUNCATTR_SYS (pread, ssize_t,
+_GL_FUNCDECL_SYS (pread, ssize_t,
(int fd, void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef pwrite
# define pwrite rpl_pwrite
# endif
-_GL_FUNCATTR_RPL (pwrite, ssize_t,
+_GL_FUNCDECL_RPL (pwrite, ssize_t,
(int fd, const void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (pwrite, ssize_t,
(int fd, const void *buf, size_t bufsize, off_t offset));
# else
# if !@HAVE_PWRITE@
-_GL_FUNCATTR_SYS (pwrite, ssize_t,
+_GL_FUNCDECL_SYS (pwrite, ssize_t,
(int fd, const void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# define read rpl_read
# endif
-_GL_FUNCATTR_RPL (read, ssize_t, (int fd, void *buf, size_t count),
+_GL_FUNCDECL_RPL (read, ssize_t, (int fd, void *buf, size_t count),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (read, ssize_t, (int fd, void *buf, size_t count));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define readlink rpl_readlink
# endif
-_GL_FUNCATTR_RPL (readlink, ssize_t,
+_GL_FUNCDECL_RPL (readlink, ssize_t,
(const char *restrict file,
char *restrict buf, size_t bufsize),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
char *restrict buf, size_t bufsize));
# else
# if !@HAVE_READLINK@
-_GL_FUNCATTR_SYS (readlink, ssize_t,
+_GL_FUNCDECL_SYS (readlink, ssize_t,
(const char *restrict file,
char *restrict buf, size_t bufsize),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define readlinkat rpl_readlinkat
# endif
-_GL_FUNCATTR_RPL (readlinkat, ssize_t,
+_GL_FUNCDECL_RPL (readlinkat, ssize_t,
(int fd, char const *restrict file,
char *restrict buf, size_t len),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
char *restrict buf, size_t len));
# else
# if !@HAVE_READLINKAT@
-_GL_FUNCATTR_SYS (readlinkat, ssize_t,
+_GL_FUNCDECL_SYS (readlinkat, ssize_t,
(int fd, char const *restrict file,
char *restrict buf, size_t len),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define rmdir rpl_rmdir
# endif
-_GL_FUNCATTR_RPL (rmdir, int, (char const *name), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (rmdir, int, (char const *name), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (rmdir, int, (char const *name));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# undef sethostname
# define sethostname rpl_sethostname
# endif
-_GL_FUNCATTR_RPL (sethostname, int,
+_GL_FUNCDECL_RPL (sethostname, int,
(const char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (sethostname, int,
(const char *name, size_t len));
# else
# if !@HAVE_SETHOSTNAME@ || !@HAVE_DECL_SETHOSTNAME@
-_GL_FUNCATTR_SYS (sethostname, int,
+_GL_FUNCDECL_SYS (sethostname, int,
(const char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef sleep
# define sleep rpl_sleep
# endif
-_GL_FUNCDECL_RPL (sleep, unsigned int, (unsigned int n));
+_GL_FUNCDECL_RPL (sleep, unsigned int, (unsigned int n), );
_GL_CXXALIAS_RPL (sleep, unsigned int, (unsigned int n));
# else
# if !@HAVE_SLEEP@
-_GL_FUNCDECL_SYS (sleep, unsigned int, (unsigned int n));
+_GL_FUNCDECL_SYS (sleep, unsigned int, (unsigned int n), );
# endif
_GL_CXXALIAS_SYS (sleep, unsigned int, (unsigned int n));
# endif
# undef symlink
# define symlink rpl_symlink
# endif
-_GL_FUNCATTR_RPL (symlink, int,
+_GL_FUNCDECL_RPL (symlink, int,
(char const *contents, char const *file),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (symlink, int,
(char const *contents, char const *file));
# else
# if !@HAVE_SYMLINK@
-_GL_FUNCATTR_SYS (symlink, int,
+_GL_FUNCDECL_SYS (symlink, int,
(char const *contents, char const *file),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef symlinkat
# define symlinkat rpl_symlinkat
# endif
-_GL_FUNCATTR_RPL (symlinkat, int,
+_GL_FUNCDECL_RPL (symlinkat, int,
(char const *contents, int fd, char const *file),
_GL_ARG_NONNULL ((1, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (symlinkat, int,
(char const *contents, int fd, char const *file));
# else
# if !@HAVE_SYMLINKAT@
-_GL_FUNCATTR_SYS (symlinkat, int,
+_GL_FUNCDECL_SYS (symlinkat, int,
(char const *contents, int fd, char const *file),
_GL_ARG_NONNULL ((1, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef truncate
# define truncate rpl_truncate
# endif
-_GL_FUNCATTR_RPL (truncate, int, (const char *filename, off_t length),
+_GL_FUNCDECL_RPL (truncate, int, (const char *filename, off_t length),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (truncate, int, (const char *filename, off_t length));
# else
# if !@HAVE_DECL_TRUNCATE@
-_GL_FUNCATTR_SYS (truncate, int, (const char *filename, off_t length),
+_GL_FUNCDECL_SYS (truncate, int, (const char *filename, off_t length),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (truncate, int, (const char *filename, off_t length));
# undef ttyname_r
# define ttyname_r rpl_ttyname_r
# endif
-_GL_FUNCATTR_RPL (ttyname_r, int,
+_GL_FUNCDECL_RPL (ttyname_r, int,
(int fd, char *buf, size_t buflen),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ttyname_r, int,
(int fd, char *buf, size_t buflen));
# else
# if !@HAVE_DECL_TTYNAME_R@
-_GL_FUNCATTR_SYS (ttyname_r, int,
+_GL_FUNCDECL_SYS (ttyname_r, int,
(int fd, char *buf, size_t buflen),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
# undef unlink
# define unlink rpl_unlink
# endif
-_GL_FUNCATTR_RPL (unlink, int, (char const *file), _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_RPL (unlink, int, (char const *file), _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (unlink, int, (char const *file));
# elif defined _WIN32 && !defined __CYGWIN__
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# undef unlinkat
# define unlinkat rpl_unlinkat
# endif
-_GL_FUNCATTR_RPL (unlinkat, int, (int fd, char const *file, int flag),
+_GL_FUNCDECL_RPL (unlinkat, int, (int fd, char const *file, int flag),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (unlinkat, int, (int fd, char const *file, int flag));
# else
# if !@HAVE_UNLINKAT@
-_GL_FUNCATTR_SYS (unlinkat, int, (int fd, char const *file, int flag),
+_GL_FUNCDECL_SYS (unlinkat, int, (int fd, char const *file, int flag),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (unlinkat, int, (int fd, char const *file, int flag));
# undef usleep
# define usleep rpl_usleep
# endif
-_GL_FUNCDECL_RPL (usleep, int, (useconds_t n));
+_GL_FUNCDECL_RPL (usleep, int, (useconds_t n), );
_GL_CXXALIAS_RPL (usleep, int, (useconds_t n));
# else
# if !@HAVE_USLEEP@
-_GL_FUNCDECL_SYS (usleep, int, (useconds_t n));
+_GL_FUNCDECL_SYS (usleep, int, (useconds_t n), );
# endif
/* Need to cast, because on Haiku, the first parameter is
unsigned int n. */
# undef write
# define write rpl_write
# endif
-_GL_FUNCATTR_RPL (write, ssize_t,
+_GL_FUNCDECL_RPL (write, ssize_t,
(int fd, const void *buf, size_t count),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (write, ssize_t,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define utime rpl_utime
# endif
-_GL_FUNCATTR_RPL (utime, int, (const char *filename, const struct utimbuf *ts),
+_GL_FUNCDECL_RPL (utime, int, (const char *filename, const struct utimbuf *ts),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (utime, int, (const char *filename, const struct utimbuf *ts));
# elif defined _WIN32 && !defined __CYGWIN__
_GL_CXXALIAS_MDA (utime, int, (const char *filename, const struct utimbuf *ts));
# else
# if !@HAVE_UTIME@
-_GL_FUNCATTR_SYS (utime, int, (const char *filename, const struct utimbuf *ts),
+_GL_FUNCDECL_SYS (utime, int, (const char *filename, const struct utimbuf *ts),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (utime, int, (const char *filename, const struct utimbuf *ts));
# undef login_tty
# define login_tty rpl_login_tty
# endif
-_GL_FUNCDECL_RPL (login_tty, int, (int fd));
+_GL_FUNCDECL_RPL (login_tty, int, (int fd), );
_GL_CXXALIAS_RPL (login_tty, int, (int fd));
# else
# if !@HAVE_LOGIN_TTY@
-_GL_FUNCDECL_SYS (login_tty, int, (int fd));
+_GL_FUNCDECL_SYS (login_tty, int, (int fd), );
# endif
_GL_CXXALIAS_SYS (login_tty, int, (int fd));
# endif
# undef btowc
# define btowc rpl_btowc
# endif
-_GL_FUNCATTR_RPL (btowc, wint_t, (int c), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (btowc, wint_t, (int c), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (btowc, wint_t, (int c));
# else
# if !@HAVE_BTOWC@
-_GL_FUNCATTR_SYS (btowc, wint_t, (int c), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (btowc, wint_t, (int c), _GL_ATTRIBUTE_PURE);
# endif
/* Need to cast, because on mingw, the return type is 'unsigned short'. */
_GL_CXXALIAS_SYS_CAST (btowc, wint_t, (int c));
# undef wctob
# define wctob rpl_wctob
# endif
-_GL_FUNCATTR_RPL (wctob, int, (wint_t wc), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (wctob, int, (wint_t wc), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wctob, int, (wint_t wc));
# else
# if !defined wctob && !@HAVE_DECL_WCTOB@
/* wctob is provided by gnulib, or wctob exists but is not declared. */
-_GL_FUNCATTR_SYS (wctob, int, (wint_t wc), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (wctob, int, (wint_t wc), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wctob, int, (wint_t wc));
# endif
# undef mbsinit
# define mbsinit rpl_mbsinit
# endif
-_GL_FUNCDECL_RPL (mbsinit, int, (const mbstate_t *ps));
+_GL_FUNCDECL_RPL (mbsinit, int, (const mbstate_t *ps), );
_GL_CXXALIAS_RPL (mbsinit, int, (const mbstate_t *ps));
# else
# if !@HAVE_MBSINIT@
-_GL_FUNCDECL_SYS (mbsinit, int, (const mbstate_t *ps));
+_GL_FUNCDECL_SYS (mbsinit, int, (const mbstate_t *ps), );
# endif
_GL_CXXALIAS_SYS (mbsinit, int, (const mbstate_t *ps));
# endif
# endif
_GL_FUNCDECL_RPL (mbrtowc, size_t,
(wchar_t *restrict pwc, const char *restrict s, size_t n,
- mbstate_t *restrict ps));
+ mbstate_t *restrict ps), );
_GL_CXXALIAS_RPL (mbrtowc, size_t,
(wchar_t *restrict pwc, const char *restrict s, size_t n,
mbstate_t *restrict ps));
# if !@HAVE_MBRTOWC@
_GL_FUNCDECL_SYS (mbrtowc, size_t,
(wchar_t *restrict pwc, const char *restrict s, size_t n,
- mbstate_t *restrict ps));
+ mbstate_t *restrict ps), );
# endif
_GL_CXXALIAS_SYS (mbrtowc, size_t,
(wchar_t *restrict pwc, const char *restrict s, size_t n,
# define mbrlen rpl_mbrlen
# endif
_GL_FUNCDECL_RPL (mbrlen, size_t,
- (const char *restrict s, size_t n, mbstate_t *restrict ps));
+ (const char *restrict s, size_t n, mbstate_t *restrict ps), );
_GL_CXXALIAS_RPL (mbrlen, size_t,
(const char *restrict s, size_t n, mbstate_t *restrict ps));
# else
# if !@HAVE_MBRLEN@
_GL_FUNCDECL_SYS (mbrlen, size_t,
- (const char *restrict s, size_t n, mbstate_t *restrict ps));
+ (const char *restrict s, size_t n, mbstate_t *restrict ps), );
# endif
_GL_CXXALIAS_SYS (mbrlen, size_t,
(const char *restrict s, size_t n, mbstate_t *restrict ps));
# undef mbsrtowcs
# define mbsrtowcs rpl_mbsrtowcs
# endif
-_GL_FUNCATTR_RPL (mbsrtowcs, size_t,
+_GL_FUNCDECL_RPL (mbsrtowcs, size_t,
(wchar_t *restrict dest,
const char **restrict srcp, size_t len,
mbstate_t *restrict ps),
mbstate_t *restrict ps));
# else
# if !@HAVE_MBSRTOWCS@
-_GL_FUNCATTR_SYS (mbsrtowcs, size_t,
+_GL_FUNCDECL_SYS (mbsrtowcs, size_t,
(wchar_t *restrict dest,
const char **restrict srcp, size_t len,
mbstate_t *restrict ps),
# undef mbsnrtowcs
# define mbsnrtowcs rpl_mbsnrtowcs
# endif
-_GL_FUNCATTR_RPL (mbsnrtowcs, size_t,
+_GL_FUNCDECL_RPL (mbsnrtowcs, size_t,
(wchar_t *restrict dest,
const char **restrict srcp, size_t srclen, size_t len,
mbstate_t *restrict ps),
mbstate_t *restrict ps));
# else
# if !@HAVE_MBSNRTOWCS@
-_GL_FUNCATTR_SYS (mbsnrtowcs, size_t,
+_GL_FUNCDECL_SYS (mbsnrtowcs, size_t,
(wchar_t *restrict dest,
const char **restrict srcp, size_t srclen, size_t len,
mbstate_t *restrict ps),
# define wcrtomb rpl_wcrtomb
# endif
_GL_FUNCDECL_RPL (wcrtomb, size_t,
- (char *restrict s, wchar_t wc, mbstate_t *restrict ps));
+ (char *restrict s, wchar_t wc, mbstate_t *restrict ps), );
_GL_CXXALIAS_RPL (wcrtomb, size_t,
(char *restrict s, wchar_t wc, mbstate_t *restrict ps));
# else
# if !@HAVE_WCRTOMB@
_GL_FUNCDECL_SYS (wcrtomb, size_t,
- (char *restrict s, wchar_t wc, mbstate_t *restrict ps));
+ (char *restrict s, wchar_t wc, mbstate_t *restrict ps), );
# endif
_GL_CXXALIAS_SYS (wcrtomb, size_t,
(char *restrict s, wchar_t wc, mbstate_t *restrict ps));
# undef wcsrtombs
# define wcsrtombs rpl_wcsrtombs
# endif
-_GL_FUNCATTR_RPL (wcsrtombs, size_t,
+_GL_FUNCDECL_RPL (wcsrtombs, size_t,
(char *restrict dest, const wchar_t **restrict srcp,
size_t len,
mbstate_t *restrict ps),
mbstate_t *restrict ps));
# else
# if !@HAVE_WCSRTOMBS@
-_GL_FUNCATTR_SYS (wcsrtombs, size_t,
+_GL_FUNCDECL_SYS (wcsrtombs, size_t,
(char *restrict dest, const wchar_t **restrict srcp,
size_t len,
mbstate_t *restrict ps),
# undef wcsnrtombs
# define wcsnrtombs rpl_wcsnrtombs
# endif
-_GL_FUNCATTR_RPL (wcsnrtombs, size_t,
+_GL_FUNCDECL_RPL (wcsnrtombs, size_t,
(char *restrict dest,
const wchar_t **restrict srcp, size_t srclen,
size_t len,
mbstate_t *restrict ps));
# else
# if !@HAVE_WCSNRTOMBS@ || (defined __cplusplus && defined __sun)
-_GL_FUNCATTR_SYS (wcsnrtombs, size_t,
+_GL_FUNCDECL_SYS (wcsnrtombs, size_t,
(char *restrict dest,
const wchar_t **restrict srcp, size_t srclen,
size_t len,
# undef wcwidth
# define wcwidth rpl_wcwidth
# endif
-_GL_FUNCATTR_RPL (wcwidth, int, (wchar_t), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_RPL (wcwidth, int, (wchar_t), _GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wcwidth, int, (wchar_t));
# else
# if !@HAVE_DECL_WCWIDTH@
/* wcwidth exists but is not declared. */
-_GL_FUNCATTR_SYS (wcwidth, int, (wchar_t), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (wcwidth, int, (wchar_t), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcwidth, int, (wchar_t));
# endif
/* Search N wide characters of S for C. */
#if @GNULIB_WMEMCHR@
# if !@HAVE_WMEMCHR@
-_GL_FUNCATTR_SYS (wmemchr, wchar_t *, (const wchar_t *s, wchar_t c, size_t n),
+_GL_FUNCDECL_SYS (wmemchr, wchar_t *, (const wchar_t *s, wchar_t c, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
/* On some systems, this function is defined as an overloaded function:
# undef wmemcmp
# define wmemcmp rpl_wmemcmp
# endif
-_GL_FUNCATTR_RPL (wmemcmp, int,
+_GL_FUNCDECL_RPL (wmemcmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wmemcmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n));
# else
# if !@HAVE_WMEMCMP@
-_GL_FUNCATTR_SYS (wmemcmp, int,
+_GL_FUNCDECL_SYS (wmemcmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
# if !@HAVE_WMEMCPY@
_GL_FUNCDECL_SYS (wmemcpy, wchar_t *,
(wchar_t *restrict dest,
- const wchar_t *restrict src, size_t n));
+ const wchar_t *restrict src, size_t n), );
# endif
_GL_CXXALIAS_SYS (wmemcpy, wchar_t *,
(wchar_t *restrict dest,
#if @GNULIB_WMEMMOVE@
# if !@HAVE_WMEMMOVE@
_GL_FUNCDECL_SYS (wmemmove, wchar_t *,
- (wchar_t *dest, const wchar_t *src, size_t n));
+ (wchar_t *dest, const wchar_t *src, size_t n), );
# endif
_GL_CXXALIAS_SYS (wmemmove, wchar_t *,
(wchar_t *dest, const wchar_t *src, size_t n));
# endif
_GL_FUNCDECL_RPL (wmempcpy, wchar_t *,
(wchar_t *restrict dest,
- const wchar_t *restrict src, size_t n));
+ const wchar_t *restrict src, size_t n), );
_GL_CXXALIAS_RPL (wmempcpy, wchar_t *,
(wchar_t *restrict dest,
const wchar_t *restrict src, size_t n));
# if !@HAVE_WMEMPCPY@
_GL_FUNCDECL_SYS (wmempcpy, wchar_t *,
(wchar_t *restrict dest,
- const wchar_t *restrict src, size_t n));
+ const wchar_t *restrict src, size_t n), );
# endif
_GL_CXXALIAS_SYS (wmempcpy, wchar_t *,
(wchar_t *restrict dest,
/* Set N wide characters of S to C. */
#if @GNULIB_WMEMSET@
# if !@HAVE_WMEMSET@
-_GL_FUNCDECL_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n));
+_GL_FUNCDECL_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n), );
# endif
_GL_CXXALIAS_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n));
# if __GLIBC__ >= 2
/* Return the number of wide characters in S. */
#if @GNULIB_WCSLEN@
# if !@HAVE_WCSLEN@
-_GL_FUNCATTR_SYS (wcslen, size_t, (const wchar_t *s), _GL_ATTRIBUTE_PURE);
+_GL_FUNCDECL_SYS (wcslen, size_t, (const wchar_t *s), _GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcslen, size_t, (const wchar_t *s));
# if __GLIBC__ >= 2
namespace, not in the global namespace. So, force a declaration in
the global namespace. */
# if !@HAVE_WCSNLEN@ || (defined __sun && defined __cplusplus)
-_GL_FUNCATTR_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen),
+_GL_FUNCDECL_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen));
#if @GNULIB_WCSCPY@
# if !@HAVE_WCSCPY@
_GL_FUNCDECL_SYS (wcscpy, wchar_t *,
- (wchar_t *restrict dest, const wchar_t *restrict src));
+ (wchar_t *restrict dest, const wchar_t *restrict src), );
# endif
_GL_CXXALIAS_SYS (wcscpy, wchar_t *,
(wchar_t *restrict dest, const wchar_t *restrict src));
the global namespace. */
# if !@HAVE_WCPCPY@ || (defined __sun && defined __cplusplus)
_GL_FUNCDECL_SYS (wcpcpy, wchar_t *,
- (wchar_t *restrict dest, const wchar_t *restrict src));
+ (wchar_t *restrict dest, const wchar_t *restrict src), );
# endif
_GL_CXXALIAS_SYS (wcpcpy, wchar_t *,
(wchar_t *restrict dest, const wchar_t *restrict src));
# if !@HAVE_WCSNCPY@
_GL_FUNCDECL_SYS (wcsncpy, wchar_t *,
(wchar_t *restrict dest,
- const wchar_t *restrict src, size_t n));
+ const wchar_t *restrict src, size_t n), );
# endif
_GL_CXXALIAS_SYS (wcsncpy, wchar_t *,
(wchar_t *restrict dest,
# if !@HAVE_WCPNCPY@ || (defined __sun && defined __cplusplus)
_GL_FUNCDECL_SYS (wcpncpy, wchar_t *,
(wchar_t *restrict dest,
- const wchar_t *restrict src, size_t n));
+ const wchar_t *restrict src, size_t n), );
# endif
_GL_CXXALIAS_SYS (wcpncpy, wchar_t *,
(wchar_t *restrict dest,
#if @GNULIB_WCSCAT@
# if !@HAVE_WCSCAT@
_GL_FUNCDECL_SYS (wcscat, wchar_t *,
- (wchar_t *restrict dest, const wchar_t *restrict src));
+ (wchar_t *restrict dest, const wchar_t *restrict src), );
# endif
_GL_CXXALIAS_SYS (wcscat, wchar_t *,
(wchar_t *restrict dest, const wchar_t *restrict src));
# if !@HAVE_WCSNCAT@
_GL_FUNCDECL_SYS (wcsncat, wchar_t *,
(wchar_t *restrict dest, const wchar_t *restrict src,
- size_t n));
+ size_t n), );
# endif
_GL_CXXALIAS_SYS (wcsncat, wchar_t *,
(wchar_t *restrict dest, const wchar_t *restrict src,
# undef wcscmp
# define wcscmp rpl_wcscmp
# endif
-_GL_FUNCATTR_RPL (wcscmp, int, (const wchar_t *s1, const wchar_t *s2),
+_GL_FUNCDECL_RPL (wcscmp, int, (const wchar_t *s1, const wchar_t *s2),
_GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wcscmp, int, (const wchar_t *s1, const wchar_t *s2));
# else
# if !@HAVE_WCSCMP@
-_GL_FUNCATTR_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2),
+_GL_FUNCDECL_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2));
# undef wcsncmp
# define wcsncmp rpl_wcsncmp
# endif
-_GL_FUNCATTR_RPL (wcsncmp, int,
+_GL_FUNCDECL_RPL (wcsncmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wcsncmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n));
# else
# if !@HAVE_WCSNCMP@
-_GL_FUNCATTR_SYS (wcsncmp, int,
+_GL_FUNCDECL_SYS (wcsncmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
namespace, not in the global namespace. So, force a declaration in
the global namespace. */
# if !@HAVE_WCSCASECMP@ || (defined __sun && defined __cplusplus)
-_GL_FUNCATTR_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2),
+_GL_FUNCDECL_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2));
namespace, not in the global namespace. So, force a declaration in
the global namespace. */
# if !@HAVE_WCSNCASECMP@ || (defined __sun && defined __cplusplus)
-_GL_FUNCATTR_SYS (wcsncasecmp, int,
+_GL_FUNCDECL_SYS (wcsncasecmp, int,
(const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
category of the current locale. */
#if @GNULIB_WCSCOLL@
# if !@HAVE_WCSCOLL@
-_GL_FUNCDECL_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2));
+_GL_FUNCDECL_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2), );
# endif
_GL_CXXALIAS_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2));
# if __GLIBC__ >= 2
#if @GNULIB_WCSXFRM@
# if !@HAVE_WCSXFRM@
_GL_FUNCDECL_SYS (wcsxfrm, size_t,
- (wchar_t *restrict s1, const wchar_t *restrict s2, size_t n));
+ (wchar_t *restrict s1, const wchar_t *restrict s2, size_t n), );
# endif
_GL_CXXALIAS_SYS (wcsxfrm, size_t,
(wchar_t *restrict s1, const wchar_t *restrict s2, size_t n));
# if !@HAVE_WCSDUP@ || (defined __sun && defined __cplusplus) \
|| (__GNUC__ >= 11 && !defined __clang__)
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# if (__GNUC__ >= 11 && !defined __clang__) && !defined wcsdup
/* For -Wmismatched-dealloc: Associate wcsdup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
_GL_CXXALIAS_MDA (wcsdup, wchar_t *, (const wchar_t *s));
# else
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
_GL_ATTRIBUTE_NOTHROW;
# else
-_GL_FUNCATTR_SYS (wcsdup, wchar_t *,
+_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
(const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
/* Find the first occurrence of WC in WCS. */
#if @GNULIB_WCSCHR@
# if !@HAVE_WCSCHR@
-_GL_FUNCATTR_SYS (wcschr, wchar_t *, (const wchar_t *wcs, wchar_t wc),
+_GL_FUNCDECL_SYS (wcschr, wchar_t *, (const wchar_t *wcs, wchar_t wc),
_GL_ATTRIBUTE_PURE);
# endif
/* On some systems, this function is defined as an overloaded function:
/* Find the last occurrence of WC in WCS. */
#if @GNULIB_WCSRCHR@
# if !@HAVE_WCSRCHR@
-_GL_FUNCATTR_SYS (wcsrchr, wchar_t *, (const wchar_t *wcs, wchar_t wc),
+_GL_FUNCDECL_SYS (wcsrchr, wchar_t *, (const wchar_t *wcs, wchar_t wc),
_GL_ATTRIBUTE_PURE);
# endif
/* On some systems, this function is defined as an overloaded function:
of wide characters not in REJECT. */
#if @GNULIB_WCSCSPN@
# if !@HAVE_WCSCSPN@
-_GL_FUNCATTR_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject),
+_GL_FUNCDECL_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject));
of wide characters in ACCEPT. */
#if @GNULIB_WCSSPN@
# if !@HAVE_WCSSPN@
-_GL_FUNCATTR_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept),
+_GL_FUNCDECL_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept));
/* Find the first occurrence in WCS of any character in ACCEPT. */
#if @GNULIB_WCSPBRK@
# if !@HAVE_WCSPBRK@
-_GL_FUNCATTR_SYS (wcspbrk, wchar_t *,
+_GL_FUNCDECL_SYS (wcspbrk, wchar_t *,
(const wchar_t *wcs, const wchar_t *accept),
_GL_ATTRIBUTE_PURE);
# endif
# undef wcsstr
# define wcsstr rpl_wcsstr
# endif
-_GL_FUNCATTR_RPL (wcsstr, wchar_t *,
+_GL_FUNCDECL_RPL (wcsstr, wchar_t *,
(const wchar_t *restrict haystack,
const wchar_t *restrict needle),
_GL_ATTRIBUTE_PURE);
const wchar_t *restrict needle));
# else
# if !@HAVE_WCSSTR@
-_GL_FUNCATTR_SYS (wcsstr, wchar_t *,
+_GL_FUNCDECL_SYS (wcsstr, wchar_t *,
(const wchar_t *restrict haystack,
const wchar_t *restrict needle),
_GL_ATTRIBUTE_PURE);
# endif
_GL_FUNCDECL_RPL (wcstok, wchar_t *,
(wchar_t *restrict wcs, const wchar_t *restrict delim,
- wchar_t **restrict ptr));
+ wchar_t **restrict ptr), );
_GL_CXXALIAS_RPL (wcstok, wchar_t *,
(wchar_t *restrict wcs, const wchar_t *restrict delim,
wchar_t **restrict ptr));
# if !@HAVE_WCSTOK@
_GL_FUNCDECL_SYS (wcstok, wchar_t *,
(wchar_t *restrict wcs, const wchar_t *restrict delim,
- wchar_t **restrict ptr));
+ wchar_t **restrict ptr), );
# endif
_GL_CXXALIAS_SYS (wcstok, wchar_t *,
(wchar_t *restrict wcs, const wchar_t *restrict delim,
# undef wcswidth
# define wcswidth rpl_wcswidth
# endif
-_GL_FUNCATTR_RPL (wcswidth, int, (const wchar_t *s, size_t n),
+_GL_FUNCDECL_RPL (wcswidth, int, (const wchar_t *s, size_t n),
_GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wcswidth, int, (const wchar_t *s, size_t n));
# else
# if !@HAVE_WCSWIDTH@
-_GL_FUNCATTR_SYS (wcswidth, int, (const wchar_t *s, size_t n),
+_GL_FUNCDECL_SYS (wcswidth, int, (const wchar_t *s, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcswidth, int, (const wchar_t *s, size_t n));
# undef wcsftime
# define wcsftime rpl_wcsftime
# endif
-_GL_FUNCATTR_RPL (wcsftime, size_t,
+_GL_FUNCDECL_RPL (wcsftime, size_t,
(wchar_t *restrict __buf, size_t __bufsize,
const wchar_t *restrict __fmt,
const struct tm *restrict __tp),
const struct tm *restrict __tp));
# else
# if !@HAVE_WCSFTIME@
-_GL_FUNCATTR_SYS (wcsftime, size_t,
+_GL_FUNCDECL_SYS (wcsftime, size_t,
(wchar_t *restrict __buf, size_t __bufsize,
const wchar_t *restrict __fmt,
const struct tm *restrict __tp),
Possible errno values include:
- ERANGE if SIZE is too small.
- ENOMEM if the memory could no be allocated. */
-_GL_FUNCDECL_SYS (wgetcwd, wchar_t *, (wchar_t *buf, size_t size));
+_GL_FUNCDECL_SYS (wgetcwd, wchar_t *, (wchar_t *buf, size_t size), );
#endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define iswblank rpl_iswblank
# endif
-_GL_FUNCDECL_RPL (iswblank, int, (wint_t wc));
+_GL_FUNCDECL_RPL (iswblank, int, (wint_t wc), );
# else
-_GL_FUNCDECL_SYS (iswblank, int, (wint_t wc));
+_GL_FUNCDECL_SYS (iswblank, int, (wint_t wc), );
# endif
# endif
# undef iswdigit
# define iswdigit rpl_iswdigit
# endif
-_GL_FUNCDECL_RPL (iswdigit, int, (wint_t wc));
+_GL_FUNCDECL_RPL (iswdigit, int, (wint_t wc), );
# endif
# endif
# undef iswpunct
# define iswpunct rpl_iswpunct
# endif
-_GL_FUNCDECL_RPL (iswpunct, int, (wint_t wc));
+_GL_FUNCDECL_RPL (iswpunct, int, (wint_t wc), );
# endif
# endif
# undef iswxdigit
# define iswxdigit rpl_iswxdigit
# endif
-_GL_FUNCDECL_RPL (iswxdigit, int, (wint_t wc));
+_GL_FUNCDECL_RPL (iswxdigit, int, (wint_t wc), );
# endif
# endif
# undef wctype
# define wctype rpl_wctype
# endif
-_GL_FUNCATTR_RPL (wctype, wctype_t, (const char *name),
+_GL_FUNCDECL_RPL (wctype, wctype_t, (const char *name),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (wctype, wctype_t, (const char *name));
# else
# if !@HAVE_WCTYPE_T@
-_GL_FUNCATTR_SYS (wctype, wctype_t, (const char *name),
+_GL_FUNCDECL_SYS (wctype, wctype_t, (const char *name),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (wctype, wctype_t, (const char *name));
# undef iswctype
# define iswctype rpl_iswctype
# endif
-_GL_FUNCDECL_RPL (iswctype, int, (wint_t wc, wctype_t desc));
+_GL_FUNCDECL_RPL (iswctype, int, (wint_t wc, wctype_t desc), );
_GL_CXXALIAS_RPL (iswctype, int, (wint_t wc, wctype_t desc));
# else
# if !@HAVE_WCTYPE_T@
-_GL_FUNCDECL_SYS (iswctype, int, (wint_t wc, wctype_t desc));
+_GL_FUNCDECL_SYS (iswctype, int, (wint_t wc, wctype_t desc), );
# endif
_GL_CXXALIAS_SYS (iswctype, int, (wint_t wc, wctype_t desc));
# endif
# undef wctrans
# define wctrans rpl_wctrans
# endif
-_GL_FUNCATTR_RPL (wctrans, wctrans_t, (const char *name),
+_GL_FUNCDECL_RPL (wctrans, wctrans_t, (const char *name),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (wctrans, wctrans_t, (const char *name));
# else
# if !@HAVE_WCTRANS_T@
-_GL_FUNCATTR_SYS (wctrans, wctrans_t, (const char *name),
+_GL_FUNCDECL_SYS (wctrans, wctrans_t, (const char *name),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (wctrans, wctrans_t, (const char *name));
# undef towctrans
# define towctrans rpl_towctrans
# endif
-_GL_FUNCDECL_RPL (towctrans, wint_t, (wint_t wc, wctrans_t desc));
+_GL_FUNCDECL_RPL (towctrans, wint_t, (wint_t wc, wctrans_t desc), );
_GL_CXXALIAS_RPL (towctrans, wint_t, (wint_t wc, wctrans_t desc));
# else
# if !@HAVE_WCTRANS_T@
-_GL_FUNCDECL_SYS (towctrans, wint_t, (wint_t wc, wctrans_t desc));
+_GL_FUNCDECL_SYS (towctrans, wint_t, (wint_t wc, wctrans_t desc), );
# endif
_GL_CXXALIAS_SYS (towctrans, wint_t, (wint_t wc, wctrans_t desc));
# endif