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