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