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)) 590 rpl_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@ 717 struct 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