1/* A GNU-like <stdio.h>. 2 3 Copyright (C) 2004, 2007-2014 Free Software Foundation, Inc. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3, or (at your option) 8 any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 17 18#if __GNUC__ >= 3 19@PRAGMA_SYSTEM_HEADER@ 20#endif 21@PRAGMA_COLUMNS@ 22 23#if defined __need_FILE || defined __need___FILE || defined _GL_ALREADY_INCLUDING_STDIO_H 24/* Special invocation convention: 25 - Inside glibc header files. 26 - On OSF/1 5.1 we have a sequence of nested includes 27 <stdio.h> -> <getopt.h> -> <ctype.h> -> <sys/localedef.h> -> 28 <sys/lc_core.h> -> <nl_types.h> -> <mesg.h> -> <stdio.h>. 29 In this situation, the functions are not yet declared, therefore we cannot 30 provide the C++ aliases. */ 31 32#@INCLUDE_NEXT@ @NEXT_STDIO_H@ 33 34#else 35/* Normal invocation convention. */ 36 37#ifndef _@GUARD_PREFIX@_STDIO_H 38 39#define _GL_ALREADY_INCLUDING_STDIO_H 40 41/* The include_next requires a split double-inclusion guard. */ 42#@INCLUDE_NEXT@ @NEXT_STDIO_H@ 43 44#undef _GL_ALREADY_INCLUDING_STDIO_H 45 46#ifndef _@GUARD_PREFIX@_STDIO_H 47#define _@GUARD_PREFIX@_STDIO_H 48 49/* Get va_list. Needed on many systems, including glibc 2.8. */ 50#include <stdarg.h> 51 52#include <stddef.h> 53 54/* Get off_t and ssize_t. Needed on many systems, including glibc 2.8 55 and eglibc 2.11.2. 56 May also define off_t to a 64-bit type on native Windows. */ 57#include <sys/types.h> 58 59/* The __attribute__ feature is available in gcc versions 2.5 and later. 60 The __-protected variants of the attributes 'format' and 'printf' are 61 accepted by gcc versions 2.6.4 (effectively 2.7) and later. 62 We enable _GL_ATTRIBUTE_FORMAT only if these are supported too, because 63 gnulib and libintl do '#define printf __printf__' when they override 64 the 'printf' function. */ 65#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7) 66# define _GL_ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec)) 67#else 68# define _GL_ATTRIBUTE_FORMAT(spec) /* empty */ 69#endif 70 71/* _GL_ATTRIBUTE_FORMAT_PRINTF 72 indicates to GCC that the function takes a format string and arguments, 73 where the format string directives are the ones standardized by ISO C99 74 and POSIX. */ 75#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) 76# define _GL_ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ 77 _GL_ATTRIBUTE_FORMAT ((__gnu_printf__, formatstring_parameter, first_argument)) 78#else 79# define _GL_ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ 80 _GL_ATTRIBUTE_FORMAT ((__printf__, formatstring_parameter, first_argument)) 81#endif 82 83/* _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM is like _GL_ATTRIBUTE_FORMAT_PRINTF, 84 except that it indicates to GCC that the supported format string directives 85 are the ones of the system printf(), rather than the ones standardized by 86 ISO C99 and POSIX. */ 87#define _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM(formatstring_parameter, first_argument) \ 88 _GL_ATTRIBUTE_FORMAT ((__printf__, formatstring_parameter, first_argument)) 89 90/* _GL_ATTRIBUTE_FORMAT_SCANF 91 indicates to GCC that the function takes a format string and arguments, 92 where the format string directives are the ones standardized by ISO C99 93 and POSIX. */ 94#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) 95# define _GL_ATTRIBUTE_FORMAT_SCANF(formatstring_parameter, first_argument) \ 96 _GL_ATTRIBUTE_FORMAT ((__gnu_scanf__, formatstring_parameter, first_argument)) 97#else 98# define _GL_ATTRIBUTE_FORMAT_SCANF(formatstring_parameter, first_argument) \ 99 _GL_ATTRIBUTE_FORMAT ((__scanf__, formatstring_parameter, first_argument)) 100#endif 101 102/* _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM is like _GL_ATTRIBUTE_FORMAT_SCANF, 103 except that it indicates to GCC that the supported format string directives 104 are the ones of the system scanf(), rather than the ones standardized by 105 ISO C99 and POSIX. */ 106#define _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM(formatstring_parameter, first_argument) \ 107 _GL_ATTRIBUTE_FORMAT ((__scanf__, formatstring_parameter, first_argument)) 108 109/* Solaris 10 declares renameat in <unistd.h>, not in <stdio.h>. */ 110/* But in any case avoid namespace pollution on glibc systems. */ 111#if (@GNULIB_RENAMEAT@ || defined GNULIB_POSIXCHECK) && defined __sun \ 112 && ! defined __GLIBC__ 113# include <unistd.h> 114#endif 115 116 117/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 118 119/* The definition of _GL_ARG_NONNULL is copied here. */ 120 121/* The definition of _GL_WARN_ON_USE is copied here. */ 122 123/* Macros for stringification. */ 124#define _GL_STDIO_STRINGIZE(token) #token 125#define _GL_STDIO_MACROEXPAND_AND_STRINGIZE(token) _GL_STDIO_STRINGIZE(token) 126 127/* When also using extern inline, suppress the use of static inline in 128 standard headers of problematic Apple configurations, as Libc at 129 least through Libc-825.26 (2013-04-09) mishandles it; see, e.g., 130 <http://lists.gnu.org/archive/html/bug-gnulib/2012-12/msg00023.html>. 131 Perhaps Apple will fix this some day. */ 132#if (defined _GL_EXTERN_INLINE_IN_USE && defined __APPLE__ \ 133 && defined __GNUC__ && defined __STDC__) 134# undef putc_unlocked 135#endif 136 137#if @GNULIB_DPRINTF@ 138# if @REPLACE_DPRINTF@ 139# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 140# define dprintf rpl_dprintf 141# endif 142_GL_FUNCDECL_RPL (dprintf, int, (int fd, const char *format, ...) 143 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 144 _GL_ARG_NONNULL ((2))); 145_GL_CXXALIAS_RPL (dprintf, int, (int fd, const char *format, ...)); 146# else 147# if !@HAVE_DPRINTF@ 148_GL_FUNCDECL_SYS (dprintf, int, (int fd, const char *format, ...) 149 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 150 _GL_ARG_NONNULL ((2))); 151# endif 152_GL_CXXALIAS_SYS (dprintf, int, (int fd, const char *format, ...)); 153# endif 154_GL_CXXALIASWARN (dprintf); 155#elif defined GNULIB_POSIXCHECK 156# undef dprintf 157# if HAVE_RAW_DECL_DPRINTF 158_GL_WARN_ON_USE (dprintf, "dprintf is unportable - " 159 "use gnulib module dprintf for portability"); 160# endif 161#endif 162 163#if @GNULIB_FCLOSE@ 164/* Close STREAM and its underlying file descriptor. */ 165# if @REPLACE_FCLOSE@ 166# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 167# define fclose rpl_fclose 168# endif 169_GL_FUNCDECL_RPL (fclose, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 170_GL_CXXALIAS_RPL (fclose, int, (FILE *stream)); 171# else 172_GL_CXXALIAS_SYS (fclose, int, (FILE *stream)); 173# endif 174_GL_CXXALIASWARN (fclose); 175#elif defined GNULIB_POSIXCHECK 176# undef fclose 177/* Assume fclose is always declared. */ 178_GL_WARN_ON_USE (fclose, "fclose is not always POSIX compliant - " 179 "use gnulib module fclose for portable POSIX compliance"); 180#endif 181 182#if @GNULIB_FDOPEN@ 183# if @REPLACE_FDOPEN@ 184# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 185# undef fdopen 186# define fdopen rpl_fdopen 187# endif 188_GL_FUNCDECL_RPL (fdopen, FILE *, (int fd, const char *mode) 189 _GL_ARG_NONNULL ((2))); 190_GL_CXXALIAS_RPL (fdopen, FILE *, (int fd, const char *mode)); 191# else 192_GL_CXXALIAS_SYS (fdopen, FILE *, (int fd, const char *mode)); 193# endif 194_GL_CXXALIASWARN (fdopen); 195#elif defined GNULIB_POSIXCHECK 196# undef fdopen 197/* Assume fdopen is always declared. */ 198_GL_WARN_ON_USE (fdopen, "fdopen on native Windows platforms is not POSIX compliant - " 199 "use gnulib module fdopen for portability"); 200#endif 201 202#if @GNULIB_FFLUSH@ 203/* Flush all pending data on STREAM according to POSIX rules. Both 204 output and seekable input streams are supported. 205 Note! LOSS OF DATA can occur if fflush is applied on an input stream 206 that is _not_seekable_ or on an update stream that is _not_seekable_ 207 and in which the most recent operation was input. Seekability can 208 be tested with lseek(fileno(fp),0,SEEK_CUR). */ 209# if @REPLACE_FFLUSH@ 210# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 211# define fflush rpl_fflush 212# endif 213_GL_FUNCDECL_RPL (fflush, int, (FILE *gl_stream)); 214_GL_CXXALIAS_RPL (fflush, int, (FILE *gl_stream)); 215# else 216_GL_CXXALIAS_SYS (fflush, int, (FILE *gl_stream)); 217# endif 218_GL_CXXALIASWARN (fflush); 219#elif defined GNULIB_POSIXCHECK 220# undef fflush 221/* Assume fflush is always declared. */ 222_GL_WARN_ON_USE (fflush, "fflush is not always POSIX compliant - " 223 "use gnulib module fflush for portable POSIX compliance"); 224#endif 225 226#if @GNULIB_FGETC@ 227# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 228# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 229# undef fgetc 230# define fgetc rpl_fgetc 231# endif 232_GL_FUNCDECL_RPL (fgetc, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 233_GL_CXXALIAS_RPL (fgetc, int, (FILE *stream)); 234# else 235_GL_CXXALIAS_SYS (fgetc, int, (FILE *stream)); 236# endif 237_GL_CXXALIASWARN (fgetc); 238#endif 239 240#if @GNULIB_FGETS@ 241# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 242# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 243# undef fgets 244# define fgets rpl_fgets 245# endif 246_GL_FUNCDECL_RPL (fgets, char *, (char *s, int n, FILE *stream) 247 _GL_ARG_NONNULL ((1, 3))); 248_GL_CXXALIAS_RPL (fgets, char *, (char *s, int n, FILE *stream)); 249# else 250_GL_CXXALIAS_SYS (fgets, char *, (char *s, int n, FILE *stream)); 251# endif 252_GL_CXXALIASWARN (fgets); 253#endif 254 255#if @GNULIB_FOPEN@ 256# if @REPLACE_FOPEN@ 257# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 258# undef fopen 259# define fopen rpl_fopen 260# endif 261_GL_FUNCDECL_RPL (fopen, FILE *, (const char *filename, const char *mode) 262 _GL_ARG_NONNULL ((1, 2))); 263_GL_CXXALIAS_RPL (fopen, FILE *, (const char *filename, const char *mode)); 264# else 265_GL_CXXALIAS_SYS (fopen, FILE *, (const char *filename, const char *mode)); 266# endif 267_GL_CXXALIASWARN (fopen); 268#elif defined GNULIB_POSIXCHECK 269# undef fopen 270/* Assume fopen is always declared. */ 271_GL_WARN_ON_USE (fopen, "fopen on native Windows platforms is not POSIX compliant - " 272 "use gnulib module fopen for portability"); 273#endif 274 275#if @GNULIB_FPRINTF_POSIX@ || @GNULIB_FPRINTF@ 276# if (@GNULIB_FPRINTF_POSIX@ && @REPLACE_FPRINTF@) \ 277 || (@GNULIB_FPRINTF@ && @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@)) 278# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 279# define fprintf rpl_fprintf 280# endif 281# define GNULIB_overrides_fprintf 1 282# if @GNULIB_FPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@ 283_GL_FUNCDECL_RPL (fprintf, int, (FILE *fp, const char *format, ...) 284 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 285 _GL_ARG_NONNULL ((1, 2))); 286# else 287_GL_FUNCDECL_RPL (fprintf, int, (FILE *fp, const char *format, ...) 288 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 3) 289 _GL_ARG_NONNULL ((1, 2))); 290# endif 291_GL_CXXALIAS_RPL (fprintf, int, (FILE *fp, const char *format, ...)); 292# else 293_GL_CXXALIAS_SYS (fprintf, int, (FILE *fp, const char *format, ...)); 294# endif 295_GL_CXXALIASWARN (fprintf); 296#endif 297#if !@GNULIB_FPRINTF_POSIX@ && defined GNULIB_POSIXCHECK 298# if !GNULIB_overrides_fprintf 299# undef fprintf 300# endif 301/* Assume fprintf is always declared. */ 302_GL_WARN_ON_USE (fprintf, "fprintf is not always POSIX compliant - " 303 "use gnulib module fprintf-posix for portable " 304 "POSIX compliance"); 305#endif 306 307#if @GNULIB_FPURGE@ 308/* Discard all pending buffered I/O data on STREAM. 309 STREAM must not be wide-character oriented. 310 When discarding pending output, the file position is set back to where it 311 was before the write calls. When discarding pending input, the file 312 position is advanced to match the end of the previously read input. 313 Return 0 if successful. Upon error, return -1 and set errno. */ 314# if @REPLACE_FPURGE@ 315# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 316# define fpurge rpl_fpurge 317# endif 318_GL_FUNCDECL_RPL (fpurge, int, (FILE *gl_stream) _GL_ARG_NONNULL ((1))); 319_GL_CXXALIAS_RPL (fpurge, int, (FILE *gl_stream)); 320# else 321# if !@HAVE_DECL_FPURGE@ 322_GL_FUNCDECL_SYS (fpurge, int, (FILE *gl_stream) _GL_ARG_NONNULL ((1))); 323# endif 324_GL_CXXALIAS_SYS (fpurge, int, (FILE *gl_stream)); 325# endif 326_GL_CXXALIASWARN (fpurge); 327#elif defined GNULIB_POSIXCHECK 328# undef fpurge 329# if HAVE_RAW_DECL_FPURGE 330_GL_WARN_ON_USE (fpurge, "fpurge is not always present - " 331 "use gnulib module fpurge for portability"); 332# endif 333#endif 334 335#if @GNULIB_FPUTC@ 336# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 337# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 338# undef fputc 339# define fputc rpl_fputc 340# endif 341_GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream) _GL_ARG_NONNULL ((2))); 342_GL_CXXALIAS_RPL (fputc, int, (int c, FILE *stream)); 343# else 344_GL_CXXALIAS_SYS (fputc, int, (int c, FILE *stream)); 345# endif 346_GL_CXXALIASWARN (fputc); 347#endif 348 349#if @GNULIB_FPUTS@ 350# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 351# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 352# undef fputs 353# define fputs rpl_fputs 354# endif 355_GL_FUNCDECL_RPL (fputs, int, (const char *string, FILE *stream) 356 _GL_ARG_NONNULL ((1, 2))); 357_GL_CXXALIAS_RPL (fputs, int, (const char *string, FILE *stream)); 358# else 359_GL_CXXALIAS_SYS (fputs, int, (const char *string, FILE *stream)); 360# endif 361_GL_CXXALIASWARN (fputs); 362#endif 363 364#if @GNULIB_FREAD@ 365# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 366# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 367# undef fread 368# define fread rpl_fread 369# endif 370_GL_FUNCDECL_RPL (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream) 371 _GL_ARG_NONNULL ((4))); 372_GL_CXXALIAS_RPL (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream)); 373# else 374_GL_CXXALIAS_SYS (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream)); 375# endif 376_GL_CXXALIASWARN (fread); 377#endif 378 379#if @GNULIB_FREOPEN@ 380# if @REPLACE_FREOPEN@ 381# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 382# undef freopen 383# define freopen rpl_freopen 384# endif 385_GL_FUNCDECL_RPL (freopen, FILE *, 386 (const char *filename, const char *mode, FILE *stream) 387 _GL_ARG_NONNULL ((2, 3))); 388_GL_CXXALIAS_RPL (freopen, FILE *, 389 (const char *filename, const char *mode, FILE *stream)); 390# else 391_GL_CXXALIAS_SYS (freopen, FILE *, 392 (const char *filename, const char *mode, FILE *stream)); 393# endif 394_GL_CXXALIASWARN (freopen); 395#elif defined GNULIB_POSIXCHECK 396# undef freopen 397/* Assume freopen is always declared. */ 398_GL_WARN_ON_USE (freopen, 399 "freopen on native Windows platforms is not POSIX compliant - " 400 "use gnulib module freopen for portability"); 401#endif 402 403#if @GNULIB_FSCANF@ 404# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 405# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 406# undef fscanf 407# define fscanf rpl_fscanf 408# endif 409_GL_FUNCDECL_RPL (fscanf, int, (FILE *stream, const char *format, ...) 410 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 3) 411 _GL_ARG_NONNULL ((1, 2))); 412_GL_CXXALIAS_RPL (fscanf, int, (FILE *stream, const char *format, ...)); 413# else 414_GL_CXXALIAS_SYS (fscanf, int, (FILE *stream, const char *format, ...)); 415# endif 416_GL_CXXALIASWARN (fscanf); 417#endif 418 419 420/* Set up the following warnings, based on which modules are in use. 421 GNU Coding Standards discourage the use of fseek, since it imposes 422 an arbitrary limitation on some 32-bit hosts. Remember that the 423 fseek module depends on the fseeko module, so we only have three 424 cases to consider: 425 426 1. The developer is not using either module. Issue a warning under 427 GNULIB_POSIXCHECK for both functions, to remind them that both 428 functions have bugs on some systems. _GL_NO_LARGE_FILES has no 429 impact on this warning. 430 431 2. The developer is using both modules. They may be unaware of the 432 arbitrary limitations of fseek, so issue a warning under 433 GNULIB_POSIXCHECK. On the other hand, they may be using both 434 modules intentionally, so the developer can define 435 _GL_NO_LARGE_FILES in the compilation units where the use of fseek 436 is safe, to silence the warning. 437 438 3. The developer is using the fseeko module, but not fseek. Gnulib 439 guarantees that fseek will still work around platform bugs in that 440 case, but we presume that the developer is aware of the pitfalls of 441 fseek and was trying to avoid it, so issue a warning even when 442 GNULIB_POSIXCHECK is undefined. Again, _GL_NO_LARGE_FILES can be 443 defined to silence the warning in particular compilation units. 444 In C++ compilations with GNULIB_NAMESPACE, in order to avoid that 445 fseek gets defined as a macro, it is recommended that the developer 446 uses the fseek module, even if he is not calling the fseek function. 447 448 Most gnulib clients that perform stream operations should fall into 449 category 3. */ 450 451#if @GNULIB_FSEEK@ 452# if defined GNULIB_POSIXCHECK && !defined _GL_NO_LARGE_FILES 453# define _GL_FSEEK_WARN /* Category 2, above. */ 454# undef fseek 455# endif 456# if @REPLACE_FSEEK@ 457# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 458# undef fseek 459# define fseek rpl_fseek 460# endif 461_GL_FUNCDECL_RPL (fseek, int, (FILE *fp, long offset, int whence) 462 _GL_ARG_NONNULL ((1))); 463_GL_CXXALIAS_RPL (fseek, int, (FILE *fp, long offset, int whence)); 464# else 465_GL_CXXALIAS_SYS (fseek, int, (FILE *fp, long offset, int whence)); 466# endif 467_GL_CXXALIASWARN (fseek); 468#endif 469 470#if @GNULIB_FSEEKO@ 471# if !@GNULIB_FSEEK@ && !defined _GL_NO_LARGE_FILES 472# define _GL_FSEEK_WARN /* Category 3, above. */ 473# undef fseek 474# endif 475# if @REPLACE_FSEEKO@ 476/* Provide an fseeko function that is aware of a preceding fflush(), and which 477 detects pipes. */ 478# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 479# undef fseeko 480# define fseeko rpl_fseeko 481# endif 482_GL_FUNCDECL_RPL (fseeko, int, (FILE *fp, off_t offset, int whence) 483 _GL_ARG_NONNULL ((1))); 484_GL_CXXALIAS_RPL (fseeko, int, (FILE *fp, off_t offset, int whence)); 485# else 486# if ! @HAVE_DECL_FSEEKO@ 487_GL_FUNCDECL_SYS (fseeko, int, (FILE *fp, off_t offset, int whence) 488 _GL_ARG_NONNULL ((1))); 489# endif 490_GL_CXXALIAS_SYS (fseeko, int, (FILE *fp, off_t offset, int whence)); 491# endif 492_GL_CXXALIASWARN (fseeko); 493#elif defined GNULIB_POSIXCHECK 494# define _GL_FSEEK_WARN /* Category 1, above. */ 495# undef fseek 496# undef fseeko 497# if HAVE_RAW_DECL_FSEEKO 498_GL_WARN_ON_USE (fseeko, "fseeko is unportable - " 499 "use gnulib module fseeko for portability"); 500# endif 501#endif 502 503#ifdef _GL_FSEEK_WARN 504# undef _GL_FSEEK_WARN 505/* Here, either fseek is undefined (but C89 guarantees that it is 506 declared), or it is defined as rpl_fseek (declared above). */ 507_GL_WARN_ON_USE (fseek, "fseek cannot handle files larger than 4 GB " 508 "on 32-bit platforms - " 509 "use fseeko function for handling of large files"); 510#endif 511 512 513/* ftell, ftello. See the comments on fseek/fseeko. */ 514 515#if @GNULIB_FTELL@ 516# if defined GNULIB_POSIXCHECK && !defined _GL_NO_LARGE_FILES 517# define _GL_FTELL_WARN /* Category 2, above. */ 518# undef ftell 519# endif 520# if @REPLACE_FTELL@ 521# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 522# undef ftell 523# define ftell rpl_ftell 524# endif 525_GL_FUNCDECL_RPL (ftell, long, (FILE *fp) _GL_ARG_NONNULL ((1))); 526_GL_CXXALIAS_RPL (ftell, long, (FILE *fp)); 527# else 528_GL_CXXALIAS_SYS (ftell, long, (FILE *fp)); 529# endif 530_GL_CXXALIASWARN (ftell); 531#endif 532 533#if @GNULIB_FTELLO@ 534# if !@GNULIB_FTELL@ && !defined _GL_NO_LARGE_FILES 535# define _GL_FTELL_WARN /* Category 3, above. */ 536# undef ftell 537# endif 538# if @REPLACE_FTELLO@ 539# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 540# undef ftello 541# define ftello rpl_ftello 542# endif 543_GL_FUNCDECL_RPL (ftello, off_t, (FILE *fp) _GL_ARG_NONNULL ((1))); 544_GL_CXXALIAS_RPL (ftello, off_t, (FILE *fp)); 545# else 546# if ! @HAVE_DECL_FTELLO@ 547_GL_FUNCDECL_SYS (ftello, off_t, (FILE *fp) _GL_ARG_NONNULL ((1))); 548# endif 549_GL_CXXALIAS_SYS (ftello, off_t, (FILE *fp)); 550# endif 551_GL_CXXALIASWARN (ftello); 552#elif defined GNULIB_POSIXCHECK 553# define _GL_FTELL_WARN /* Category 1, above. */ 554# undef ftell 555# undef ftello 556# if HAVE_RAW_DECL_FTELLO 557_GL_WARN_ON_USE (ftello, "ftello is unportable - " 558 "use gnulib module ftello for portability"); 559# endif 560#endif 561 562#ifdef _GL_FTELL_WARN 563# undef _GL_FTELL_WARN 564/* Here, either ftell is undefined (but C89 guarantees that it is 565 declared), or it is defined as rpl_ftell (declared above). */ 566_GL_WARN_ON_USE (ftell, "ftell cannot handle files larger than 4 GB " 567 "on 32-bit platforms - " 568 "use ftello function for handling of large files"); 569#endif 570 571 572#if @GNULIB_FWRITE@ 573# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 574# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 575# undef fwrite 576# define fwrite rpl_fwrite 577# endif 578_GL_FUNCDECL_RPL (fwrite, size_t, 579 (const void *ptr, size_t s, size_t n, FILE *stream) 580 _GL_ARG_NONNULL ((1, 4))); 581_GL_CXXALIAS_RPL (fwrite, size_t, 582 (const void *ptr, size_t s, size_t n, FILE *stream)); 583# else 584_GL_CXXALIAS_SYS (fwrite, size_t, 585 (const void *ptr, size_t s, size_t n, FILE *stream)); 586 587/* Work around bug 11959 when fortifying glibc 2.4 through 2.15 588 <http://sources.redhat.com/bugzilla/show_bug.cgi?id=11959>, 589 which sometimes causes an unwanted diagnostic for fwrite calls. 590 This affects only function declaration attributes under certain 591 versions of gcc and clang, and is not needed for C++. */ 592# if (0 < __USE_FORTIFY_LEVEL \ 593 && __GLIBC__ == 2 && 4 <= __GLIBC_MINOR__ && __GLIBC_MINOR__ <= 15 \ 594 && 3 < __GNUC__ + (4 <= __GNUC_MINOR__) \ 595 && !defined __cplusplus) 596# undef fwrite 597# undef fwrite_unlocked 598extern size_t __REDIRECT (rpl_fwrite, 599 (const void *__restrict, size_t, size_t, 600 FILE *__restrict), 601 fwrite); 602extern size_t __REDIRECT (rpl_fwrite_unlocked, 603 (const void *__restrict, size_t, size_t, 604 FILE *__restrict), 605 fwrite_unlocked); 606# define fwrite rpl_fwrite 607# define fwrite_unlocked rpl_fwrite_unlocked 608# endif 609# endif 610_GL_CXXALIASWARN (fwrite); 611#endif 612 613#if @GNULIB_GETC@ 614# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 615# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 616# undef getc 617# define getc rpl_fgetc 618# endif 619_GL_FUNCDECL_RPL (fgetc, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 620_GL_CXXALIAS_RPL_1 (getc, rpl_fgetc, int, (FILE *stream)); 621# else 622_GL_CXXALIAS_SYS (getc, int, (FILE *stream)); 623# endif 624_GL_CXXALIASWARN (getc); 625#endif 626 627#if @GNULIB_GETCHAR@ 628# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 629# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 630# undef getchar 631# define getchar rpl_getchar 632# endif 633_GL_FUNCDECL_RPL (getchar, int, (void)); 634_GL_CXXALIAS_RPL (getchar, int, (void)); 635# else 636_GL_CXXALIAS_SYS (getchar, int, (void)); 637# endif 638_GL_CXXALIASWARN (getchar); 639#endif 640 641#if @GNULIB_GETDELIM@ 642/* Read input, up to (and including) the next occurrence of DELIMITER, from 643 STREAM, store it in *LINEPTR (and NUL-terminate it). 644 *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE 645 bytes of space. It is realloc'd as necessary. 646 Return the number of bytes read and stored at *LINEPTR (not including the 647 NUL terminator), or -1 on error or EOF. */ 648# if @REPLACE_GETDELIM@ 649# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 650# undef getdelim 651# define getdelim rpl_getdelim 652# endif 653_GL_FUNCDECL_RPL (getdelim, ssize_t, 654 (char **lineptr, size_t *linesize, int delimiter, 655 FILE *stream) 656 _GL_ARG_NONNULL ((1, 2, 4))); 657_GL_CXXALIAS_RPL (getdelim, ssize_t, 658 (char **lineptr, size_t *linesize, int delimiter, 659 FILE *stream)); 660# else 661# if !@HAVE_DECL_GETDELIM@ 662_GL_FUNCDECL_SYS (getdelim, ssize_t, 663 (char **lineptr, size_t *linesize, int delimiter, 664 FILE *stream) 665 _GL_ARG_NONNULL ((1, 2, 4))); 666# endif 667_GL_CXXALIAS_SYS (getdelim, ssize_t, 668 (char **lineptr, size_t *linesize, int delimiter, 669 FILE *stream)); 670# endif 671_GL_CXXALIASWARN (getdelim); 672#elif defined GNULIB_POSIXCHECK 673# undef getdelim 674# if HAVE_RAW_DECL_GETDELIM 675_GL_WARN_ON_USE (getdelim, "getdelim is unportable - " 676 "use gnulib module getdelim for portability"); 677# endif 678#endif 679 680#if @GNULIB_GETLINE@ 681/* Read a line, up to (and including) the next newline, from STREAM, store it 682 in *LINEPTR (and NUL-terminate it). 683 *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE 684 bytes of space. It is realloc'd as necessary. 685 Return the number of bytes read and stored at *LINEPTR (not including the 686 NUL terminator), or -1 on error or EOF. */ 687# if @REPLACE_GETLINE@ 688# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 689# undef getline 690# define getline rpl_getline 691# endif 692_GL_FUNCDECL_RPL (getline, ssize_t, 693 (char **lineptr, size_t *linesize, FILE *stream) 694 _GL_ARG_NONNULL ((1, 2, 3))); 695_GL_CXXALIAS_RPL (getline, ssize_t, 696 (char **lineptr, size_t *linesize, FILE *stream)); 697# else 698# if !@HAVE_DECL_GETLINE@ 699_GL_FUNCDECL_SYS (getline, ssize_t, 700 (char **lineptr, size_t *linesize, FILE *stream) 701 _GL_ARG_NONNULL ((1, 2, 3))); 702# endif 703_GL_CXXALIAS_SYS (getline, ssize_t, 704 (char **lineptr, size_t *linesize, FILE *stream)); 705# endif 706# if @HAVE_DECL_GETLINE@ 707_GL_CXXALIASWARN (getline); 708# endif 709#elif defined GNULIB_POSIXCHECK 710# undef getline 711# if HAVE_RAW_DECL_GETLINE 712_GL_WARN_ON_USE (getline, "getline is unportable - " 713 "use gnulib module getline for portability"); 714# endif 715#endif 716 717/* It is very rare that the developer ever has full control of stdin, 718 so any use of gets warrants an unconditional warning; besides, C11 719 removed it. */ 720#undef gets 721#if HAVE_RAW_DECL_GETS 722_GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead"); 723#endif 724 725 726#if @GNULIB_OBSTACK_PRINTF@ || @GNULIB_OBSTACK_PRINTF_POSIX@ 727struct obstack; 728/* Grow an obstack with formatted output. Return the number of 729 bytes added to OBS. No trailing nul byte is added, and the 730 object should be closed with obstack_finish before use. Upon 731 memory allocation error, call obstack_alloc_failed_handler. Upon 732 other error, return -1. */ 733# if @REPLACE_OBSTACK_PRINTF@ 734# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 735# define obstack_printf rpl_obstack_printf 736# endif 737_GL_FUNCDECL_RPL (obstack_printf, int, 738 (struct obstack *obs, const char *format, ...) 739 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 740 _GL_ARG_NONNULL ((1, 2))); 741_GL_CXXALIAS_RPL (obstack_printf, int, 742 (struct obstack *obs, const char *format, ...)); 743# else 744# if !@HAVE_DECL_OBSTACK_PRINTF@ 745_GL_FUNCDECL_SYS (obstack_printf, int, 746 (struct obstack *obs, const char *format, ...) 747 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 748 _GL_ARG_NONNULL ((1, 2))); 749# endif 750_GL_CXXALIAS_SYS (obstack_printf, int, 751 (struct obstack *obs, const char *format, ...)); 752# endif 753_GL_CXXALIASWARN (obstack_printf); 754# if @REPLACE_OBSTACK_PRINTF@ 755# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 756# define obstack_vprintf rpl_obstack_vprintf 757# endif 758_GL_FUNCDECL_RPL (obstack_vprintf, int, 759 (struct obstack *obs, const char *format, va_list args) 760 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 761 _GL_ARG_NONNULL ((1, 2))); 762_GL_CXXALIAS_RPL (obstack_vprintf, int, 763 (struct obstack *obs, const char *format, va_list args)); 764# else 765# if !@HAVE_DECL_OBSTACK_PRINTF@ 766_GL_FUNCDECL_SYS (obstack_vprintf, int, 767 (struct obstack *obs, const char *format, va_list args) 768 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 769 _GL_ARG_NONNULL ((1, 2))); 770# endif 771_GL_CXXALIAS_SYS (obstack_vprintf, int, 772 (struct obstack *obs, const char *format, va_list args)); 773# endif 774_GL_CXXALIASWARN (obstack_vprintf); 775#endif 776 777#if @GNULIB_PCLOSE@ 778# if !@HAVE_PCLOSE@ 779_GL_FUNCDECL_SYS (pclose, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 780# endif 781_GL_CXXALIAS_SYS (pclose, int, (FILE *stream)); 782_GL_CXXALIASWARN (pclose); 783#elif defined GNULIB_POSIXCHECK 784# undef pclose 785# if HAVE_RAW_DECL_PCLOSE 786_GL_WARN_ON_USE (pclose, "pclose is unportable - " 787 "use gnulib module pclose for more portability"); 788# endif 789#endif 790 791#if @GNULIB_PERROR@ 792/* Print a message to standard error, describing the value of ERRNO, 793 (if STRING is not NULL and not empty) prefixed with STRING and ": ", 794 and terminated with a newline. */ 795# if @REPLACE_PERROR@ 796# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 797# define perror rpl_perror 798# endif 799_GL_FUNCDECL_RPL (perror, void, (const char *string)); 800_GL_CXXALIAS_RPL (perror, void, (const char *string)); 801# else 802_GL_CXXALIAS_SYS (perror, void, (const char *string)); 803# endif 804_GL_CXXALIASWARN (perror); 805#elif defined GNULIB_POSIXCHECK 806# undef perror 807/* Assume perror is always declared. */ 808_GL_WARN_ON_USE (perror, "perror is not always POSIX compliant - " 809 "use gnulib module perror for portability"); 810#endif 811 812#if @GNULIB_POPEN@ 813# if @REPLACE_POPEN@ 814# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 815# undef popen 816# define popen rpl_popen 817# endif 818_GL_FUNCDECL_RPL (popen, FILE *, (const char *cmd, const char *mode) 819 _GL_ARG_NONNULL ((1, 2))); 820_GL_CXXALIAS_RPL (popen, FILE *, (const char *cmd, const char *mode)); 821# else 822# if !@HAVE_POPEN@ 823_GL_FUNCDECL_SYS (popen, FILE *, (const char *cmd, const char *mode) 824 _GL_ARG_NONNULL ((1, 2))); 825# endif 826_GL_CXXALIAS_SYS (popen, FILE *, (const char *cmd, const char *mode)); 827# endif 828_GL_CXXALIASWARN (popen); 829#elif defined GNULIB_POSIXCHECK 830# undef popen 831# if HAVE_RAW_DECL_POPEN 832_GL_WARN_ON_USE (popen, "popen is buggy on some platforms - " 833 "use gnulib module popen or pipe for more portability"); 834# endif 835#endif 836 837#if @GNULIB_PRINTF_POSIX@ || @GNULIB_PRINTF@ 838# if (@GNULIB_PRINTF_POSIX@ && @REPLACE_PRINTF@) \ 839 || (@GNULIB_PRINTF@ && @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@)) 840# if defined __GNUC__ 841# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 842/* Don't break __attribute__((format(printf,M,N))). */ 843# define printf __printf__ 844# endif 845# if @GNULIB_PRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@ 846_GL_FUNCDECL_RPL_1 (__printf__, int, 847 (const char *format, ...) 848 __asm__ (@ASM_SYMBOL_PREFIX@ 849 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)) 850 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 2) 851 _GL_ARG_NONNULL ((1))); 852# else 853_GL_FUNCDECL_RPL_1 (__printf__, int, 854 (const char *format, ...) 855 __asm__ (@ASM_SYMBOL_PREFIX@ 856 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)) 857 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 2) 858 _GL_ARG_NONNULL ((1))); 859# endif 860_GL_CXXALIAS_RPL_1 (printf, __printf__, int, (const char *format, ...)); 861# else 862# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 863# define printf rpl_printf 864# endif 865_GL_FUNCDECL_RPL (printf, int, 866 (const char *format, ...) 867 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 2) 868 _GL_ARG_NONNULL ((1))); 869_GL_CXXALIAS_RPL (printf, int, (const char *format, ...)); 870# endif 871# define GNULIB_overrides_printf 1 872# else 873_GL_CXXALIAS_SYS (printf, int, (const char *format, ...)); 874# endif 875_GL_CXXALIASWARN (printf); 876#endif 877#if !@GNULIB_PRINTF_POSIX@ && defined GNULIB_POSIXCHECK 878# if !GNULIB_overrides_printf 879# undef printf 880# endif 881/* Assume printf is always declared. */ 882_GL_WARN_ON_USE (printf, "printf is not always POSIX compliant - " 883 "use gnulib module printf-posix for portable " 884 "POSIX compliance"); 885#endif 886 887#if @GNULIB_PUTC@ 888# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 889# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 890# undef putc 891# define putc rpl_fputc 892# endif 893_GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream) _GL_ARG_NONNULL ((2))); 894_GL_CXXALIAS_RPL_1 (putc, rpl_fputc, int, (int c, FILE *stream)); 895# else 896_GL_CXXALIAS_SYS (putc, int, (int c, FILE *stream)); 897# endif 898_GL_CXXALIASWARN (putc); 899#endif 900 901#if @GNULIB_PUTCHAR@ 902# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 903# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 904# undef putchar 905# define putchar rpl_putchar 906# endif 907_GL_FUNCDECL_RPL (putchar, int, (int c)); 908_GL_CXXALIAS_RPL (putchar, int, (int c)); 909# else 910_GL_CXXALIAS_SYS (putchar, int, (int c)); 911# endif 912_GL_CXXALIASWARN (putchar); 913#endif 914 915#if @GNULIB_PUTS@ 916# if @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@) 917# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 918# undef puts 919# define puts rpl_puts 920# endif 921_GL_FUNCDECL_RPL (puts, int, (const char *string) _GL_ARG_NONNULL ((1))); 922_GL_CXXALIAS_RPL (puts, int, (const char *string)); 923# else 924_GL_CXXALIAS_SYS (puts, int, (const char *string)); 925# endif 926_GL_CXXALIASWARN (puts); 927#endif 928 929#if @GNULIB_REMOVE@ 930# if @REPLACE_REMOVE@ 931# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 932# undef remove 933# define remove rpl_remove 934# endif 935_GL_FUNCDECL_RPL (remove, int, (const char *name) _GL_ARG_NONNULL ((1))); 936_GL_CXXALIAS_RPL (remove, int, (const char *name)); 937# else 938_GL_CXXALIAS_SYS (remove, int, (const char *name)); 939# endif 940_GL_CXXALIASWARN (remove); 941#elif defined GNULIB_POSIXCHECK 942# undef remove 943/* Assume remove is always declared. */ 944_GL_WARN_ON_USE (remove, "remove cannot handle directories on some platforms - " 945 "use gnulib module remove for more portability"); 946#endif 947 948#if @GNULIB_RENAME@ 949# if @REPLACE_RENAME@ 950# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 951# undef rename 952# define rename rpl_rename 953# endif 954_GL_FUNCDECL_RPL (rename, int, 955 (const char *old_filename, const char *new_filename) 956 _GL_ARG_NONNULL ((1, 2))); 957_GL_CXXALIAS_RPL (rename, int, 958 (const char *old_filename, const char *new_filename)); 959# else 960_GL_CXXALIAS_SYS (rename, int, 961 (const char *old_filename, const char *new_filename)); 962# endif 963_GL_CXXALIASWARN (rename); 964#elif defined GNULIB_POSIXCHECK 965# undef rename 966/* Assume rename is always declared. */ 967_GL_WARN_ON_USE (rename, "rename is buggy on some platforms - " 968 "use gnulib module rename for more portability"); 969#endif 970 971#if @GNULIB_RENAMEAT@ 972# if @REPLACE_RENAMEAT@ 973# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 974# undef renameat 975# define renameat rpl_renameat 976# endif 977_GL_FUNCDECL_RPL (renameat, int, 978 (int fd1, char const *file1, int fd2, char const *file2) 979 _GL_ARG_NONNULL ((2, 4))); 980_GL_CXXALIAS_RPL (renameat, int, 981 (int fd1, char const *file1, int fd2, char const *file2)); 982# else 983# if !@HAVE_RENAMEAT@ 984_GL_FUNCDECL_SYS (renameat, int, 985 (int fd1, char const *file1, int fd2, char const *file2) 986 _GL_ARG_NONNULL ((2, 4))); 987# endif 988_GL_CXXALIAS_SYS (renameat, int, 989 (int fd1, char const *file1, int fd2, char const *file2)); 990# endif 991_GL_CXXALIASWARN (renameat); 992#elif defined GNULIB_POSIXCHECK 993# undef renameat 994# if HAVE_RAW_DECL_RENAMEAT 995_GL_WARN_ON_USE (renameat, "renameat is not portable - " 996 "use gnulib module renameat for portability"); 997# endif 998#endif 999 1000#if @GNULIB_SCANF@ 1001# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 1002# if defined __GNUC__ 1003# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1004# undef scanf 1005/* Don't break __attribute__((format(scanf,M,N))). */ 1006# define scanf __scanf__ 1007# endif 1008_GL_FUNCDECL_RPL_1 (__scanf__, int, 1009 (const char *format, ...) 1010 __asm__ (@ASM_SYMBOL_PREFIX@ 1011 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_scanf)) 1012 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2) 1013 _GL_ARG_NONNULL ((1))); 1014_GL_CXXALIAS_RPL_1 (scanf, __scanf__, int, (const char *format, ...)); 1015# else 1016# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1017# undef scanf 1018# define scanf rpl_scanf 1019# endif 1020_GL_FUNCDECL_RPL (scanf, int, (const char *format, ...) 1021 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2) 1022 _GL_ARG_NONNULL ((1))); 1023_GL_CXXALIAS_RPL (scanf, int, (const char *format, ...)); 1024# endif 1025# else 1026_GL_CXXALIAS_SYS (scanf, int, (const char *format, ...)); 1027# endif 1028_GL_CXXALIASWARN (scanf); 1029#endif 1030 1031#if @GNULIB_SNPRINTF@ 1032# if @REPLACE_SNPRINTF@ 1033# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1034# define snprintf rpl_snprintf 1035# endif 1036_GL_FUNCDECL_RPL (snprintf, int, 1037 (char *str, size_t size, const char *format, ...) 1038 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 4) 1039 _GL_ARG_NONNULL ((3))); 1040_GL_CXXALIAS_RPL (snprintf, int, 1041 (char *str, size_t size, const char *format, ...)); 1042# else 1043# if !@HAVE_DECL_SNPRINTF@ 1044_GL_FUNCDECL_SYS (snprintf, int, 1045 (char *str, size_t size, const char *format, ...) 1046 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 4) 1047 _GL_ARG_NONNULL ((3))); 1048# endif 1049_GL_CXXALIAS_SYS (snprintf, int, 1050 (char *str, size_t size, const char *format, ...)); 1051# endif 1052_GL_CXXALIASWARN (snprintf); 1053#elif defined GNULIB_POSIXCHECK 1054# undef snprintf 1055# if HAVE_RAW_DECL_SNPRINTF 1056_GL_WARN_ON_USE (snprintf, "snprintf is unportable - " 1057 "use gnulib module snprintf for portability"); 1058# endif 1059#endif 1060 1061/* Some people would argue that all sprintf uses should be warned about 1062 (for example, OpenBSD issues a link warning for it), 1063 since it can cause security holes due to buffer overruns. 1064 However, we believe that sprintf can be used safely, and is more 1065 efficient than snprintf in those safe cases; and as proof of our 1066 belief, we use sprintf in several gnulib modules. So this header 1067 intentionally avoids adding a warning to sprintf except when 1068 GNULIB_POSIXCHECK is defined. */ 1069 1070#if @GNULIB_SPRINTF_POSIX@ 1071# if @REPLACE_SPRINTF@ 1072# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1073# define sprintf rpl_sprintf 1074# endif 1075_GL_FUNCDECL_RPL (sprintf, int, (char *str, const char *format, ...) 1076 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1077 _GL_ARG_NONNULL ((1, 2))); 1078_GL_CXXALIAS_RPL (sprintf, int, (char *str, const char *format, ...)); 1079# else 1080_GL_CXXALIAS_SYS (sprintf, int, (char *str, const char *format, ...)); 1081# endif 1082_GL_CXXALIASWARN (sprintf); 1083#elif defined GNULIB_POSIXCHECK 1084# undef sprintf 1085/* Assume sprintf is always declared. */ 1086_GL_WARN_ON_USE (sprintf, "sprintf is not always POSIX compliant - " 1087 "use gnulib module sprintf-posix for portable " 1088 "POSIX compliance"); 1089#endif 1090 1091#if @GNULIB_TMPFILE@ 1092# if @REPLACE_TMPFILE@ 1093# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1094# define tmpfile rpl_tmpfile 1095# endif 1096_GL_FUNCDECL_RPL (tmpfile, FILE *, (void)); 1097_GL_CXXALIAS_RPL (tmpfile, FILE *, (void)); 1098# else 1099_GL_CXXALIAS_SYS (tmpfile, FILE *, (void)); 1100# endif 1101_GL_CXXALIASWARN (tmpfile); 1102#elif defined GNULIB_POSIXCHECK 1103# undef tmpfile 1104# if HAVE_RAW_DECL_TMPFILE 1105_GL_WARN_ON_USE (tmpfile, "tmpfile is not usable on mingw - " 1106 "use gnulib module tmpfile for portability"); 1107# endif 1108#endif 1109 1110#if @GNULIB_VASPRINTF@ 1111/* Write formatted output to a string dynamically allocated with malloc(). 1112 If the memory allocation succeeds, store the address of the string in 1113 *RESULT and return the number of resulting bytes, excluding the trailing 1114 NUL. Upon memory allocation error, or some other error, return -1. */ 1115# if @REPLACE_VASPRINTF@ 1116# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1117# define asprintf rpl_asprintf 1118# endif 1119_GL_FUNCDECL_RPL (asprintf, int, 1120 (char **result, const char *format, ...) 1121 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1122 _GL_ARG_NONNULL ((1, 2))); 1123_GL_CXXALIAS_RPL (asprintf, int, 1124 (char **result, const char *format, ...)); 1125# else 1126# if !@HAVE_VASPRINTF@ 1127_GL_FUNCDECL_SYS (asprintf, int, 1128 (char **result, const char *format, ...) 1129 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1130 _GL_ARG_NONNULL ((1, 2))); 1131# endif 1132_GL_CXXALIAS_SYS (asprintf, int, 1133 (char **result, const char *format, ...)); 1134# endif 1135_GL_CXXALIASWARN (asprintf); 1136# if @REPLACE_VASPRINTF@ 1137# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1138# define vasprintf rpl_vasprintf 1139# endif 1140_GL_FUNCDECL_RPL (vasprintf, int, 1141 (char **result, const char *format, va_list args) 1142 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1143 _GL_ARG_NONNULL ((1, 2))); 1144_GL_CXXALIAS_RPL (vasprintf, int, 1145 (char **result, const char *format, va_list args)); 1146# else 1147# if !@HAVE_VASPRINTF@ 1148_GL_FUNCDECL_SYS (vasprintf, int, 1149 (char **result, const char *format, va_list args) 1150 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1151 _GL_ARG_NONNULL ((1, 2))); 1152# endif 1153_GL_CXXALIAS_SYS (vasprintf, int, 1154 (char **result, const char *format, va_list args)); 1155# endif 1156_GL_CXXALIASWARN (vasprintf); 1157#endif 1158 1159#if @GNULIB_VDPRINTF@ 1160# if @REPLACE_VDPRINTF@ 1161# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1162# define vdprintf rpl_vdprintf 1163# endif 1164_GL_FUNCDECL_RPL (vdprintf, int, (int fd, const char *format, va_list args) 1165 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1166 _GL_ARG_NONNULL ((2))); 1167_GL_CXXALIAS_RPL (vdprintf, int, (int fd, const char *format, va_list args)); 1168# else 1169# if !@HAVE_VDPRINTF@ 1170_GL_FUNCDECL_SYS (vdprintf, int, (int fd, const char *format, va_list args) 1171 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1172 _GL_ARG_NONNULL ((2))); 1173# endif 1174/* Need to cast, because on Solaris, the third parameter will likely be 1175 __va_list args. */ 1176_GL_CXXALIAS_SYS_CAST (vdprintf, int, 1177 (int fd, const char *format, va_list args)); 1178# endif 1179_GL_CXXALIASWARN (vdprintf); 1180#elif defined GNULIB_POSIXCHECK 1181# undef vdprintf 1182# if HAVE_RAW_DECL_VDPRINTF 1183_GL_WARN_ON_USE (vdprintf, "vdprintf is unportable - " 1184 "use gnulib module vdprintf for portability"); 1185# endif 1186#endif 1187 1188#if @GNULIB_VFPRINTF_POSIX@ || @GNULIB_VFPRINTF@ 1189# if (@GNULIB_VFPRINTF_POSIX@ && @REPLACE_VFPRINTF@) \ 1190 || (@GNULIB_VFPRINTF@ && @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@)) 1191# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1192# define vfprintf rpl_vfprintf 1193# endif 1194# define GNULIB_overrides_vfprintf 1 1195# if @GNULIB_VFPRINTF_POSIX@ 1196_GL_FUNCDECL_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args) 1197 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1198 _GL_ARG_NONNULL ((1, 2))); 1199# else 1200_GL_FUNCDECL_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args) 1201 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 0) 1202 _GL_ARG_NONNULL ((1, 2))); 1203# endif 1204_GL_CXXALIAS_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args)); 1205# else 1206/* Need to cast, because on Solaris, the third parameter is 1207 __va_list args 1208 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1209_GL_CXXALIAS_SYS_CAST (vfprintf, int, 1210 (FILE *fp, const char *format, va_list args)); 1211# endif 1212_GL_CXXALIASWARN (vfprintf); 1213#endif 1214#if !@GNULIB_VFPRINTF_POSIX@ && defined GNULIB_POSIXCHECK 1215# if !GNULIB_overrides_vfprintf 1216# undef vfprintf 1217# endif 1218/* Assume vfprintf is always declared. */ 1219_GL_WARN_ON_USE (vfprintf, "vfprintf is not always POSIX compliant - " 1220 "use gnulib module vfprintf-posix for portable " 1221 "POSIX compliance"); 1222#endif 1223 1224#if @GNULIB_VFSCANF@ 1225# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 1226# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1227# undef vfscanf 1228# define vfscanf rpl_vfscanf 1229# endif 1230_GL_FUNCDECL_RPL (vfscanf, int, 1231 (FILE *stream, const char *format, va_list args) 1232 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 0) 1233 _GL_ARG_NONNULL ((1, 2))); 1234_GL_CXXALIAS_RPL (vfscanf, int, 1235 (FILE *stream, const char *format, va_list args)); 1236# else 1237_GL_CXXALIAS_SYS (vfscanf, int, 1238 (FILE *stream, const char *format, va_list args)); 1239# endif 1240_GL_CXXALIASWARN (vfscanf); 1241#endif 1242 1243#if @GNULIB_VPRINTF_POSIX@ || @GNULIB_VPRINTF@ 1244# if (@GNULIB_VPRINTF_POSIX@ && @REPLACE_VPRINTF@) \ 1245 || (@GNULIB_VPRINTF@ && @REPLACE_STDIO_WRITE_FUNCS@ && (@GNULIB_STDIO_H_NONBLOCKING@ || @GNULIB_STDIO_H_SIGPIPE@)) 1246# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1247# define vprintf rpl_vprintf 1248# endif 1249# define GNULIB_overrides_vprintf 1 1250# if @GNULIB_VPRINTF_POSIX@ || @GNULIB_VFPRINTF_POSIX@ 1251_GL_FUNCDECL_RPL (vprintf, int, (const char *format, va_list args) 1252 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 0) 1253 _GL_ARG_NONNULL ((1))); 1254# else 1255_GL_FUNCDECL_RPL (vprintf, int, (const char *format, va_list args) 1256 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 0) 1257 _GL_ARG_NONNULL ((1))); 1258# endif 1259_GL_CXXALIAS_RPL (vprintf, int, (const char *format, va_list args)); 1260# else 1261/* Need to cast, because on Solaris, the second parameter is 1262 __va_list args 1263 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1264_GL_CXXALIAS_SYS_CAST (vprintf, int, (const char *format, va_list args)); 1265# endif 1266_GL_CXXALIASWARN (vprintf); 1267#endif 1268#if !@GNULIB_VPRINTF_POSIX@ && defined GNULIB_POSIXCHECK 1269# if !GNULIB_overrides_vprintf 1270# undef vprintf 1271# endif 1272/* Assume vprintf is always declared. */ 1273_GL_WARN_ON_USE (vprintf, "vprintf is not always POSIX compliant - " 1274 "use gnulib module vprintf-posix for portable " 1275 "POSIX compliance"); 1276#endif 1277 1278#if @GNULIB_VSCANF@ 1279# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ 1280# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1281# undef vscanf 1282# define vscanf rpl_vscanf 1283# endif 1284_GL_FUNCDECL_RPL (vscanf, int, (const char *format, va_list args) 1285 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 0) 1286 _GL_ARG_NONNULL ((1))); 1287_GL_CXXALIAS_RPL (vscanf, int, (const char *format, va_list args)); 1288# else 1289_GL_CXXALIAS_SYS (vscanf, int, (const char *format, va_list args)); 1290# endif 1291_GL_CXXALIASWARN (vscanf); 1292#endif 1293 1294#if @GNULIB_VSNPRINTF@ 1295# if @REPLACE_VSNPRINTF@ 1296# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1297# define vsnprintf rpl_vsnprintf 1298# endif 1299_GL_FUNCDECL_RPL (vsnprintf, int, 1300 (char *str, size_t size, const char *format, va_list args) 1301 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 0) 1302 _GL_ARG_NONNULL ((3))); 1303_GL_CXXALIAS_RPL (vsnprintf, int, 1304 (char *str, size_t size, const char *format, va_list args)); 1305# else 1306# if !@HAVE_DECL_VSNPRINTF@ 1307_GL_FUNCDECL_SYS (vsnprintf, int, 1308 (char *str, size_t size, const char *format, va_list args) 1309 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 0) 1310 _GL_ARG_NONNULL ((3))); 1311# endif 1312_GL_CXXALIAS_SYS (vsnprintf, int, 1313 (char *str, size_t size, const char *format, va_list args)); 1314# endif 1315_GL_CXXALIASWARN (vsnprintf); 1316#elif defined GNULIB_POSIXCHECK 1317# undef vsnprintf 1318# if HAVE_RAW_DECL_VSNPRINTF 1319_GL_WARN_ON_USE (vsnprintf, "vsnprintf is unportable - " 1320 "use gnulib module vsnprintf for portability"); 1321# endif 1322#endif 1323 1324#if @GNULIB_VSPRINTF_POSIX@ 1325# if @REPLACE_VSPRINTF@ 1326# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1327# define vsprintf rpl_vsprintf 1328# endif 1329_GL_FUNCDECL_RPL (vsprintf, int, 1330 (char *str, const char *format, va_list args) 1331 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1332 _GL_ARG_NONNULL ((1, 2))); 1333_GL_CXXALIAS_RPL (vsprintf, int, 1334 (char *str, const char *format, va_list args)); 1335# else 1336/* Need to cast, because on Solaris, the third parameter is 1337 __va_list args 1338 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1339_GL_CXXALIAS_SYS_CAST (vsprintf, int, 1340 (char *str, const char *format, va_list args)); 1341# endif 1342_GL_CXXALIASWARN (vsprintf); 1343#elif defined GNULIB_POSIXCHECK 1344# undef vsprintf 1345/* Assume vsprintf is always declared. */ 1346_GL_WARN_ON_USE (vsprintf, "vsprintf is not always POSIX compliant - " 1347 "use gnulib module vsprintf-posix for portable " 1348 "POSIX compliance"); 1349#endif 1350 1351#endif /* _@GUARD_PREFIX@_STDIO_H */ 1352#endif /* _@GUARD_PREFIX@_STDIO_H */ 1353#endif 1354