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