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