+2024-07-30 Bruno Haible <bruno@clisp.org>
+
+ Reenable use of attributes in bracket syntax [[...]] (regr. yesterday).
+ * m4/gnulib-common.m4 (gl_COMMON_BODY): Add more comments. Don't define
+ _GL_BRACKET_USABLE.
+ * lib/c++defs.h (_GL_EXTERN_C_FUNC): New macro.
+ (_GL_FUNCDECL_RPL, _GL_FUNCDECL_RPL_1, _GL_FUNCDECL_SYS): Expect the
+ attributes in an optional 4th argument. Expand them before the return
+ type.
+ * lib/arpa_inet.in.h: Update all _GL_FUNCDECL_RPL and _GL_FUNCDECL_SYS
+ invocations.
+ * lib/dirent.in.h: Likewise.
+ * lib/error.in.h: Likewise.
+ * lib/fcntl.in.h: Likewise.
+ * lib/fnmatch.in.h: Likewise.
+ * lib/glob.in.h: Likewise.
+ * lib/iconv.in.h: Likewise.
+ * lib/inttypes.in.h: Likewise.
+ * lib/locale.in.h: Likewise.
+ * lib/malloc.in.h: Likewise.
+ * lib/math.in.h: Likewise.
+ * lib/monetary.in.h: Likewise.
+ * lib/netdb.in.h: Likewise.
+ * lib/pthread.in.h: Likewise.
+ * lib/search.in.h: Likewise.
+ * lib/signal.in.h: Likewise.
+ * lib/spawn.in.h: Likewise.
+ * lib/stdio.in.h: Likewise.
+ * lib/stdlib.in.h: Likewise.
+ * lib/string.in.h: Likewise.
+ * lib/sys_random.in.h: Likewise.
+ * lib/sys_resource.in.h: Likewise.
+ * lib/sys_socket.in.h: Likewise.
+ * lib/sys_stat.in.h: Likewise.
+ * lib/sys_time.in.h: Likewise.
+ * lib/threads.in.h: Likewise.
+ * lib/time.in.h: Likewise.
+ * lib/uchar.in.h: Likewise.
+ * lib/unistd.in.h: Likewise.
+ * lib/utime.in.h: Likewise.
+ * lib/wchar.in.h: Likewise.
+ * lib/wctype.in.h: Likewise.
+ * lib/c-vasprintf.h (c_aszprintf, c_vaszprintf, c_asprintf,
+ c_vasprintf): Move _GL_ATTRIBUTE_NODISCARD back to the beginning of the
+ declaration.
+
2024-07-29 Bruno Haible <bruno@clisp.org>
vaszprintf-posix tests: Fix a gcc warning.
# endif
_GL_FUNCDECL_RPL (inet_ntop, const char *,
(int af, const void *restrict src,
- char *restrict dst, socklen_t cnt)
+ char *restrict dst, socklen_t cnt),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (inet_ntop, const char *,
(int af, const void *restrict src,
# if !@HAVE_DECL_INET_NTOP@
_GL_FUNCDECL_SYS (inet_ntop, const char *,
(int af, const void *restrict src,
- char *restrict dst, socklen_t cnt)
+ char *restrict dst, socklen_t cnt),
_GL_ARG_NONNULL ((2, 3)));
# endif
/* Need to cast, because on NonStop Kernel, the fourth parameter is
# define inet_pton rpl_inet_pton
# endif
_GL_FUNCDECL_RPL (inet_pton, int,
- (int af, const char *restrict src, void *restrict dst)
+ (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_FUNCDECL_SYS (inet_pton, int,
- (int af, const char *restrict src, void *restrict dst)
+ (int af, const char *restrict src, void *restrict dst),
_GL_ARG_NONNULL ((2, 3)));
# endif
_GL_CXXALIAS_SYS (inet_pton, int,
# define _GL_EXTERN_C extern
#endif
-/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
+/* _GL_EXTERN_C_FUNC declaration;
+ performs the declaration of a function with C linkage. */
+#if defined __cplusplus
+# define _GL_EXTERN_C_FUNC extern "C"
+#else
+/* In C mode, omit the 'extern' keyword, because attributes in bracket syntax
+ are not allowed between 'extern' and the return type (see gnulib-common.m4).
+ */
+# define _GL_EXTERN_C_FUNC
+#endif
+
+/* _GL_FUNCDECL_RPL (func, rettype, parameters[, attributes]);
declares a replacement function, named rpl_func, with the given prototype,
consisting of return type, parameters, and attributes.
Example:
- _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
+ _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
because
[[...]] extern "C" <declaration>;
is invalid syntax in C++.)
+
+ Note: The attribute _GL_ATTRIBUTE_NOTHROW, if needed, must be placed outside
+ of the _GL_FUNCDECL_RPL invocation, at the end of the declaration.
*/
-#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
- _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
-#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
- _GL_EXTERN_C rettype rpl_func parameters_and_attributes
+#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_and_attributes);
+/* _GL_FUNCDECL_SYS (func, rettype, parameters[, attributes]);
declares the system function, named func, with the given prototype,
consisting of return type, parameters, and attributes.
Example:
- _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
+ _GL_FUNCDECL_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 _GL_FUNCDECL_SYS invocation, at the end of the declaration.
*/
-#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
- _GL_EXTERN_C rettype func parameters_and_attributes
+#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
Formatting takes place in the C locale, that is, the decimal point
used in floating-point formatting directives is always '.'. */
+_GL_ATTRIBUTE_NODISCARD
ptrdiff_t c_aszprintf (char **resultp, const char *format, ...)
- _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 3))
- _GL_ATTRIBUTE_NODISCARD;
+ _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 3));
+_GL_ATTRIBUTE_NODISCARD
ptrdiff_t c_vaszprintf (char **resultp, const char *format, va_list args)
- _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 0))
- _GL_ATTRIBUTE_NODISCARD;
+ _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 0));
/* Prints formatted output to a string dynamically allocated with malloc().
If the memory allocation succeeds, it stores the address of the string in
Formatting takes place in the C locale, that is, the decimal point
used in floating-point formatting directives is always '.'. */
+_GL_ATTRIBUTE_NODISCARD
int c_asprintf (char **resultp, const char *format, ...)
- _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 3))
- _GL_ATTRIBUTE_NODISCARD;
+ _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 3));
+_GL_ATTRIBUTE_NODISCARD
int c_vasprintf (char **resultp, const char *format, va_list args)
- _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 0))
- _GL_ATTRIBUTE_NODISCARD;
+ _GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_STANDARD, 2, 0));
#ifdef __cplusplus
}
# define closedir rpl_closedir
# define GNULIB_defined_closedir 1
# endif
-_GL_FUNCDECL_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_FUNCDECL_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 GNULIB_defined_opendir 1
# endif
_GL_FUNCDECL_RPL (opendir, DIR *,
- (const char *dir_name)
+ (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
_GL_FUNCDECL_SYS (opendir, DIR *,
- (const char *dir_name)
+ (const char *dir_name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
/* For -Wmismatched-dealloc: Associate opendir with closedir or
rpl_closedir. */
_GL_FUNCDECL_SYS (opendir, DIR *,
- (const char *dir_name)
+ (const char *dir_name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
# undef readdir
# define readdir rpl_readdir
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define fdopendir rpl_fdopendir
# endif
_GL_FUNCDECL_RPL (fdopendir, DIR *,
- (int fd)
+ (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
_GL_FUNCDECL_SYS (fdopendir, DIR *,
- (int fd)
+ (int fd),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
_GL_CXXALIAS_SYS (fdopendir, DIR *, (int fd));
/* For -Wmismatched-dealloc: Associate fdopendir with closedir or
rpl_closedir. */
_GL_FUNCDECL_SYS (fdopendir, DIR *,
- (int fd)
+ (int fd),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC (closedir, 1));
# endif
# if defined GNULIB_POSIXCHECK
_GL_FUNCDECL_SYS (scandir, int,
(const char *dir, struct dirent ***namelist,
int (*filter) (const struct dirent *),
- int (*cmp) (const struct dirent **, const struct dirent **))
+ int (*cmp) (const struct dirent **, const struct dirent **)),
_GL_ARG_NONNULL ((1, 2, 4)));
# endif
/* Need to cast, because on glibc systems, the fourth parameter is
/* Compare two 'struct dirent' entries alphabetically. */
# if !@HAVE_ALPHASORT@
_GL_FUNCDECL_SYS (alphasort, int,
- (const struct dirent **, const struct dirent **)
+ (const struct dirent **, const struct dirent **),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# endif
# define error rpl_error
# endif
_GL_FUNCDECL_RPL (error, void,
- (int __status, int __errnum, const char *__format, ...)
+ (int __status, int __errnum, const char *__format, ...),
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 3, 4)));
_GL_CXXALIAS_RPL (error, void,
(int __status, int __errnum, const char *__format, ...));
#else
# if ! @HAVE_ERROR@
_GL_FUNCDECL_SYS (error, void,
- (int __status, int __errnum, const char *__format, ...)
+ (int __status, int __errnum, const char *__format, ...),
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 3, 4)));
# endif
_GL_CXXALIAS_SYS (error, void,
# endif
_GL_FUNCDECL_RPL (error_at_line, void,
(int __status, int __errnum, const char *__filename,
- unsigned int __lineno, const char *__format, ...)
+ unsigned int __lineno, const char *__format, ...),
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 5, 6)));
_GL_CXXALIAS_RPL (error_at_line, void,
(int __status, int __errnum, const char *__filename,
# if ! @HAVE_ERROR_AT_LINE@
_GL_FUNCDECL_SYS (error_at_line, void,
(int __status, int __errnum, const char *__filename,
- unsigned int __lineno, const char *__format, ...)
+ unsigned int __lineno, const char *__format, ...),
_GL_ATTRIBUTE_FORMAT ((_GL_ATTRIBUTE_SPEC_PRINTF_ERROR, 5, 6)));
# endif
_GL_CXXALIAS_SYS (error_at_line, void,
# undef creat
# define creat rpl_creat
# endif
-_GL_FUNCDECL_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 open
# define open rpl_open
# endif
-_GL_FUNCDECL_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__
# define openat rpl_openat
# endif
_GL_FUNCDECL_RPL (openat, int,
- (int fd, char const *file, int flags, /* mode_t mode */ ...)
+ (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_FUNCDECL_SYS (openat, int,
- (int fd, char const *file, int flags, /* mode_t mode */ ...)
+ (int fd, char const *file, int flags, /* mode_t mode */ ...),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (openat, int,
# endif
# define GNULIB_defined_fnmatch_function 1
_GL_FUNCDECL_RPL (fnmatch, int,
- (const char *pattern, const char *name, int flags)
+ (const char *pattern, const char *name, int flags),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (fnmatch, int,
(const char *pattern, const char *name, int flags));
# if !@HAVE_FNMATCH@
# define GNULIB_defined_fnmatch_function 1
_GL_FUNCDECL_SYS (fnmatch, int,
- (const char *pattern, const char *name, int flags)
+ (const char *pattern, const char *name, int flags),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (fnmatch, int,
# if @REPLACE_GLOB@
_GL_FUNCDECL_RPL (glob, int, (const char *_Restrict_ __pattern, int __flags,
_gl_glob_errfunc_fn __errfunc,
- glob_t *_Restrict_ __pglob)
+ glob_t *_Restrict_ __pglob),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (glob, int, (const char *_Restrict_ __pattern, int __flags,
_gl_glob_errfunc_fn __errfunc,
# if !@HAVE_GLOB@
_GL_FUNCDECL_SYS (glob, int, (const char *_Restrict_ __pattern, int __flags,
_gl_glob_errfunc_fn __errfunc,
- glob_t *_Restrict_ __pglob)
+ glob_t *_Restrict_ __pglob),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (glob, int, (const char *_Restrict_ __pattern, int __flags,
#if @GNULIB_GLOB@
# if @REPLACE_GLOB@
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define iconv_open rpl_iconv_open
# endif
_GL_FUNCDECL_RPL (iconv_open, iconv_t,
- (const char *tocode, const char *fromcode)
+ (const char *tocode, const char *fromcode),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (iconv_open, iconv_t,
(const char *tocode, const char *fromcode));
# define strtoimax rpl_strtoimax
# endif
_GL_FUNCDECL_RPL (strtoimax, intmax_t,
- (const char *restrict, char **restrict, int)
+ (const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoimax, intmax_t,
(const char *restrict, char **restrict, int));
# if !@HAVE_DECL_STRTOIMAX@
# undef strtoimax
_GL_FUNCDECL_SYS (strtoimax, intmax_t,
- (const char *restrict, char **restrict, int)
+ (const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtoimax, intmax_t,
# define strtoumax rpl_strtoumax
# endif
_GL_FUNCDECL_RPL (strtoumax, uintmax_t,
- (const char *restrict, char **restrict, int)
+ (const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoumax, uintmax_t,
(const char *restrict, char **restrict, int));
# if !@HAVE_DECL_STRTOUMAX@
# undef strtoumax
_GL_FUNCDECL_SYS (strtoumax, uintmax_t,
- (const char *restrict, char **restrict, int)
+ (const char *restrict, char **restrict, int),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtoumax, uintmax_t,
# define GNULIB_defined_newlocale 1
# endif
_GL_FUNCDECL_RPL (newlocale, locale_t,
- (int category_mask, const char *name, locale_t base)
+ (int category_mask, const char *name, locale_t base),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (newlocale, locale_t,
(int category_mask, const char *name, locale_t base));
# define duplocale rpl_duplocale
# define GNULIB_defined_duplocale 1
# endif
-_GL_FUNCDECL_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_FUNCDECL_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@
# define memalign rpl_memalign
# endif
_GL_FUNCDECL_RPL (memalign, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (memalign, void *, (size_t alignment, size_t size));
/* For -Wmismatched-dealloc: Associate memalign with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (memalign, void *,
- (size_t alignment, size_t size)
- _GL_ATTRIBUTE_NOTHROW
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (memalign, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# endif
/* For -Wmismatched-dealloc: Associate memalign with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (memalign, void *,
- (size_t alignment, size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_DEALLOC_FREE);
+ (size_t alignment, size_t size),
+ _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (memalign, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
# undef frexpf
# define frexpf rpl_frexpf
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr),
+ _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr));
# else
_GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr));
# define frexpl rpl_frexpl
# endif
_GL_FUNCDECL_RPL (frexpl, long double,
- (long double x, int *expptr) _GL_ARG_NONNULL ((2)));
+ (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_FUNCDECL_SYS (frexpl, long double,
- (long double x, int *expptr) _GL_ARG_NONNULL ((2)));
+ (long double x, int *expptr), _GL_ARG_NONNULL ((2)));
# endif
# if @GNULIB_FREXPL@
_GL_CXXALIAS_SYS (frexpl, long double, (long double x, int *expptr));
# undef modff
# define modff rpl_modff
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_RPL (modf, double, (double x, double *iptr) _GL_ARG_NONNULL ((2)));
+_GL_FUNCDECL_RPL (modf, double, (double x, double *iptr),
+ _GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (modf, double, (double x, double *iptr));
# else
_GL_CXXALIAS_SYS (modf, double, (double x, double *iptr));
# undef modfl
# define modfl rpl_modfl
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (strfmon_l, ssize_t,
(char *restrict s, size_t maxsize, locale_t locale,
- const char *restrict format, ...)
+ const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_STRFMON (4, 5)
_GL_ARG_NONNULL ((4)));
_GL_CXXALIAS_RPL (strfmon_l, ssize_t,
(const char *restrict nodename,
const char *restrict servname,
const struct addrinfo *restrict hints,
- struct addrinfo **restrict res)
+ struct addrinfo **restrict res),
_GL_ARG_NONNULL ((4)));
_GL_CXXALIAS_RPL (getaddrinfo, int,
(const char *restrict nodename,
(const char *restrict nodename,
const char *restrict servname,
const struct addrinfo *restrict hints,
- struct addrinfo **restrict res)
+ struct addrinfo **restrict res),
_GL_ARG_NONNULL ((4)));
# endif
_GL_CXXALIAS_SYS (getaddrinfo, int,
# undef freeaddrinfo
# define freeaddrinfo rpl_freeaddrinfo
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
(const struct sockaddr *restrict sa, socklen_t salen,
char *restrict node, socklen_t nodelen,
char *restrict service, socklen_t servicelen,
- int flags)
+ int flags),
_GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on glibc systems, the seventh parameter is
_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),
_GL_ARG_NONNULL ((1, 3)));
_GL_CXXALIAS_RPL (pthread_create, int,
(pthread_t *restrict threadp,
_GL_FUNCDECL_SYS (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),
_GL_ARG_NONNULL ((1, 3)));
# endif
_GL_CXXALIAS_SYS_CAST (pthread_create, int,
# undef pthread_attr_init
# define pthread_attr_init rpl_pthread_attr_init
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# define pthread_attr_getdetachstate rpl_pthread_attr_getdetachstate
# endif
_GL_FUNCDECL_RPL (pthread_attr_getdetachstate, int,
- (const pthread_attr_t *attr, int *detachstatep)
+ (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_FUNCDECL_SYS (pthread_attr_getdetachstate, int,
- (const pthread_attr_t *attr, int *detachstatep)
+ (const pthread_attr_t *attr, int *detachstatep),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (pthread_attr_getdetachstate, int,
# define pthread_attr_setdetachstate rpl_pthread_attr_setdetachstate
# endif
_GL_FUNCDECL_RPL (pthread_attr_setdetachstate, int,
- (pthread_attr_t *attr, int detachstate)
+ (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_FUNCDECL_SYS (pthread_attr_setdetachstate, int,
- (pthread_attr_t *attr, int detachstate)
+ (pthread_attr_t *attr, int detachstate),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_attr_setdetachstate, int,
# undef pthread_attr_destroy
# define pthread_attr_destroy rpl_pthread_attr_destroy
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define pthread_once rpl_pthread_once
# endif
_GL_FUNCDECL_RPL (pthread_once, int,
- (pthread_once_t *once_control, void (*initfunction) (void))
+ (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_FUNCDECL_SYS (pthread_once, int,
- (pthread_once_t *once_control, void (*initfunction) (void))
+ (pthread_once_t *once_control, void (*initfunction) (void)),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS_CAST (pthread_once, int,
# endif
_GL_FUNCDECL_RPL (pthread_mutex_init, int,
(pthread_mutex_t *restrict mutex,
- const pthread_mutexattr_t *restrict attr)
+ const pthread_mutexattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_mutex_init, int,
(pthread_mutex_t *restrict mutex,
# if !@HAVE_PTHREAD_MUTEX_INIT@
_GL_FUNCDECL_SYS (pthread_mutex_init, int,
(pthread_mutex_t *restrict mutex,
- const pthread_mutexattr_t *restrict attr)
+ const pthread_mutexattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_init, int,
# undef pthread_mutexattr_init
# define pthread_mutexattr_init rpl_pthread_mutexattr_init
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_mutexattr_gettype, int,
(const pthread_mutexattr_t *restrict attr,
- int *restrict typep)
+ int *restrict typep),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_mutexattr_gettype, int,
(const pthread_mutexattr_t *restrict attr,
# if !@HAVE_PTHREAD_MUTEXATTR_GETTYPE@
_GL_FUNCDECL_SYS (pthread_mutexattr_gettype, int,
(const pthread_mutexattr_t *restrict attr,
- int *restrict typep)
+ int *restrict typep),
_GL_ARG_NONNULL ((1, 2)));
# endif
/* Need to cast, because on FreeBSD the first parameter is
# define pthread_mutexattr_settype rpl_pthread_mutexattr_settype
# endif
_GL_FUNCDECL_RPL (pthread_mutexattr_settype, int,
- (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (pthread_mutexattr_settype, int,
- (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
+ (pthread_mutexattr_t *attr, int type), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutexattr_settype, int,
(pthread_mutexattr_t *attr, int type));
# endif
_GL_FUNCDECL_RPL (pthread_mutexattr_getrobust, int,
(const pthread_mutexattr_t *restrict attr,
- int *restrict robustp)
+ int *restrict robustp),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_mutexattr_getrobust, int,
(const pthread_mutexattr_t *restrict attr,
# if !@HAVE_PTHREAD_MUTEXATTR_GETROBUST@
_GL_FUNCDECL_SYS (pthread_mutexattr_getrobust, int,
(const pthread_mutexattr_t *restrict attr,
- int *restrict robustp)
+ int *restrict robustp),
_GL_ARG_NONNULL ((1, 2)));
# endif
/* Need to cast, because on FreeBSD the first parameter is
# define pthread_mutexattr_setrobust rpl_pthread_mutexattr_setrobust
# endif
_GL_FUNCDECL_RPL (pthread_mutexattr_setrobust, int,
- (pthread_mutexattr_t *attr, int robust)
+ (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_FUNCDECL_SYS (pthread_mutexattr_setrobust, int,
- (pthread_mutexattr_t *attr, int robust)
+ (pthread_mutexattr_t *attr, int robust),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_mutexattr_setrobust, int,
# undef pthread_mutexattr_destroy
# define pthread_mutexattr_destroy rpl_pthread_mutexattr_destroy
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_mutex_timedlock, int,
(pthread_mutex_t *restrict mutex,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_mutex_timedlock, int,
(pthread_mutex_t *restrict mutex,
# if !@HAVE_PTHREAD_MUTEX_TIMEDLOCK@
_GL_FUNCDECL_SYS (pthread_mutex_timedlock, int,
(pthread_mutex_t *restrict mutex,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (pthread_mutex_timedlock, int,
# undef pthread_mutex_unlock
# define pthread_mutex_unlock rpl_pthread_mutex_unlock
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_rwlock_init, int,
(pthread_rwlock_t *restrict lock,
- const pthread_rwlockattr_t *restrict attr)
+ const pthread_rwlockattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_rwlock_init, int,
(pthread_rwlock_t *restrict lock,
# if !@HAVE_PTHREAD_RWLOCK_INIT@
_GL_FUNCDECL_SYS (pthread_rwlock_init, int,
(pthread_rwlock_t *restrict lock,
- const pthread_rwlockattr_t *restrict attr)
+ const pthread_rwlockattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_init, int,
# undef pthread_rwlockattr_init
# define pthread_rwlockattr_init rpl_pthread_rwlockattr_init
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# define pthread_rwlockattr_destroy rpl_pthread_rwlockattr_destroy
# endif
_GL_FUNCDECL_RPL (pthread_rwlockattr_destroy, int,
- (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (pthread_rwlockattr_destroy, int,
- (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
+ (pthread_rwlockattr_t *attr), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlockattr_destroy, int,
(pthread_rwlockattr_t *attr));
# undef pthread_rwlock_rdlock
# define pthread_rwlock_rdlock rpl_pthread_rwlock_rdlock
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_rwlock_timedrdlock, int,
(pthread_rwlock_t *restrict lock,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_rwlock_timedrdlock, int,
(pthread_rwlock_t *restrict lock,
# if !@HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK@
_GL_FUNCDECL_SYS (pthread_rwlock_timedrdlock, int,
(pthread_rwlock_t *restrict lock,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_timedrdlock, int,
# endif
_GL_FUNCDECL_RPL (pthread_rwlock_timedwrlock, int,
(pthread_rwlock_t *restrict lock,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_rwlock_timedwrlock, int,
(pthread_rwlock_t *restrict lock,
# if !@HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK@
_GL_FUNCDECL_SYS (pthread_rwlock_timedwrlock, int,
(pthread_rwlock_t *restrict lock,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (pthread_rwlock_timedwrlock, int,
# undef pthread_rwlock_unlock
# define pthread_rwlock_unlock rpl_pthread_rwlock_unlock
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_cond_init, int,
(pthread_cond_t *restrict cond,
- const pthread_condattr_t *restrict attr)
+ const pthread_condattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (pthread_cond_init, int,
(pthread_cond_t *restrict cond,
# if !@HAVE_PTHREAD_COND_INIT@
_GL_FUNCDECL_SYS (pthread_cond_init, int,
(pthread_cond_t *restrict cond,
- const pthread_condattr_t *restrict attr)
+ const pthread_condattr_t *restrict attr),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_init, int,
# undef pthread_condattr_init
# define pthread_condattr_init rpl_pthread_condattr_init
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (pthread_cond_wait, int,
(pthread_cond_t *restrict cond,
- pthread_mutex_t *restrict mutex)
+ pthread_mutex_t *restrict mutex),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (pthread_cond_wait, int,
(pthread_cond_t *restrict cond,
# if !@HAVE_PTHREAD_COND_WAIT@
_GL_FUNCDECL_SYS (pthread_cond_wait, int,
(pthread_cond_t *restrict cond,
- pthread_mutex_t *restrict mutex)
+ pthread_mutex_t *restrict mutex),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_wait, 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),
_GL_ARG_NONNULL ((1, 2, 3)));
_GL_CXXALIAS_RPL (pthread_cond_timedwait, int,
(pthread_cond_t *restrict cond,
_GL_FUNCDECL_SYS (pthread_cond_timedwait, int,
(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
- const struct timespec *restrict abstime)
+ const struct timespec *restrict abstime),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
_GL_CXXALIAS_SYS (pthread_cond_timedwait, int,
# undef pthread_cond_signal
# define pthread_cond_signal rpl_pthread_cond_signal
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define pthread_key_create rpl_pthread_key_create
# endif
_GL_FUNCDECL_RPL (pthread_key_create, int,
- (pthread_key_t *keyp, void (*destructor) (void *))
+ (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_FUNCDECL_SYS (pthread_key_create, int,
- (pthread_key_t *keyp, void (*destructor) (void *))
+ (pthread_key_t *keyp, void (*destructor) (void *)),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS_CAST (pthread_key_create, int,
# define pthread_spin_init rpl_pthread_spin_init
# endif
_GL_FUNCDECL_RPL (pthread_spin_init, int,
- (pthread_spinlock_t *lock, int shared_across_processes)
+ (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_FUNCDECL_SYS (pthread_spin_init, int,
- (pthread_spinlock_t *lock, int shared_across_processes)
+ (pthread_spinlock_t *lock, int shared_across_processes),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (pthread_spin_init, int,
# undef pthread_spin_lock
# define pthread_spin_lock rpl_pthread_spin_lock
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# if @REPLACE_TSEARCH@
_GL_FUNCDECL_RPL (tsearch, void *,
(const void *key, void **vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_GL_CXXALIAS_RPL (tsearch, void *,
(const void *key, void **vrootp,
# if !@HAVE_TSEARCH@
_GL_FUNCDECL_SYS (tsearch, void *,
(const void *key, void **vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
_GL_CXXALIAS_SYS (tsearch, void *,
# if @REPLACE_TSEARCH@
_GL_FUNCDECL_RPL (tfind, void *,
(const void *key, void *const *vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_GL_CXXALIAS_RPL (tfind, void *,
(const void *key, void *const *vrootp,
# if !@HAVE_TSEARCH@
_GL_FUNCDECL_SYS (tfind, void *,
(const void *key, void *const *vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
/* Need to cast, because on Cygwin 1.5.x systems, the second parameter is
# if @REPLACE_TSEARCH@
_GL_FUNCDECL_RPL (tdelete, void *,
(const void *restrict key, void **restrict vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
_GL_CXXALIAS_RPL (tdelete, void *,
(const void *restrict key, void **restrict vrootp,
# if !@HAVE_TSEARCH@
_GL_FUNCDECL_SYS (tdelete, void *,
(const void *restrict key, void **restrict vrootp,
- _gl_search_compar_fn compar)
+ _gl_search_compar_fn compar),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
_GL_CXXALIAS_SYS (tdelete, void *,
3. the level of the node in the tree (0 for the root). */
# if @REPLACE_TWALK@
_GL_FUNCDECL_RPL (twalk, void,
- (const void *vroot, _gl_search_action_fn action)
+ (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_FUNCDECL_SYS (twalk, void,
- (const void *vroot, _gl_search_action_fn action)
+ (const void *vroot, _gl_search_action_fn action),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (twalk, void,
# undef sigismember
# endif
# else
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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);
const posix_spawn_file_actions_t *_Restrict_ __file_actions,
const posix_spawnattr_t *_Restrict_ __attrp,
char *const argv[_Restrict_arr_],
- char *const envp[_Restrict_arr_])
+ char *const envp[_Restrict_arr_]),
_GL_ARG_NONNULL ((2, 5, 6)));
_GL_CXXALIAS_RPL (posix_spawn, int,
(pid_t *_Restrict_ __pid,
const posix_spawn_file_actions_t *_Restrict_ __file_actions,
const posix_spawnattr_t *_Restrict_ __attrp,
char *const argv[_Restrict_arr_],
- char *const envp[_Restrict_arr_])
+ char *const envp[_Restrict_arr_]),
_GL_ARG_NONNULL ((2, 5, 6)));
# endif
_GL_CXXALIAS_SYS (posix_spawn, 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[])
+ char *const argv[], char *const envp[]),
_GL_ARG_NONNULL ((2, 5, 6)));
_GL_CXXALIAS_RPL (posix_spawnp, int,
(pid_t *__pid, const char *__file,
(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[])
+ char *const argv[], char *const envp[]),
_GL_ARG_NONNULL ((2, 5, 6)));
# endif
_GL_CXXALIAS_SYS (posix_spawnp, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_init rpl_posix_spawnattr_init
# endif
-_GL_FUNCDECL_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)
- __THROW _GL_ARG_NONNULL ((1)));
+_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_FUNCDECL_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)
- __THROW _GL_ARG_NONNULL ((1)));
+_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));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define posix_spawnattr_destroy rpl_posix_spawnattr_destroy
# endif
-_GL_FUNCDECL_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)
- __THROW _GL_ARG_NONNULL ((1)));
+_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_FUNCDECL_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)
- __THROW _GL_ARG_NONNULL ((1)));
+_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));
# endif
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- sigset_t *_Restrict_ __sigdefault)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ sigset_t *_Restrict_ __sigdefault),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigdefault));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- sigset_t *_Restrict_ __sigdefault)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ sigset_t *_Restrict_ __sigdefault),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getsigdefault, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const sigset_t *_Restrict_ __sigdefault)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const sigset_t *_Restrict_ __sigdefault),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigdefault));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const sigset_t *_Restrict_ __sigdefault)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const sigset_t *_Restrict_ __sigdefault),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setsigdefault, int,
(posix_spawnattr_t *_Restrict_ __attr,
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- sigset_t *_Restrict_ __sigmask)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ sigset_t *_Restrict_ __sigmask),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
sigset_t *_Restrict_ __sigmask));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- sigset_t *_Restrict_ __sigmask)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ sigset_t *_Restrict_ __sigmask),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getsigmask, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const sigset_t *_Restrict_ __sigmask)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const sigset_t *_Restrict_ __sigmask),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
const sigset_t *_Restrict_ __sigmask));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const sigset_t *_Restrict_ __sigmask)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const sigset_t *_Restrict_ __sigmask),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setsigmask, int,
(posix_spawnattr_t *_Restrict_ __attr,
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- short int *_Restrict_ __flags)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ short int *_Restrict_ __flags),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
short int *_Restrict_ __flags));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- short int *_Restrict_ __flags)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ short int *_Restrict_ __flags),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getflags, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# define posix_spawnattr_setflags rpl_posix_spawnattr_setflags
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setflags, int,
- (posix_spawnattr_t *__attr, short int __flags)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawnattr_setflags, int,
- (posix_spawnattr_t *__attr, short int __flags)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawnattr_t *__attr, short int __flags),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setflags, int,
(posix_spawnattr_t *__attr, short int __flags));
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- pid_t *_Restrict_ __pgroup)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ pid_t *_Restrict_ __pgroup),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
pid_t *_Restrict_ __pgroup));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- pid_t *_Restrict_ __pgroup)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ pid_t *_Restrict_ __pgroup),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getpgroup, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# define posix_spawnattr_setpgroup rpl_posix_spawnattr_setpgroup
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setpgroup, int,
- (posix_spawnattr_t *__attr, pid_t __pgroup)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawnattr_setpgroup, int,
- (posix_spawnattr_t *__attr, pid_t __pgroup)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawnattr_t *__attr, pid_t __pgroup),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setpgroup, int,
(posix_spawnattr_t *__attr, pid_t __pgroup));
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- int *_Restrict_ __schedpolicy)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ int *_Restrict_ __schedpolicy),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
int *_Restrict_ __schedpolicy));
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDULER == 0
_GL_FUNCDECL_SYS (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- int *_Restrict_ __schedpolicy)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ int *_Restrict_ __schedpolicy),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getschedpolicy, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# define posix_spawnattr_setschedpolicy rpl_posix_spawnattr_setschedpolicy
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setschedpolicy, int,
- (posix_spawnattr_t *__attr, int __schedpolicy)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawnattr_setschedpolicy, int,
- (posix_spawnattr_t *__attr, int __schedpolicy)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawnattr_t *__attr, int __schedpolicy),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setschedpolicy, int,
(posix_spawnattr_t *__attr, int __schedpolicy));
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- struct sched_param *_Restrict_ __schedparam)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ struct sched_param *_Restrict_ __schedparam),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
struct sched_param *_Restrict_ __schedparam));
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0
_GL_FUNCDECL_SYS (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
- struct sched_param *_Restrict_ __schedparam)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ struct sched_param *_Restrict_ __schedparam),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_getschedparam, int,
(const posix_spawnattr_t *_Restrict_ __attr,
# endif
_GL_FUNCDECL_RPL (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const struct sched_param *_Restrict_ __schedparam)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const struct sched_param *_Restrict_ __schedparam),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
const struct sched_param *_Restrict_ __schedparam));
# if !@HAVE_POSIX_SPAWN@ || POSIX_SPAWN_SETSCHEDPARAM == 0
_GL_FUNCDECL_SYS (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
- const struct sched_param *_Restrict_ __schedparam)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const struct sched_param *_Restrict_ __schedparam),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawnattr_setschedparam, int,
(posix_spawnattr_t *_Restrict_ __attr,
# define posix_spawn_file_actions_init rpl_posix_spawn_file_actions_init
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_init, int,
- (posix_spawn_file_actions_t *__file_actions)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawn_file_actions_init, int,
- (posix_spawn_file_actions_t *__file_actions)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawn_file_actions_t *__file_actions),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_init, int,
(posix_spawn_file_actions_t *__file_actions));
# define posix_spawn_file_actions_destroy rpl_posix_spawn_file_actions_destroy
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_destroy, int,
- (posix_spawn_file_actions_t *__file_actions)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawn_file_actions_destroy, int,
- (posix_spawn_file_actions_t *__file_actions)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawn_file_actions_t *__file_actions),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_destroy, int,
(posix_spawn_file_actions_t *__file_actions));
_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)
- __THROW _GL_ARG_NONNULL ((1, 3)));
+ const char *_Restrict_ __path, int __oflag, mode_t __mode),
+ _GL_ARG_NONNULL ((1, 3))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_addopen, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd,
_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)
- __THROW _GL_ARG_NONNULL ((1, 3)));
+ const char *_Restrict_ __path, int __oflag, mode_t __mode),
+ _GL_ARG_NONNULL ((1, 3))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_addopen, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
# define posix_spawn_file_actions_addclose rpl_posix_spawn_file_actions_addclose
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_addclose, int,
- (posix_spawn_file_actions_t *__file_actions, int __fd)
- __THROW _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (posix_spawn_file_actions_addclose, int,
- (posix_spawn_file_actions_t *__file_actions, int __fd)
- __THROW _GL_ARG_NONNULL ((1)));
+ (posix_spawn_file_actions_t *__file_actions, int __fd),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_addclose, int,
(posix_spawn_file_actions_t *__file_actions, int __fd));
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
- int __fd, int __newfd)
- __THROW _GL_ARG_NONNULL ((1)));
+ int __fd, int __newfd),
+ _GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
int __fd, int __newfd));
# if !@HAVE_POSIX_SPAWN@
_GL_FUNCDECL_SYS (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
- int __fd, int __newfd)
- __THROW _GL_ARG_NONNULL ((1)));
+ int __fd, int __newfd),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_adddup2, int,
(posix_spawn_file_actions_t *__file_actions,
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
- const char *_Restrict_ __path)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const char *_Restrict_ __path),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
const char *_Restrict_ __path));
# if !@HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR@
_GL_FUNCDECL_SYS (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
- const char *_Restrict_ __path)
- __THROW _GL_ARG_NONNULL ((1, 2)));
+ const char *_Restrict_ __path),
+ _GL_ARG_NONNULL ((1, 2))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_addchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
# endif
_GL_FUNCDECL_RPL (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
- int __fd)
- __THROW _GL_ARG_NONNULL ((1)));
+ int __fd),
+ _GL_ARG_NONNULL ((1))) __THROW;
_GL_CXXALIAS_RPL (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
int __fd));
# if !@HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR@
_GL_FUNCDECL_SYS (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
- int __fd)
- __THROW _GL_ARG_NONNULL ((1)));
+ int __fd),
+ _GL_ARG_NONNULL ((1))) __THROW;
# endif
_GL_CXXALIAS_SYS (posix_spawn_file_actions_addfchdir, int,
(posix_spawn_file_actions_t *_Restrict_ __file_actions,
directives nor widths, the only possible failure codes are ENOMEM
and the possible failure codes from write(), excluding EINTR. */
_GL_FUNCDECL_SYS (dzprintf, off64_t,
- (int fd, const char *restrict format, ...)
+ (int fd, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_SYS (dzprintf, off64_t,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define dprintf rpl_dprintf
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define fdopen rpl_fdopen
# endif
_GL_FUNCDECL_RPL (fdopen, FILE *,
- (int fd, const char *mode)
+ (int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD);
/* For -Wmismatched-dealloc: Associate fdopen with fclose or rpl_fclose. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (fdopen, FILE *,
- (int fd, const char *mode)
- _GL_ATTRIBUTE_NOTHROW
+ (int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (fdopen, FILE *,
- (int fd, const char *mode)
+ (int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD);
/* For -Wmismatched-dealloc: Associate fdopen with fclose or rpl_fclose. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (fdopen, FILE *,
- (int fd, const char *mode)
- _GL_ATTRIBUTE_NOTHROW
+ (int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
- _GL_ATTRIBUTE_MALLOC);
+ _GL_ATTRIBUTE_MALLOC)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (fdopen, FILE *,
- (int fd, const char *mode)
+ (int fd, const char *mode),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC);
# endif
# undef fgetc
# define fgetc rpl_fgetc
# endif
-_GL_FUNCDECL_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));
# define fgets rpl_fgets
# endif
_GL_FUNCDECL_RPL (fgets, char *,
- (char *restrict s, int n, FILE *restrict stream)
+ (char *restrict s, int n, FILE *restrict stream),
_GL_ARG_NONNULL ((1, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fgets, char *,
(char *restrict s, int n, FILE *restrict stream));
# define fopen rpl_fopen
# endif
_GL_FUNCDECL_RPL (fopen, FILE *,
- (const char *restrict filename, const char *restrict mode)
+ (const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fopen, FILE *,
# if __GNUC__ >= 11
/* For -Wmismatched-dealloc: Associate fopen with fclose or rpl_fclose. */
_GL_FUNCDECL_SYS (fopen, FILE *,
- (const char *restrict filename, const char *restrict mode)
+ (const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_NODISCARD);
# endif
# if @GNULIB_FCLOSE@ && __GNUC__ >= 11 && !defined fopen
/* For -Wmismatched-dealloc: Associate fopen with fclose or rpl_fclose. */
_GL_FUNCDECL_SYS (fopen, FILE *,
- (const char *restrict filename, const char *restrict mode)
+ (const char *restrict filename, const char *restrict mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (fclose, 1));
# endif
# if defined GNULIB_POSIXCHECK
directives nor widths, the only possible failure causes are ENOMEM
and the possible failure causes from fwrite(). */
_GL_FUNCDECL_SYS (fzprintf, off64_t,
- (FILE *restrict fp, const char *restrict format, ...)
+ (FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (fzprintf, off64_t,
# define GNULIB_overrides_fprintf 1
# if @GNULIB_FPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@
_GL_FUNCDECL_RPL (fprintf, int,
- (FILE *restrict fp, const char *restrict format, ...)
+ (FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# else
_GL_FUNCDECL_RPL (fprintf, int,
- (FILE *restrict fp, const char *restrict format, ...)
+ (FILE *restrict fp, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# endif
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define fpurge rpl_fpurge
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define fputs rpl_fputs
# endif
_GL_FUNCDECL_RPL (fputs, int,
- (const char *restrict string, FILE *restrict stream)
+ (const char *restrict string, FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (fputs, int,
(const char *restrict string, FILE *restrict stream));
# endif
_GL_FUNCDECL_RPL (fread, size_t,
(void *restrict ptr, size_t s, size_t n,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((4)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fread, size_t,
(void *restrict ptr, size_t s, size_t n,
# endif
_GL_FUNCDECL_RPL (freopen, FILE *,
(const char *restrict filename, const char *restrict mode,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (freopen, FILE *,
(const char *restrict filename, const char *restrict mode,
# define fscanf rpl_fscanf
# endif
_GL_FUNCDECL_RPL (fscanf, int,
- (FILE *restrict stream, const char *restrict format, ...)
+ (FILE *restrict stream, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 3)
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (fscanf, int,
# undef fseek
# define fseek rpl_fseek
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (fwrite, size_t,
(const void *restrict ptr, size_t s, size_t n,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((1, 4)));
_GL_CXXALIAS_RPL (fwrite, size_t,
(const void *restrict ptr, size_t s, size_t n,
# undef getc
# define getc rpl_fgetc
# endif
-_GL_FUNCDECL_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));
_GL_FUNCDECL_RPL (getdelim, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
int delimiter,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 4)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getdelim, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
_GL_FUNCDECL_SYS (getdelim, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
int delimiter,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 4)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getdelim, ssize_t,
# endif
_GL_FUNCDECL_RPL (getline, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getline, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
# if !@HAVE_DECL_GETLINE@
_GL_FUNCDECL_SYS (getline, ssize_t,
(char **restrict lineptr, size_t *restrict linesize,
- FILE *restrict stream)
+ FILE *restrict stream),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getline, ssize_t,
directives nor widths, the only possible failure code is through
obstack_alloc_failed_handler. */
_GL_FUNCDECL_SYS (obstack_zprintf, ptrdiff_t,
- (struct obstack *obs, const char *format, ...)
+ (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_FUNCDECL_SYS (obstack_vzprintf, ptrdiff_t,
- (struct obstack *obs, const char *format, va_list args)
+ (struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (obstack_vzprintf, ptrdiff_t,
# define obstack_printf rpl_obstack_printf
# endif
_GL_FUNCDECL_RPL (obstack_printf, int,
- (struct obstack *obs, const char *format, ...)
+ (struct obstack *obs, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (obstack_printf, int,
# else
# if !@HAVE_DECL_OBSTACK_PRINTF@
_GL_FUNCDECL_SYS (obstack_printf, int,
- (struct obstack *obs, const char *format, ...)
+ (struct obstack *obs, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
# endif
# define obstack_vprintf rpl_obstack_vprintf
# endif
_GL_FUNCDECL_RPL (obstack_vprintf, int,
- (struct obstack *obs, const char *format, va_list args)
+ (struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (obstack_vprintf, int,
# else
# if !@HAVE_DECL_OBSTACK_PRINTF@
_GL_FUNCDECL_SYS (obstack_vprintf, int,
- (struct obstack *obs, const char *format, va_list args)
+ (struct obstack *obs, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
# endif
#if @GNULIB_PCLOSE@
# if !@HAVE_PCLOSE@
-_GL_FUNCDECL_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);
# define popen rpl_popen
# endif
_GL_FUNCDECL_RPL (popen, FILE *,
- (const char *cmd, const char *mode)
+ (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
_GL_FUNCDECL_SYS (popen, FILE *,
- (const char *cmd, const char *mode)
+ (const char *cmd, const char *mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (pclose, 1)
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_NODISCARD);
# endif
# if @GNULIB_PCLOSE@ && __GNUC__ >= 11 && !defined popen
/* For -Wmismatched-dealloc: Associate popen with pclose or rpl_pclose. */
_GL_FUNCDECL_SYS (popen, FILE *,
- (const char *cmd, const char *mode)
+ (const char *cmd, const char *mode),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_DEALLOC (pclose, 1)
_GL_ATTRIBUTE_MALLOC);
# 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_FUNCDECL_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, ...));
_GL_FUNCDECL_RPL_1 (__printf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
- _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf))
+ _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 2)
_GL_ARG_NONNULL ((1)));
# else
_GL_FUNCDECL_RPL_1 (__printf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
- _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf))
+ _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 2)
_GL_ARG_NONNULL ((1)));
# endif
# define printf rpl_printf
# endif
_GL_FUNCDECL_RPL (printf, int,
- (const char *restrict format, ...)
+ (const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 2)
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (printf, int, (const char *restrict format, ...));
# undef putc
# define putc rpl_fputc
# endif
-_GL_FUNCDECL_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 puts
# define puts rpl_puts
# endif
-_GL_FUNCDECL_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));
# undef remove
# define remove rpl_remove
# endif
-_GL_FUNCDECL_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));
# define rename rpl_rename
# endif
_GL_FUNCDECL_RPL (rename, int,
- (const char *old_filename, const char *new_filename)
+ (const char *old_filename, const char *new_filename),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (rename, int,
(const char *old_filename, const char *new_filename));
# define renameat rpl_renameat
# endif
_GL_FUNCDECL_RPL (renameat, int,
- (int fd1, char const *file1, int fd2, char const *file2)
+ (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_FUNCDECL_SYS (renameat, int,
- (int fd1, char const *file1, int fd2, char const *file2)
+ (int fd1, char const *file1, int fd2, char const *file2),
_GL_ARG_NONNULL ((2, 4)));
# endif
_GL_CXXALIAS_SYS (renameat, int,
_GL_FUNCDECL_RPL_1 (__scanf__, int,
(const char *restrict format, ...)
__asm__ (@ASM_SYMBOL_PREFIX@
- _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_scanf))
+ _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_scanf)),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2)
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL_1 (scanf, __scanf__, int, (const char *restrict format, ...));
# undef scanf
# define scanf rpl_scanf
# endif
-_GL_FUNCDECL_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, ...));
directives nor widths, the only possible failure code is ENOMEM. */
_GL_FUNCDECL_SYS (snzprintf, ptrdiff_t,
(char *restrict str, size_t size,
- const char *restrict format, ...)
+ const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
_GL_ARG_NONNULL ((3)));
_GL_CXXALIAS_SYS (snzprintf, ptrdiff_t,
# define GNULIB_overrides_snprintf 1
_GL_FUNCDECL_RPL (snprintf, int,
(char *restrict str, size_t size,
- const char *restrict format, ...)
+ const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
_GL_ARG_NONNULL ((3)));
_GL_CXXALIAS_RPL (snprintf, int,
# if !@HAVE_DECL_SNPRINTF@
_GL_FUNCDECL_SYS (snprintf, int,
(char *restrict str, size_t size,
- const char *restrict format, ...)
+ const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 4)
_GL_ARG_NONNULL ((3)));
# endif
directives nor widths, the only possible failure code is ENOMEM. */
_GL_FUNCDECL_SYS (szprintf, ptrdiff_t,
(char *restrict str,
- const char *restrict format, ...)
+ const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (szprintf, ptrdiff_t,
# endif
# define GNULIB_overrides_sprintf 1
_GL_FUNCDECL_RPL (sprintf, int,
- (char *restrict str, const char *restrict format, ...)
+ (char *restrict str, const char *restrict format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (sprintf, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define tmpfile rpl_tmpfile
# endif
-_GL_FUNCDECL_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
/* For -Wmismatched-dealloc: Associate tmpfile with fclose or rpl_fclose. */
-_GL_FUNCDECL_SYS (tmpfile, FILE *, (void)
+_GL_FUNCDECL_SYS (tmpfile, FILE *, (void),
_GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC
_GL_ATTRIBUTE_NODISCARD);
#else
# if @GNULIB_FCLOSE@ && __GNUC__ >= 11 && !defined tmpfile
/* For -Wmismatched-dealloc: Associate tmpfile with fclose or rpl_fclose. */
-_GL_FUNCDECL_SYS (tmpfile, FILE *, (void)
+_GL_FUNCDECL_SYS (tmpfile, FILE *, (void),
_GL_ATTRIBUTE_DEALLOC (fclose, 1)
_GL_ATTRIBUTE_MALLOC);
# endif
Therefore, if the format string is valid and does not use %ls/%lc
directives nor widths, the only possible failure code is ENOMEM. */
_GL_FUNCDECL_SYS (aszprintf, ptrdiff_t,
- (char **result, const char *format, ...)
+ (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_FUNCDECL_SYS (vaszprintf, ptrdiff_t,
- (char **result, const char *format, va_list args)
+ (char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
# endif
# define GNULIB_overrides_asprintf
_GL_FUNCDECL_RPL (asprintf, int,
- (char **result, const char *format, ...)
+ (char **result, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
# else
# if !@HAVE_VASPRINTF@
_GL_FUNCDECL_SYS (asprintf, int,
- (char **result, const char *format, ...)
+ (char **result, const char *format, ...),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 3)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
# endif
# define GNULIB_overrides_vasprintf 1
_GL_FUNCDECL_RPL (vasprintf, int,
- (char **result, const char *format, va_list args)
+ (char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
# else
# if !@HAVE_VASPRINTF@
_GL_FUNCDECL_SYS (vasprintf, int,
- (char **result, const char *format, va_list args)
+ (char **result, const char *format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2))
_GL_ATTRIBUTE_NODISCARD);
directives nor widths, the only possible failure codes are ENOMEM
and the possible failure codes from write(), excluding EINTR. */
_GL_FUNCDECL_SYS (vdzprintf, off64_t,
- (int fd, const char *restrict format, va_list args)
+ (int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_SYS (vdzprintf, off64_t,
# define vdprintf rpl_vdprintf
# endif
_GL_FUNCDECL_RPL (vdprintf, int,
- (int fd, const char *restrict format, va_list args)
+ (int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (vdprintf, int,
# else
# if !@HAVE_VDPRINTF@
_GL_FUNCDECL_SYS (vdprintf, int,
- (int fd, const char *restrict format, va_list args)
+ (int fd, const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((2)));
# endif
and the possible failure causes from fwrite(). */
_GL_FUNCDECL_SYS (vfzprintf, off64_t,
(FILE *restrict fp,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (vfzprintf, off64_t,
# if @GNULIB_VFPRINTF_POSIX@
_GL_FUNCDECL_RPL (vfprintf, int,
(FILE *restrict fp,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
# else
_GL_FUNCDECL_RPL (vfprintf, int,
(FILE *restrict fp,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 0)
_GL_ARG_NONNULL ((1, 2)));
# endif
# endif
_GL_FUNCDECL_RPL (vfscanf, int,
(FILE *restrict stream,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 0)
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (vfscanf, int,
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_FUNCDECL_SYS (vzprintf, off64_t, (const char *restrict format, va_list args)
- _GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 0)
- _GL_ARG_NONNULL ((1)));
+_GL_FUNCDECL_SYS (vzprintf, off64_t,
+ (const char *restrict format, va_list args),
+ _GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (1, 0)
+ _GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_SYS (vzprintf, off64_t,
(const char *restrict format, va_list args));
#endif
# endif
# define GNULIB_overrides_vprintf 1
# if @GNULIB_VPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
directives nor widths, the only possible failure code is ENOMEM. */
_GL_FUNCDECL_SYS (vsnzprintf, ptrdiff_t,
(char *restrict str, size_t size,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
_GL_ARG_NONNULL ((3)));
_GL_CXXALIAS_SYS (vsnzprintf, ptrdiff_t,
# define GNULIB_overrides_vsnprintf 1
_GL_FUNCDECL_RPL (vsnprintf, int,
(char *restrict str, size_t size,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
_GL_ARG_NONNULL ((3)));
_GL_CXXALIAS_RPL (vsnprintf, int,
# if !@HAVE_DECL_VSNPRINTF@
_GL_FUNCDECL_SYS (vsnprintf, int,
(char *restrict str, size_t size,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (3, 0)
_GL_ARG_NONNULL ((3)));
# endif
directives nor widths, the only possible failure code is ENOMEM. */
_GL_FUNCDECL_SYS (vszprintf, ptrdiff_t,
(char *restrict str,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_SYS (vszprintf, ptrdiff_t,
# define GNULIB_overrides_vsprintf 1
_GL_FUNCDECL_RPL (vsprintf, int,
(char *restrict str,
- const char *restrict format, va_list args)
+ const char *restrict format, va_list args),
_GL_ATTRIBUTE_FORMAT_PRINTF_STANDARD (2, 0)
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (vsprintf, int,
# 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));
# endif
# define aligned_alloc rpl_aligned_alloc
# endif
_GL_FUNCDECL_RPL (aligned_alloc, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (aligned_alloc, void *, (size_t alignment, size_t size));
/* For -Wmismatched-dealloc: Associate aligned_alloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 16) > 2
_GL_FUNCDECL_SYS (aligned_alloc, void *,
- (size_t alignment, size_t size)
- _GL_ATTRIBUTE_NOTHROW
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (aligned_alloc, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# endif
/* For -Wmismatched-dealloc: Associate aligned_alloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 16) > 2
_GL_FUNCDECL_SYS (aligned_alloc, void *,
- (size_t alignment, size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (size_t alignment, size_t size),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (aligned_alloc, void *,
- (size_t alignment, size_t size)
+ (size_t alignment, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
Returns the value of the integer. Errors are not detected. */
# if !@HAVE_ATOLL@
_GL_FUNCDECL_SYS (atoll, long long,
- (const char *string)
+ (const char *string),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
# define calloc rpl_calloc
# endif
_GL_FUNCDECL_RPL (calloc, void *,
- (size_t nmemb, size_t size)
+ (size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (calloc, void *, (size_t nmemb, size_t size));
/* For -Wmismatched-dealloc: Associate calloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (calloc, void *,
- (size_t nmemb, size_t size)
- _GL_ATTRIBUTE_NOTHROW
+ (size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (calloc, void *,
- (size_t nmemb, size_t size)
+ (size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# endif
/* For -Wmismatched-dealloc: Associate calloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (calloc, void *,
- (size_t nmemb, size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (size_t nmemb, size_t size),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (calloc, void *,
- (size_t nmemb, size_t size)
+ (size_t nmemb, size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
# define canonicalize_file_name rpl_canonicalize_file_name
# endif
_GL_FUNCDECL_RPL (canonicalize_file_name, char *,
- (const char *name)
+ (const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# if !@HAVE_CANONICALIZE_FILE_NAME@ || __GNUC__ >= 11
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
- (const char *name)
- _GL_ATTRIBUTE_NOTHROW
+ (const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
- (const char *name)
+ (const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
- (const char *name)
- _GL_ATTRIBUTE_NOTHROW
+ (const char *name),
_GL_ARG_NONNULL ((1))
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (canonicalize_file_name, char *,
- (const char *name)
+ (const char *name),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# undef getloadavg
# define getloadavg rpl_getloadavg
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
# else
# if !@HAVE_GETPROGNAME@
# if @HAVE_DECL_PROGRAM_INVOCATION_NAME@
-_GL_FUNCDECL_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));
# endif
# define getsubopt rpl_getsubopt
# endif
_GL_FUNCDECL_RPL (getsubopt, int,
- (char **optionp, char *const *tokens, char **valuep)
+ (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_FUNCDECL_SYS (getsubopt, int,
- (char **optionp, char *const *tokens, char **valuep)
+ (char **optionp, char *const *tokens, char **valuep),
_GL_ARG_NONNULL ((1, 2, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getsubopt, int,
# define malloc rpl_malloc
# endif
_GL_FUNCDECL_RPL (malloc, void *,
- (size_t size)
+ (size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (malloc, void *, (size_t size));
/* For -Wmismatched-dealloc: Associate malloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (malloc, void *,
- (size_t size)
- _GL_ATTRIBUTE_NOTHROW
+ (size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
- _GL_ATTRIBUTE_NODISCARD);
+ _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (malloc, void *,
- (size_t size)
+ (size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE
_GL_ATTRIBUTE_NODISCARD);
# endif
/* For -Wmismatched-dealloc: Associate malloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (malloc, void *,
- (size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (size_t size),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (malloc, void *,
- (size_t size)
+ (size_t size),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
# endif
_GL_FUNCDECL_RPL (mbstowcs, size_t,
(wchar_t *restrict dest, const char *restrict src,
- size_t len)
+ size_t len),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mbstowcs, size_t,
(wchar_t *restrict dest, const char *restrict src,
The directory is created mode 700. */
# if !@HAVE_MKDTEMP@
_GL_FUNCDECL_SYS (mkdtemp, char *,
- (char * /*template*/)
+ (char * /*template*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (mkdtemp, char *, (char * /*template*/));
# undef mkostemp
# define mkostemp rpl_mkostemp
# endif
-_GL_FUNCDECL_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_FUNCDECL_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*/));
# define mkostemps rpl_mkostemps
# endif
_GL_FUNCDECL_RPL (mkostemps, int,
- (char * /*template*/, int /*suffixlen*/, int /*flags*/)
+ (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_FUNCDECL_SYS (mkostemps, int,
- (char * /*template*/, int /*suffixlen*/, int /*flags*/)
+ (char * /*template*/, int /*suffixlen*/, int /*flags*/),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (mkostemps, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mkstemp rpl_mkstemp
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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*/));
# define posix_memalign rpl_posix_memalign
# endif
_GL_FUNCDECL_RPL (posix_memalign, int,
- (void **memptr, size_t alignment, size_t size)
+ (void **memptr, size_t alignment, size_t size),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (posix_memalign, int,
(void **memptr, size_t alignment, size_t size));
# undef posix_openpt
# define posix_openpt rpl_posix_openpt
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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 putenv
# define putenv rpl_putenv
# endif
-_GL_FUNCDECL_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)
# endif
_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),
+ _GL_ARG_NONNULL ((1, 4)));
_GL_CXXALIAS_RPL (qsort_r, void, (void *base, size_t nmemb, size_t size,
_gl_qsort_r_compar_fn compare,
void *arg));
# if !@HAVE_QSORT_R@
_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)));
+ void *arg),
+ _GL_ARG_NONNULL ((1, 4)));
# endif
_GL_CXXALIAS_SYS (qsort_r, void, (void *base, size_t nmemb, size_t size,
_gl_qsort_r_compar_fn compare,
# define initstate rpl_initstate
# endif
_GL_FUNCDECL_RPL (initstate, char *,
- (unsigned int seed, char *buf, size_t buf_size)
+ (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_FUNCDECL_SYS (initstate, char *,
- (unsigned int seed, char *buf, size_t buf_size)
+ (unsigned int seed, char *buf, size_t buf_size),
_GL_ARG_NONNULL ((2)));
# endif
/* Need to cast, because on FreeBSD, the first parameter is
# undef setstate
# define setstate rpl_setstate
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define srandom_r rpl_srandom_r
# endif
_GL_FUNCDECL_RPL (srandom_r, int,
- (unsigned int seed, struct random_data *rand_state)
+ (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_FUNCDECL_SYS (srandom_r, int,
- (unsigned int seed, struct random_data *rand_state)
+ (unsigned int seed, struct random_data *rand_state),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (srandom_r, int,
# endif
_GL_FUNCDECL_RPL (initstate_r, int,
(unsigned int seed, char *buf, size_t buf_size,
- struct random_data *rand_state)
+ struct random_data *rand_state),
_GL_ARG_NONNULL ((2, 4)));
_GL_CXXALIAS_RPL (initstate_r, int,
(unsigned int seed, char *buf, size_t buf_size,
# if !@HAVE_RANDOM_R@
_GL_FUNCDECL_SYS (initstate_r, int,
(unsigned int seed, char *buf, size_t buf_size,
- struct random_data *rand_state)
+ struct random_data *rand_state),
_GL_ARG_NONNULL ((2, 4)));
# endif
/* Need to cast, because on Haiku, the third parameter is
# define setstate_r rpl_setstate_r
# endif
_GL_FUNCDECL_RPL (setstate_r, int,
- (char *arg_state, struct random_data *rand_state)
+ (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_FUNCDECL_SYS (setstate_r, int,
- (char *arg_state, struct random_data *rand_state)
+ (char *arg_state, struct random_data *rand_state),
_GL_ARG_NONNULL ((1, 2)));
# endif
/* Need to cast, because on Haiku, the first parameter is
# define realloc rpl_realloc
# endif
_GL_FUNCDECL_RPL (realloc, void *,
- (void *ptr, size_t size)
+ (void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (realloc, void *, (void *ptr, size_t size));
# else
/* For -Wmismatched-dealloc: Associate realloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (realloc, void *,
- (void *ptr, size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD);
+ (void *ptr, size_t size),
+ _GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (realloc, void *,
- (void *ptr, size_t size)
+ (void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_NODISCARD);
# endif
# endif
/* For -Wmismatched-dealloc: Associate realloc with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2
_GL_FUNCDECL_SYS (realloc, void *,
- (void *ptr, size_t size)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_DEALLOC_FREE);
+ (void *ptr, size_t size),
+ _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (realloc, void *,
- (void *ptr, size_t size)
+ (void *ptr, size_t size),
_GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
# define reallocarray rpl_reallocarray
# endif
_GL_FUNCDECL_RPL (reallocarray, void *,
- (void *ptr, size_t nmemb, size_t size)
+ (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_FUNCDECL_SYS (reallocarray, void *,
- (void *ptr, size_t nmemb, size_t size)
+ (void *ptr, size_t nmemb, size_t size),
_GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (reallocarray, void *,
# define realpath rpl_realpath
# endif
_GL_FUNCDECL_RPL (realpath, char *,
- (const char *restrict name, char *restrict resolved)
+ (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_FUNCDECL_SYS (realpath, char *,
- (const char *restrict name, char *restrict resolved)
+ (const char *restrict name, char *restrict resolved),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (realpath, char *,
/* 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_FUNCDECL_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));
/* Look up NAME in the environment, returning 0 in insecure situations. */
# if !@HAVE_SECURE_GETENV@
_GL_FUNCDECL_SYS (secure_getenv, char *,
- (char const *name)
+ (char const *name),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (secure_getenv, char *, (char const *name));
# define setenv rpl_setenv
# endif
_GL_FUNCDECL_RPL (setenv, int,
- (const char *name, const char *value, int replace)
+ (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_FUNCDECL_SYS (setenv, int,
- (const char *name, const char *value, int replace)
+ (const char *name, const char *value, int replace),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (setenv, int,
# endif
# define GNULIB_defined_strtod_function 1
_GL_FUNCDECL_RPL (strtod, double,
- (const char *restrict str, char **restrict endp)
+ (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_FUNCDECL_SYS (strtod, double,
- (const char *restrict str, char **restrict endp)
+ (const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtod, double,
# endif
# define GNULIB_defined_strtof_function 1
_GL_FUNCDECL_RPL (strtof, float,
- (const char *restrict str, char **restrict endp)
+ (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_FUNCDECL_SYS (strtof, float,
- (const char *restrict str, char **restrict endp)
+ (const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtof, float,
# endif
# define GNULIB_defined_strtold_function 1
_GL_FUNCDECL_RPL (strtold, long double,
- (const char *restrict str, char **restrict endp)
+ (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_FUNCDECL_SYS (strtold, long double,
- (const char *restrict str, char **restrict endp)
+ (const char *restrict str, char **restrict endp),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtold, long double,
# define GNULIB_defined_strtol_function 1
_GL_FUNCDECL_RPL (strtol, long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtol, long,
(const char *restrict string, char **restrict endptr,
# if !@HAVE_STRTOL@
_GL_FUNCDECL_SYS (strtol, long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtol, long,
# define GNULIB_defined_strtoll_function 1
_GL_FUNCDECL_RPL (strtoll, long long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoll, long long,
(const char *restrict string, char **restrict endptr,
# if !@HAVE_STRTOLL@
_GL_FUNCDECL_SYS (strtoll, long long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtoll, long long,
# define GNULIB_defined_strtoul_function 1
_GL_FUNCDECL_RPL (strtoul, unsigned long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoul, unsigned long,
(const char *restrict string, char **restrict endptr,
# if !@HAVE_STRTOUL@
_GL_FUNCDECL_SYS (strtoul, unsigned long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtoul, unsigned long,
# define GNULIB_defined_strtoull_function 1
_GL_FUNCDECL_RPL (strtoull, unsigned long long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (strtoull, unsigned long long,
(const char *restrict string, char **restrict endptr,
# if !@HAVE_STRTOULL@
_GL_FUNCDECL_SYS (strtoull, unsigned long long,
(const char *restrict string, char **restrict endptr,
- int base)
+ int base),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (strtoull, unsigned long long,
# undef unsetenv
# define unsetenv rpl_unsetenv
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
#if @GNULIB_EXPLICIT_BZERO@
# if ! @HAVE_EXPLICIT_BZERO@
_GL_FUNCDECL_SYS (explicit_bzero, void,
- (void *__dest, size_t __n) _GL_ARG_NONNULL ((1)));
+ (void *__dest, size_t __n), _GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (explicit_bzero, void, (void *__dest, size_t __n));
_GL_CXXALIASWARN (explicit_bzero);
# undef memchr
# define memchr rpl_memchr
# endif
-_GL_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (memmem, void *,
(void const *__haystack, size_t __haystack_len,
- void const *__needle, size_t __needle_len)
+ void const *__needle, size_t __needle_len),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 3)));
_GL_CXXALIAS_RPL (memmem, void *,
# if ! @HAVE_DECL_MEMMEM@
_GL_FUNCDECL_SYS (memmem, void *,
(void const *__haystack, size_t __haystack_len,
- void const *__needle, size_t __needle_len)
+ void const *__needle, size_t __needle_len),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 3)));
# endif
# endif
_GL_FUNCDECL_RPL (mempcpy, void *,
(void *restrict __dest, void const *restrict __src,
- size_t __n)
+ size_t __n),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (mempcpy, void *,
(void *restrict __dest, void const *restrict __src,
# if !@HAVE_MEMPCPY@
_GL_FUNCDECL_SYS (mempcpy, void *,
(void *restrict __dest, void const *restrict __src,
- size_t __n)
+ size_t __n),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (mempcpy, void *,
/* Search backwards through a block for a byte (specified as an int). */
#if @GNULIB_MEMRCHR@
# if ! @HAVE_DECL_MEMRCHR@
-_GL_FUNCDECL_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
# define memset_explicit rpl_memset_explicit
# endif
_GL_FUNCDECL_RPL (memset_explicit, void *,
- (void *__dest, int __c, size_t __n) _GL_ARG_NONNULL ((1)));
+ (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_FUNCDECL_SYS (memset_explicit, void *,
- (void *__dest, int __c, size_t __n) _GL_ARG_NONNULL ((1)));
+ (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));
# endif
occur within N bytes. */
#if @GNULIB_RAWMEMCHR@
# if ! @HAVE_RAWMEMCHR@
-_GL_FUNCDECL_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
# define stpcpy rpl_stpcpy
# endif
_GL_FUNCDECL_RPL (stpcpy, char *,
- (char *restrict __dst, char const *restrict __src)
+ (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_FUNCDECL_SYS (stpcpy, char *,
- (char *restrict __dst, char const *restrict __src)
+ (char *restrict __dst, char const *restrict __src),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (stpcpy, char *,
# endif
_GL_FUNCDECL_RPL (stpncpy, char *,
(char *restrict __dst, char const *restrict __src,
- size_t __n)
+ size_t __n),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (stpncpy, char *,
(char *restrict __dst, char const *restrict __src,
# if ! @HAVE_STPNCPY@
_GL_FUNCDECL_SYS (stpncpy, char *,
(char *restrict __dst, char const *restrict __src,
- size_t __n)
+ size_t __n),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (stpncpy, char *,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strchrnul rpl_strchrnul
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# define strdup rpl_strdup
# endif
_GL_FUNCDECL_RPL (strdup, char *,
- (char const *__s)
+ (char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
_GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
# if (!@HAVE_DECL_STRDUP@ || __GNUC__ >= 11) && !defined strdup
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (strdup, char *,
- (char const *__s)
- _GL_ATTRIBUTE_NOTHROW
+ (char const *__s),
_GL_ARG_NONNULL ((1))
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (strdup, char *,
- (char const *__s)
+ (char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
/* For -Wmismatched-dealloc: Associate strdup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (strdup, char *,
- (char const *__s)
- _GL_ATTRIBUTE_NOTHROW
+ (char const *__s),
_GL_ARG_NONNULL ((1))
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (strdup, char *,
- (char const *__s)
+ (char const *__s),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# define strncat rpl_strncat
# endif
_GL_FUNCDECL_RPL (strncat, char *,
- (char *restrict dest, const char *restrict src, size_t n)
+ (char *restrict dest, const char *restrict src, size_t n),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (strncat, char *,
(char *restrict dest, const char *restrict src, size_t n));
# define strndup rpl_strndup
# endif
_GL_FUNCDECL_RPL (strndup, char *,
- (char const *__s, size_t __n)
+ (char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
_GL_CXXALIAS_RPL (strndup, char *, (char const *__s, size_t __n));
# if !@HAVE_DECL_STRNDUP@ || (__GNUC__ >= 11 && !defined strndup)
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (strndup, char *,
- (char const *__s, size_t __n)
- _GL_ATTRIBUTE_NOTHROW
+ (char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (strndup, char *,
- (char const *__s, size_t __n)
+ (char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
/* For -Wmismatched-dealloc: Associate strndup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (strndup, char *,
- (char const *__s, size_t __n)
- _GL_ATTRIBUTE_NOTHROW
+ (char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (strndup, char *,
- (char const *__s, size_t __n)
+ (char const *__s, size_t __n),
_GL_ARG_NONNULL ((1))
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# undef strnlen
# define strnlen rpl_strnlen
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
#if @GNULIB_STRSEP@
# if ! @HAVE_STRSEP@
_GL_FUNCDECL_SYS (strsep, char *,
- (char **restrict __stringp, char const *restrict __delim)
+ (char **restrict __stringp, char const *restrict __delim),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (strsep, char *,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strstr rpl_strstr
# endif
-_GL_FUNCDECL_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));
# define strcasestr rpl_strcasestr
# endif
_GL_FUNCDECL_RPL (strcasestr, char *,
- (const char *haystack, const char *needle)
+ (const char *haystack, const char *needle),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (strcasestr, char *,
# else
# if ! @HAVE_STRCASESTR@
_GL_FUNCDECL_SYS (strcasestr, char *,
- (const char *haystack, const char *needle)
+ (const char *haystack, const char *needle),
_GL_ATTRIBUTE_PURE
_GL_ARG_NONNULL ((1, 2)));
# endif
# endif
_GL_FUNCDECL_RPL (strtok_r, char *,
(char *restrict s, char const *restrict delim,
- char **restrict save_ptr)
+ char **restrict save_ptr),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (strtok_r, char *,
(char *restrict s, char const *restrict delim,
# if ! @HAVE_DECL_STRTOK_R@
_GL_FUNCDECL_SYS (strtok_r, char *,
(char *restrict s, char const *restrict delim,
- char **restrict save_ptr)
+ char **restrict save_ptr),
_GL_ARG_NONNULL ((2, 3)));
# endif
_GL_CXXALIAS_SYS (strtok_r, char *,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mbslen rpl_mbslen
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_r
# define strerror_r rpl_strerror_r
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define strverscmp rpl_strverscmp
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# define getrandom rpl_getrandom
# endif
_GL_FUNCDECL_RPL (getrandom, ssize_t,
- (void *buffer, size_t length, unsigned int flags)
+ (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_FUNCDECL_SYS (getrandom, ssize_t,
- (void *buffer, size_t length, unsigned int flags)
+ (void *buffer, size_t length, unsigned int flags),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getrandom, ssize_t,
#if @GNULIB_GETRUSAGE@
# if !@HAVE_GETRUSAGE@
-_GL_FUNCDECL_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));
# define connect rpl_connect
# endif
_GL_FUNCDECL_RPL (connect, int,
- (int fd, const struct sockaddr *addr, socklen_t addrlen)
+ (int fd, const struct sockaddr *addr, socklen_t addrlen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (connect, int,
(int fd, const struct sockaddr *addr, socklen_t addrlen));
# define bind rpl_bind
# endif
_GL_FUNCDECL_RPL (bind, int,
- (int fd, const struct sockaddr *addr, socklen_t addrlen)
+ (int fd, const struct sockaddr *addr, socklen_t addrlen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (bind, int,
(int fd, const struct sockaddr *addr, socklen_t addrlen));
# endif
_GL_FUNCDECL_RPL (getpeername, int,
(int fd, struct sockaddr *restrict addr,
- socklen_t *restrict addrlen)
+ socklen_t *restrict addrlen),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (getpeername, int,
(int fd, struct sockaddr *restrict addr,
# endif
_GL_FUNCDECL_RPL (getsockname, int,
(int fd, struct sockaddr *restrict addr,
- socklen_t *restrict addrlen)
+ socklen_t *restrict addrlen),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (getsockname, int,
(int fd, struct sockaddr *restrict addr,
# endif
_GL_FUNCDECL_RPL (getsockopt, int,
(int fd, int level, int optname,
- void *restrict optval, socklen_t *restrict optlen)
+ void *restrict optval, socklen_t *restrict optlen),
_GL_ARG_NONNULL ((4, 5)));
_GL_CXXALIAS_RPL (getsockopt, int,
(int fd, int level, int optname,
# undef recv
# define recv rpl_recv
# endif
-_GL_FUNCDECL_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
# define send rpl_send
# endif
_GL_FUNCDECL_RPL (send, ssize_t,
- (int fd, const void *buf, size_t len, int flags)
+ (int fd, const void *buf, size_t len, int flags),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (send, ssize_t,
(int fd, const void *buf, size_t len, int flags));
_GL_FUNCDECL_RPL (recvfrom, ssize_t,
(int fd, void *restrict buf, size_t len, int flags,
struct sockaddr *restrict from,
- socklen_t *restrict fromlen)
+ socklen_t *restrict fromlen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (recvfrom, ssize_t,
(int fd, void *restrict buf, size_t len, int flags,
# endif
_GL_FUNCDECL_RPL (sendto, ssize_t,
(int fd, const void *buf, size_t len, int flags,
- const struct sockaddr *to, socklen_t tolen)
+ const struct sockaddr *to, socklen_t tolen),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (sendto, ssize_t,
(int fd, const void *buf, size_t len, int flags,
# define setsockopt rpl_setsockopt
# endif
_GL_FUNCDECL_RPL (setsockopt, int, (int fd, int level, int optname,
- const void * optval, socklen_t optlen)
+ const void * optval, socklen_t optlen),
_GL_ARG_NONNULL ((4)));
_GL_CXXALIAS_RPL (setsockopt, int, (int fd, int level, int optname,
const void * optval, socklen_t optlen));
# undef chmod
# define chmod rpl_chmod
# endif
-_GL_FUNCDECL_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__
# define fchmodat rpl_fchmodat
# endif
_GL_FUNCDECL_RPL (fchmodat, int,
- (int fd, char const *file, mode_t mode, int flag)
+ (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_FUNCDECL_SYS (fchmodat, int,
- (int fd, char const *file, mode_t mode, int flag)
+ (int fd, char const *file, mode_t mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (fchmodat, int,
# undef fstat
# define fstat rpl_fstat
# endif
-_GL_FUNCDECL_RPL (fstat, int, (int fd, struct stat *buf) _GL_ARG_NONNULL ((2)));
+_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
_GL_CXXALIAS_SYS (fstat, int, (int fd, struct stat *buf));
# endif
_GL_FUNCDECL_RPL (fstatat, int,
(int fd, char const *restrict name, struct stat *restrict st,
- int flags)
+ int flags),
_GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_RPL (fstatat, int,
(int fd, char const *restrict name, struct stat *restrict st,
# if !@HAVE_FSTATAT@
_GL_FUNCDECL_SYS (fstatat, int,
(int fd, char const *restrict name, struct stat *restrict st,
- int flags)
+ int flags),
_GL_ARG_NONNULL ((2, 3)));
# endif
_GL_CXXALIAS_SYS (fstatat, int,
#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));
# endif
/* Change the mode of FILENAME to MODE, without dereferencing it if FILENAME
denotes a symbolic link. */
# if !@HAVE_LCHMOD@ || defined __hpux
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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 '...'. */
# define mknodat rpl_mknodat
# endif
_GL_FUNCDECL_RPL (mknodat, int,
- (int fd, char const *file, mode_t mode, dev_t dev)
+ (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_FUNCDECL_SYS (mknodat, int,
- (int fd, char const *file, mode_t mode, dev_t dev)
+ (int fd, char const *file, mode_t mode, dev_t dev),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mknodat, int,
# define lstat rpl_lstat
# endif
_GL_FUNCDECL_RPL (lstat, int,
- (const char *restrict name, struct stat *restrict buf)
+ (const char *restrict name, struct stat *restrict buf),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (lstat, int,
(const char *restrict name, struct stat *restrict buf));
# define utimensat rpl_utimensat
# endif
_GL_FUNCDECL_RPL (utimensat, int, (int fd, char const *name,
- struct timespec const times[2], int flag)
+ 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_FUNCDECL_SYS (utimensat, int, (int fd, char const *name,
- struct timespec const times[2], int flag)
+ struct timespec const times[2], int flag),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (utimensat, int, (int fd, char const *name,
# define gettimeofday rpl_gettimeofday
# endif
_GL_FUNCDECL_RPL (gettimeofday, int,
- (struct timeval *restrict, void *restrict)
+ (struct timeval *restrict, void *restrict),
_GL_ARG_NONNULL ((1)));
_GL_CXXALIAS_RPL (gettimeofday, int,
(struct timeval *restrict, void *restrict));
# else
# if !@HAVE_GETTIMEOFDAY@
_GL_FUNCDECL_SYS (gettimeofday, int,
- (struct timeval *restrict, void *restrict)
+ (struct timeval *restrict, void *restrict),
_GL_ARG_NONNULL ((1)));
# endif
/* Need to cast, because on glibc systems, by default, the second argument is
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define thrd_create rpl_thrd_create
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define thrd_sleep rpl_thrd_sleep
# endif
_GL_FUNCDECL_RPL (thrd_sleep, int,
- (const struct timespec *, struct timespec *)
+ (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_FUNCDECL_SYS (thrd_sleep, int,
- (const struct timespec *, struct timespec *)
+ (const struct timespec *, struct timespec *),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (thrd_sleep, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mtx_init rpl_mtx_init
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define cnd_timedwait rpl_cnd_timedwait
# endif
_GL_FUNCDECL_RPL (cnd_timedwait, int,
- (cnd_t *, mtx_t *, const struct timespec *)
+ (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_FUNCDECL_SYS (cnd_timedwait, int,
- (cnd_t *, mtx_t *, const struct timespec *)
+ (cnd_t *, mtx_t *, const struct timespec *),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
_GL_CXXALIAS_SYS (cnd_timedwait, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define cnd_signal rpl_cnd_signal
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_RPL (tss_create, int, (tss_t *, tss_dtor_t) _GL_ARG_NONNULL ((1)));
+_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_FUNCDECL_SYS (tss_create, int, (tss_t *, tss_dtor_t) _GL_ARG_NONNULL ((1)));
+_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));
# endif
# undef timespec_get
# define timespec_get rpl_timespec_get
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define nanosleep rpl_nanosleep
# endif
_GL_FUNCDECL_RPL (nanosleep, int,
- (struct timespec const *__rqtp, struct timespec *__rmtp)
+ (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_FUNCDECL_SYS (nanosleep, int,
- (struct timespec const *__rqtp, struct timespec *__rmtp)
+ (struct timespec const *__rqtp, struct timespec *__rmtp),
_GL_ARG_NONNULL ((1)));
# endif
_GL_CXXALIAS_SYS (nanosleep, int,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define mktime rpl_mktime
# endif
-_GL_FUNCDECL_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));
# define localtime_r rpl_localtime_r
# endif
_GL_FUNCDECL_RPL (localtime_r, struct tm *, (time_t const *restrict __timer,
- struct tm *restrict __result)
+ 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_FUNCDECL_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
- struct tm *restrict __result)
+ struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (localtime_r, struct tm *, (time_t const *restrict __timer,
# define gmtime_r rpl_gmtime_r
# endif
_GL_FUNCDECL_RPL (gmtime_r, struct tm *, (time_t const *restrict __timer,
- struct tm *restrict __result)
+ 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_FUNCDECL_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
- struct tm *restrict __result)
+ struct tm *restrict __result),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (gmtime_r, struct tm *, (time_t const *restrict __timer,
# undef localtime
# define localtime rpl_localtime
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# if ! @HAVE_STRPTIME@
_GL_FUNCDECL_SYS (strptime, char *, (char const *restrict __buf,
char const *restrict __format,
- struct tm *restrict __tm)
+ struct tm *restrict __tm),
_GL_ARG_NONNULL ((1, 2, 3)));
# endif
_GL_CXXALIAS_SYS (strptime, char *, (char const *restrict __buf,
# ifndef __cplusplus
_GL_ATTRIBUTE_DEPRECATED
# endif
-_GL_FUNCDECL_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
# endif
_GL_FUNCDECL_RPL (strftime, size_t,
(char *restrict __buf, size_t __bufsize,
- const char *restrict __fmt, const struct tm *restrict __tp)
+ const char *restrict __fmt, const struct tm *restrict __tp),
_GL_ARG_NONNULL ((1, 3, 4)));
_GL_CXXALIAS_RPL (strftime, size_t,
(char *restrict __buf, size_t __bufsize,
of an implicit global time zone. */
_GL_FUNCDECL_SYS (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),
+ _GL_ARG_NONNULL ((2, 3)));
_GL_CXXALIAS_SYS (localtime_rz, struct tm *,
(timezone_t __tz, time_t const *restrict __timer,
struct tm *restrict __result));
This function is like 'mktime', but relies on the argument TZ instead
of an implicit global time zone. */
_GL_FUNCDECL_SYS (mktime_z, time_t,
- (timezone_t __tz, struct tm *restrict __tm)
+ (timezone_t __tz, struct tm *restrict __tm),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_SYS (mktime_z, time_t,
(timezone_t __tz, struct tm *restrict __tm));
# undef timegm
# define timegm rpl_timegm
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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);
# else
_GL_FUNCDECL_SYS (c32snrtombs, size_t,
(char *dest, const char32_t **srcp, size_t srclen, size_t len,
- mbstate_t *ps)
+ mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (c32snrtombs, size_t,
_GL_END_C_LINKAGE
# else
_GL_FUNCDECL_SYS (c32srtombs, size_t,
- (char *dest, const char32_t **srcp, size_t len, mbstate_t *ps)
+ (char *dest, const char32_t **srcp, size_t len,
+ mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (c32srtombs, size_t,
_GL_END_C_LINKAGE
# else
_GL_FUNCDECL_SYS (c32stombs, size_t,
- (char *dest, const char32_t *src, size_t len)
+ (char *dest, const char32_t *src, size_t len),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (c32stombs, size_t,
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_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));
# else
_GL_FUNCDECL_SYS (mbsnrtoc32s, size_t,
(char32_t *dest, const char **srcp, size_t srclen, size_t len,
- mbstate_t *ps)
+ mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mbsnrtoc32s, size_t,
_GL_END_C_LINKAGE
# else
_GL_FUNCDECL_SYS (mbsrtoc32s, size_t,
- (char32_t *dest, const char **srcp, size_t len, mbstate_t *ps)
+ (char32_t *dest, const char **srcp, size_t len,
+ mbstate_t *ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mbsrtoc32s, size_t,
_GL_END_C_LINKAGE
# else
_GL_FUNCDECL_SYS (mbstoc32s, size_t,
- (char32_t *dest, const char *src, size_t len)
+ (char32_t *dest, const char *src, size_t len),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mbstoc32s, size_t,
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_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));
# endif
# 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),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (c32_apply_type_test, int,
}
_GL_END_C_LINKAGE
# else
-_GL_FUNCDECL_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_FUNCDECL_SYS (c32_apply_mapping, wint_t,
- (wint_t wc, c32_mapping_t mapping)
+ (wint_t wc, c32_mapping_t mapping),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (c32_apply_mapping, wint_t,
# undef access
# define access rpl_access
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define dup rpl_dup
# endif
-_GL_FUNCDECL_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)
/* Like access(), except that it uses the effective user id and group id of
the current process. */
# if !@HAVE_EUIDACCESS@
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define execve rpl_execve
# endif
_GL_FUNCDECL_RPL (execve, int,
- (const char *program, char * const *argv, char * const *env)
+ (const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
_GL_CXXALIAS_RPL (execve, int,
(const char *program, char * const *argv, char * const *env));
# undef execvp
# define execvp rpl_execvp
# endif
-_GL_FUNCDECL_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
# define execvpe rpl_execvpe
# endif
_GL_FUNCDECL_RPL (execvpe, int,
- (const char *program, char * const *argv, char * const *env)
+ (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_FUNCDECL_SYS (execvpe, int,
- (const char *program, char * const *argv, char * const *env)
+ (const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (execvpe, int,
# elif @HAVE_EXECVPE@
# if !@HAVE_DECL_EXECVPE@
_GL_FUNCDECL_SYS (execvpe, int,
- (const char *program, char * const *argv, char * const *env)
+ (const char *program, char * const *argv, char * const *env),
_GL_ARG_NONNULL ((1, 2)));
# endif
_GL_CXXALIAS_SYS (execvpe, int,
# define faccessat rpl_faccessat
# endif
_GL_FUNCDECL_RPL (faccessat, int,
- (int fd, char const *name, int mode, int flag)
+ (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_FUNCDECL_SYS (faccessat, int,
- (int fd, char const *file, int mode, int flag)
+ (int fd, char const *file, int mode, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (faccessat, int,
# undef fchdir
# define fchdir rpl_fchdir
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# define fchownat rpl_fchownat
# endif
_GL_FUNCDECL_RPL (fchownat, int, (int fd, char const *file,
- uid_t owner, gid_t group, int flag)
+ 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_FUNCDECL_SYS (fchownat, int, (int fd, char const *file,
- uid_t owner, gid_t group, int flag)
+ uid_t owner, gid_t group, int flag),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (fchownat, int, (int fd, char const *file,
# define ftruncate rpl_ftruncate
# endif
_GL_FUNCDECL_RPL (ftruncate, int,
- (int fd, off_t length) _GL_ATTRIBUTE_NODISCARD);
+ (int fd, off_t length), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (ftruncate, int,
(int fd, off_t length));
# else
# if !@HAVE_FTRUNCATE@
_GL_FUNCDECL_SYS (ftruncate, int,
- (int fd, off_t length) _GL_ATTRIBUTE_NODISCARD);
+ (int fd, off_t length), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (ftruncate, int,
(int fd, off_t length));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define getcwd rpl_getcwd
# endif
-_GL_FUNCDECL_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__
# define getdomainname rpl_getdomainname
# endif
_GL_FUNCDECL_RPL (getdomainname, int,
- (char *name, size_t len)
+ (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_FUNCDECL_SYS (getdomainname, int,
- (char *name, size_t len)
+ (char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getdomainname, int,
# define getentropy rpl_getentropy
# endif
_GL_FUNCDECL_RPL (getentropy, int,
- (void *buffer, size_t length) _GL_ATTRIBUTE_NODISCARD);
+ (void *buffer, size_t length), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getentropy, int,
(void *buffer, size_t length));
# else
# if !@HAVE_GETENTROPY@
_GL_FUNCDECL_SYS (getentropy, int,
- (void *buffer, size_t length) _GL_ATTRIBUTE_NODISCARD);
+ (void *buffer, size_t length), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getentropy, int,
(void *buffer, size_t length));
# define getgroups rpl_getgroups
# endif
_GL_FUNCDECL_RPL (getgroups, int,
- (int n, gid_t *groups) _GL_ATTRIBUTE_NODISCARD);
+ (int n, gid_t *groups), _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (getgroups, int,
(int n, gid_t *groups));
# else
# if !@HAVE_GETGROUPS@
_GL_FUNCDECL_SYS (getgroups, int,
- (int n, gid_t *groups) _GL_ATTRIBUTE_NODISCARD);
+ (int n, gid_t *groups), _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (getgroups, int,
(int n, gid_t *groups));
# undef gethostname
# define gethostname rpl_gethostname
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define getlogin_r rpl_getlogin_r
# endif
-_GL_FUNCDECL_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_FUNCDECL_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
# undef getpass
# define getpass rpl_getpass
# endif
-_GL_FUNCDECL_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_FUNCDECL_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 lchown
# define lchown rpl_lchown
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# endif
_GL_FUNCDECL_RPL (linkat, int,
(int fd1, const char *path1, int fd2, const char *path2,
- int flag)
+ int flag),
_GL_ARG_NONNULL ((2, 4)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (linkat, int,
(int fd1, const char *path1, int fd2, const char *path2,
# if !@HAVE_LINKAT@
_GL_FUNCDECL_SYS (linkat, int,
(int fd1, const char *path1, int fd2, const char *path2,
- int flag)
+ int flag),
_GL_ARG_NONNULL ((2, 4)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (linkat, int,
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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
# define pread rpl_pread
# endif
_GL_FUNCDECL_RPL (pread, ssize_t,
- (int fd, void *buf, size_t bufsize, off_t offset)
+ (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_FUNCDECL_SYS (pread, ssize_t,
- (int fd, void *buf, size_t bufsize, off_t offset)
+ (int fd, void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (pread, ssize_t,
# define pwrite rpl_pwrite
# endif
_GL_FUNCDECL_RPL (pwrite, ssize_t,
- (int fd, const void *buf, size_t bufsize, off_t offset)
+ (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_FUNCDECL_SYS (pwrite, ssize_t,
- (int fd, const void *buf, size_t bufsize, off_t offset)
+ (int fd, const void *buf, size_t bufsize, off_t offset),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (pwrite, ssize_t,
# define read rpl_read
# endif
-_GL_FUNCDECL_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__
# endif
_GL_FUNCDECL_RPL (readlink, ssize_t,
(const char *restrict file,
- char *restrict buf, size_t bufsize)
+ char *restrict buf, size_t bufsize),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (readlink, ssize_t,
(const char *restrict file,
# if !@HAVE_READLINK@
_GL_FUNCDECL_SYS (readlink, ssize_t,
(const char *restrict file,
- char *restrict buf, size_t bufsize)
+ char *restrict buf, size_t bufsize),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (readlink, ssize_t,
# endif
_GL_FUNCDECL_RPL (readlinkat, ssize_t,
(int fd, char const *restrict file,
- char *restrict buf, size_t len)
+ char *restrict buf, size_t len),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (readlinkat, ssize_t,
(int fd, char const *restrict file,
# if !@HAVE_READLINKAT@
_GL_FUNCDECL_SYS (readlinkat, ssize_t,
(int fd, char const *restrict file,
- char *restrict buf, size_t len)
+ char *restrict buf, size_t len),
_GL_ARG_NONNULL ((2, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (readlinkat, ssize_t,
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define rmdir rpl_rmdir
# endif
-_GL_FUNCDECL_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)
# define sethostname rpl_sethostname
# endif
_GL_FUNCDECL_RPL (sethostname, int,
- (const char *name, size_t len)
+ (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_FUNCDECL_SYS (sethostname, int,
- (const char *name, size_t len)
+ (const char *name, size_t len),
_GL_ARG_NONNULL ((1)) _GL_ATTRIBUTE_NODISCARD);
# endif
/* Need to cast, because on Solaris 11 2011-10, Mac OS X 10.5, IRIX 6.5
# define symlink rpl_symlink
# endif
_GL_FUNCDECL_RPL (symlink, int,
- (char const *contents, char const *file)
+ (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_FUNCDECL_SYS (symlink, int,
- (char const *contents, char const *file)
+ (char const *contents, char const *file),
_GL_ARG_NONNULL ((1, 2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (symlink, int,
# define symlinkat rpl_symlinkat
# endif
_GL_FUNCDECL_RPL (symlinkat, int,
- (char const *contents, int fd, char const *file)
+ (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_FUNCDECL_SYS (symlinkat, int,
- (char const *contents, int fd, char const *file)
+ (char const *contents, int fd, char const *file),
_GL_ARG_NONNULL ((1, 3)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (symlinkat, int,
# undef truncate
# define truncate rpl_truncate
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# define ttyname_r rpl_ttyname_r
# endif
_GL_FUNCDECL_RPL (ttyname_r, int,
- (int fd, char *buf, size_t buflen)
+ (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_FUNCDECL_SYS (ttyname_r, int,
- (int fd, char *buf, size_t buflen)
+ (int fd, char *buf, size_t buflen),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
# endif
_GL_CXXALIAS_SYS (ttyname_r, int,
# undef unlink
# define unlink rpl_unlink
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
# define write rpl_write
# endif
_GL_FUNCDECL_RPL (write, ssize_t,
- (int fd, const void *buf, size_t count)
+ (int fd, const void *buf, size_t count),
_GL_ARG_NONNULL ((2)) _GL_ATTRIBUTE_NODISCARD);
_GL_CXXALIAS_RPL (write, ssize_t,
(int fd, const void *buf, size_t count));
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
# define utime rpl_utime
# endif
-_GL_FUNCDECL_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_FUNCDECL_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 btowc
# define btowc rpl_btowc
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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
_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),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mbsrtowcs, size_t,
(wchar_t *restrict dest,
_GL_FUNCDECL_SYS (mbsrtowcs, size_t,
(wchar_t *restrict dest,
const char **restrict srcp, size_t len,
- mbstate_t *restrict ps)
+ mbstate_t *restrict ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mbsrtowcs, 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),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (mbsnrtowcs, size_t,
(wchar_t *restrict dest,
_GL_FUNCDECL_SYS (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),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (mbsnrtowcs, 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),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (wcsrtombs, size_t,
(char *restrict dest, const wchar_t **restrict srcp,
_GL_FUNCDECL_SYS (wcsrtombs, size_t,
(char *restrict dest, const wchar_t **restrict srcp,
size_t len,
- mbstate_t *restrict ps)
+ mbstate_t *restrict ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (wcsrtombs, size_t,
(char *restrict dest,
const wchar_t **restrict srcp, size_t srclen,
size_t len,
- mbstate_t *restrict ps)
+ mbstate_t *restrict ps),
_GL_ARG_NONNULL ((2)));
_GL_CXXALIAS_RPL (wcsnrtombs, size_t,
(char *restrict dest,
(char *restrict dest,
const wchar_t **restrict srcp, size_t srclen,
size_t len,
- mbstate_t *restrict ps)
+ mbstate_t *restrict ps),
_GL_ARG_NONNULL ((2)));
# endif
_GL_CXXALIAS_SYS (wcsnrtombs, size_t,
# undef wcwidth
# define wcwidth rpl_wcwidth
# endif
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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:
# define wmemcmp rpl_wmemcmp
# endif
_GL_FUNCDECL_RPL (wmemcmp, int,
- (const wchar_t *s1, const wchar_t *s2, size_t n)
+ (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_FUNCDECL_SYS (wmemcmp, int,
- (const wchar_t *s1, const wchar_t *s2, size_t n)
+ (const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wmemcmp, int,
/* Return the number of wide characters in S. */
#if @GNULIB_WCSLEN@
# if !@HAVE_WCSLEN@
-_GL_FUNCDECL_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_FUNCDECL_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));
# undef wcscmp
# define wcscmp rpl_wcscmp
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# define wcsncmp rpl_wcsncmp
# endif
_GL_FUNCDECL_RPL (wcsncmp, int,
- (const wchar_t *s1, const wchar_t *s2, size_t n)
+ (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_FUNCDECL_SYS (wcsncmp, int,
- (const wchar_t *s1, const wchar_t *s2, size_t n)
+ (const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcsncmp, int,
namespace, not in the global namespace. So, force a declaration in
the global namespace. */
# if !@HAVE_WCSCASECMP@ || (defined __sun && defined __cplusplus)
-_GL_FUNCDECL_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));
the global namespace. */
# if !@HAVE_WCSNCASECMP@ || (defined __sun && defined __cplusplus)
_GL_FUNCDECL_SYS (wcsncasecmp, int,
- (const wchar_t *s1, const wchar_t *s2, size_t n)
+ (const wchar_t *s1, const wchar_t *s2, size_t n),
_GL_ATTRIBUTE_PURE);
# endif
_GL_CXXALIAS_SYS (wcsncasecmp, int,
# if !@HAVE_WCSDUP@ || (defined __sun && defined __cplusplus) || __GNUC__ >= 11
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (const wchar_t *s),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
+ (const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
/* For -Wmismatched-dealloc: Associate wcsdup with free or rpl_free. */
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (const wchar_t *s),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
+ (const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# endif
# else
# if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
- _GL_ATTRIBUTE_NOTHROW
- _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
+ (const wchar_t *s),
+ _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
+ _GL_ATTRIBUTE_NOTHROW;
# else
_GL_FUNCDECL_SYS (wcsdup, wchar_t *,
- (const wchar_t *s)
+ (const wchar_t *s),
_GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
# endif
# if @HAVE_DECL_WCSDUP@
/* Find the first occurrence of WC in WCS. */
#if @GNULIB_WCSCHR@
# if !@HAVE_WCSCHR@
-_GL_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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_FUNCDECL_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));
#if @GNULIB_WCSPBRK@
# if !@HAVE_WCSPBRK@
_GL_FUNCDECL_SYS (wcspbrk, wchar_t *,
- (const wchar_t *wcs, const wchar_t *accept)
+ (const wchar_t *wcs, const wchar_t *accept),
_GL_ATTRIBUTE_PURE);
# endif
/* On some systems, this function is defined as an overloaded function:
# endif
_GL_FUNCDECL_RPL (wcsstr, wchar_t *,
(const wchar_t *restrict haystack,
- const wchar_t *restrict needle)
+ const wchar_t *restrict needle),
_GL_ATTRIBUTE_PURE);
_GL_CXXALIAS_RPL (wcsstr, wchar_t *,
(const wchar_t *restrict haystack,
# if !@HAVE_WCSSTR@
_GL_FUNCDECL_SYS (wcsstr, wchar_t *,
(const wchar_t *restrict haystack,
- const wchar_t *restrict needle)
+ const wchar_t *restrict needle),
_GL_ATTRIBUTE_PURE);
# endif
/* On some systems, this function is defined as an overloaded function:
# undef wcswidth
# define wcswidth rpl_wcswidth
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
_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),
_GL_ARG_NONNULL ((1, 3, 4)));
_GL_CXXALIAS_RPL (wcsftime, size_t,
(wchar_t *restrict __buf, size_t __bufsize,
_GL_FUNCDECL_SYS (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),
_GL_ARG_NONNULL ((1, 3, 4)));
# endif
_GL_CXXALIAS_SYS (wcsftime, size_t,
# undef wctype
# define wctype rpl_wctype
# endif
-_GL_FUNCDECL_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_FUNCDECL_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 wctrans
# define wctrans rpl_wctrans
# endif
-_GL_FUNCDECL_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_FUNCDECL_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));
# gnulib-common.m4
-# serial 98
+# serial 99
dnl Copyright (C) 2007-2024 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
#ifdef __cplusplus
extern "C" {
#endif
- // gcc clang g++ clang++
+ // gcc clang g++ clang++
ND int foo (int);
- int ND foo (int); // warn error warn error
- int foo (int) ND; // warn error warn error
+ int ND foo (int); // warn error warn error
+ int foo ND (int);
+ int foo (int) ND; // warn error warn error
WUR int foo (int);
int WUR foo (int);
+ int fo1 WUR (int); // error error error error
int foo (int) WUR;
#ifdef __cplusplus
}
#endif
- // gcc clang g++ clang++
+ // gcc clang g++ clang++
- ND extern CC int foo (int); // error error
- extern CC ND int foo (int); // error error
- extern CC int ND foo (int); // warn error warn error
- extern CC int foo (int) ND; // warn error warn error
+ ND extern CC int foo (int); // error error
+ extern CC ND int foo (int); // error error
+ extern CC int ND foo (int); // warn error warn error
+ extern CC int foo ND (int);
+ extern CC int foo (int) ND; // warn error warn error
- WUR extern CC int foo (int); // warn
+ WUR extern CC int foo (int); // warn
extern CC WUR int foo (int);
extern CC int WUR foo (int);
+ extern CC int foo WUR (int); // error error error error
extern CC int foo (int) WUR;
+
+ ND EXTERN_C_FUNC int foo (int); // error error
+ EXTERN_C_FUNC ND int foo (int);
+ EXTERN_C_FUNC int ND foo (int); // warn error warn error
+ EXTERN_C_FUNC int foo ND (int);
+ EXTERN_C_FUNC int foo (int) ND; // warn error warn error
+
+ WUR EXTERN_C_FUNC int foo (int); // warn
+ EXTERN_C_FUNC WUR int foo (int);
+ EXTERN_C_FUNC int WUR foo (int);
+ EXTERN_C_FUNC int fo2 WUR (int); // error error error error
+ EXTERN_C_FUNC int foo (int) WUR;
======================================================================
- So,
- * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]]
- in both C and C++, there is no available position:
- it would need to come before 'extern' in C but after 'extern "C"'
- in C++.
- * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax
- in both C and C++, there are several available positions:
- - before the return type,
- - between return type and function name,
- - at the end of the declaration.
- * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]] in C and
- to __attribute__((...)) syntax in C++, there is no available position:
- it would need to come before 'extern' in C but after 'extern "C"'
- in C++.
- * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax in C and
- to bracket syntax [[...]] in C++, there is one available position:
- - before the return type.
+ So, if we insist on using the 'extern' keyword ('extern CC' idiom):
+ * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]]
+ in both C and C++, there is one available position:
+ - between the function name and the parameter list.
+ * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax
+ in both C and C++, there are several available positions:
+ - before the return type,
+ - between return type and function name,
+ - at the end of the declaration.
+ * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]] in C and to
+ __attribute__((...)) syntax in C++, there is no available position:
+ it would need to come before 'extern' in C but after 'extern "C"'
+ in C++.
+ * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax in C and
+ to bracket syntax [[...]] in C++, there is one available position:
+ - before the return type.
+ Whereas, if we use the 'EXTERN_C_FUNC' idiom, which conditionally
+ omits the 'extern' keyword:
+ * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]]
+ in both C and C++, there are two available positions:
+ - before the return type,
+ - between the function name and the parameter list.
+ * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax
+ in both C and C++, there are several available positions:
+ - before the return type,
+ - between return type and function name,
+ - at the end of the declaration.
+ * If _GL_ATTRIBUTE_* expands to bracket syntax [[...]] in C and to
+ __attribute__((...)) syntax in C++, there is one available position:
+ - before the return type.
+ * If _GL_ATTRIBUTE_* expands to __attribute__((...)) syntax in C and
+ to bracket syntax [[...]] in C++, there is one available position:
+ - before the return type.
+ The best choice is therefore to use the 'EXTERN_C_FUNC' idiom and
+ put the attributes before the return type. This works regardless
+ to what the _GL_ATTRIBUTE_* macros expand.
+ */
+
+/* Attributes in bracket syntax [[...]] vs. attributes in __attribute__((...))
+ syntax, in static/inline function definitions.
+
+ There are similar constraints as for function declarations. However, here,
+ we cannot omit the storage-class specifier. Therefore, the following rule
+ applies:
+ * The macros
+ _GL_ATTRIBUTE_CONST
+ _GL_ATTRIBUTE_DEPRECATED
+ _GL_ATTRIBUTE_MAYBE_UNUSED
+ _GL_ATTRIBUTE_NODISCARD
+ _GL_ATTRIBUTE_PURE
+ _GL_ATTRIBUTE_REPRODUCIBLE
+ _GL_ATTRIBUTE_UNSEQUENCED
+ which may expand to bracket syntax [[...]], must come first, before the
+ storage-class specifier.
+ * Other _GL_ATTRIBUTE_* macros, that expand to __attribute__((...)) syntax,
+ are better placed between the storage-class specifier and the return
+ type.
+ */
+
+/* Attributes in bracket syntax [[...]] vs. attributes in __attribute__((...))
+ syntax, in variable declarations.
+
+ At which position can they be placed?
+ (Last tested with gcc/g++ 14 and clang/clang++ 18.)
+
+ =========================== foo.c = foo.cc ===========================
+ #ifdef __cplusplus
+ # define CC "C"
+ #else
+ # define CC
+ #endif
+
+ #define BD [[__deprecated__]]
+ #define AD __attribute__ ((__deprecated__))
+
+ // gcc clang g++ clang++
+
+ BD extern CC int var; // error error
+ extern CC BD int var; // error error
+ extern CC int BD var; // warn error warn error
+ extern CC int var BD;
+
+ AD extern CC int var; // warn
+ extern CC AD int var;
+ extern CC int AD var;
+ extern CC int var AD;
+
+ BD extern CC int z[]; // error error
+ extern CC BD int z[]; // error error
+ extern CC int BD z[]; // warn error warn error
+ extern CC int z1 BD [];
+ extern CC int z[] BD; // warn error error
+
+ AD extern CC int z[]; // warn
+ extern CC AD int z[];
+ extern CC int AD z[];
+ extern CC int z2 AD []; // error error error error
+ extern CC int z[] AD;
+ ======================================================================
+
+ * For non-array variables, the only good position is after the variable name,
+ that is, at the end of the declaration.
+ * For array variables, you will need to distinguish C and C++:
+ - In C, before the 'extern' keyword.
+ - In C++, between the 'extern "C"' and the variable's type.
*/
-/* Define if, in a function declaration, the attributes in bracket syntax
- [[...]] are usable at all. */
-#ifdef __cplusplus
-# define _GL_BRACKET_USABLE 1
-#endif
]dnl There is no _GL_ATTRIBUTE_ALIGNED; use stdalign's alignas instead.
[
/* _GL_ATTRIBUTE_ALLOC_SIZE ((N)) declares that the Nth argument of the function
- typedef,
in C++ also: namespace, class, template specialization. */
#ifndef _GL_ATTRIBUTE_DEPRECATED
-# if defined _GL_BRACKET_USABLE && !defined _GL_BRACKET_BEFORE_ATTRIBUTE
+# ifndef _GL_BRACKET_BEFORE_ATTRIBUTE
# if _GL_HAVE___HAS_C_ATTRIBUTE
# if __has_c_attribute (__deprecated__)
# define _GL_ATTRIBUTE_DEPRECATED [[__deprecated__]]
__has_c_attribute (__maybe_unused__) yields true but the use of
[[__maybe_unused__]] nevertheless produces a warning. */
#ifndef _GL_ATTRIBUTE_MAYBE_UNUSED
-# if defined _GL_BRACKET_USABLE && !defined _GL_BRACKET_BEFORE_ATTRIBUTE
+# ifndef _GL_BRACKET_BEFORE_ATTRIBUTE
# if defined __clang__ && defined __cplusplus
# if !defined __apple_build_version__ && __clang_major__ >= 10
# define _GL_ATTRIBUTE_MAYBE_UNUSED [[__maybe_unused__]]
the return value, unless the caller uses something like ignore_value. */
/* Applies to: function, enumeration, class. */
#ifndef _GL_ATTRIBUTE_NODISCARD
-# if defined _GL_BRACKET_USABLE && !defined _GL_BRACKET_BEFORE_ATTRIBUTE
+# ifndef _GL_BRACKET_BEFORE_ATTRIBUTE
# if defined __clang__ && defined __cplusplus
/* With clang up to 15.0.6 (at least), in C++ mode, [[__nodiscard__]] produces
a warning.
#ifndef _GL_ATTRIBUTE_REPRODUCIBLE
/* This may be revisited when gcc and clang support [[reproducible]] or possibly
__attribute__ ((__reproducible__)). */
-# if defined _GL_BRACKET_USABLE && !defined _GL_BRACKET_BEFORE_ATTRIBUTE
+# ifndef _GL_BRACKET_BEFORE_ATTRIBUTE
# if _GL_HAS_ATTRIBUTE (reproducible)
# define _GL_ATTRIBUTE_REPRODUCIBLE [[reproducible]]
# endif
#ifndef _GL_ATTRIBUTE_UNSEQUENCED
/* This may be revisited when gcc and clang support [[unsequenced]] or possibly
__attribute__ ((__unsequenced__)). */
-# if defined _GL_BRACKET_USABLE && !defined _GL_BRACKET_BEFORE_ATTRIBUTE
+# ifndef _GL_BRACKET_BEFORE_ATTRIBUTE
# if _GL_HAS_ATTRIBUTE (unsequenced)
# define _GL_ATTRIBUTE_UNSEQUENCED [[unsequenced]]
# endif