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