1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2 /* A GNU-like <stdio.h>. 3 4 Copyright (C) 2004, 2007-2015 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 18 19 #if __GNUC__ >= 3 20 #pragma GCC system_header 21 #endif 22 23 24 #if defined __need_FILE || defined __need___FILE || defined _GL_ALREADY_INCLUDING_STDIO_H 25 /* Special invocation convention: 26 - Inside glibc header files. 27 - On OSF/1 5.1 we have a sequence of nested includes 28 <stdio.h> -> <getopt.h> -> <ctype.h> -> <sys/localedef.h> -> 29 <sys/lc_core.h> -> <nl_types.h> -> <mesg.h> -> <stdio.h>. 30 In this situation, the functions are not yet declared, therefore we cannot 31 provide the C++ aliases. */ 32 33 #include_next <stdio.h> 34 35 #else 36 /* Normal invocation convention. */ 37 38 #ifndef _GL_STDIO_H 39 40 #define _GL_ALREADY_INCLUDING_STDIO_H 41 42 /* The include_next requires a split double-inclusion guard. */ 43 #include_next <stdio.h> 44 45 #undef _GL_ALREADY_INCLUDING_STDIO_H 46 47 #ifndef _GL_STDIO_H 48 #define _GL_STDIO_H 49 50 /* Get va_list. Needed on many systems, including glibc 2.8. */ 51 #include <stdarg.h> 52 53 #include <stddef.h> 54 55 /* Get off_t and ssize_t. Needed on many systems, including glibc 2.8 56 and eglibc 2.11.2. 57 May also define off_t to a 64-bit type on native Windows. */ 58 #include <sys/types.h> 59 60 /* The __attribute__ feature is available in gcc versions 2.5 and later. 61 The __-protected variants of the attributes 'format' and 'printf' are 62 accepted by gcc versions 2.6.4 (effectively 2.7) and later. 63 We enable _GL_ATTRIBUTE_FORMAT only if these are supported too, because 64 gnulib and libintl do '#define printf __printf__' when they override 65 the 'printf' function. */ 66 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7) 67 # define _GL_ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec)) 68 #else 69 # define _GL_ATTRIBUTE_FORMAT(spec) /* empty */ 70 #endif 71 72 /* _GL_ATTRIBUTE_FORMAT_PRINTF 73 indicates to GCC that the function takes a format string and arguments, 74 where the format string directives are the ones standardized by ISO C99 75 and POSIX. */ 76 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) 77 # define _GL_ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ 78 _GL_ATTRIBUTE_FORMAT ((__gnu_printf__, formatstring_parameter, first_argument)) 79 #else 80 # define _GL_ATTRIBUTE_FORMAT_PRINTF(formatstring_parameter, first_argument) \ 81 _GL_ATTRIBUTE_FORMAT ((__printf__, formatstring_parameter, first_argument)) 82 #endif 83 84 /* _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM is like _GL_ATTRIBUTE_FORMAT_PRINTF, 85 except that it indicates to GCC that the supported format string directives 86 are the ones of the system printf(), rather than the ones standardized by 87 ISO C99 and POSIX. */ 88 #if GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU 89 # define _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM(formatstring_parameter, first_argument) \ 90 _GL_ATTRIBUTE_FORMAT_PRINTF (formatstring_parameter, first_argument) 91 #else 92 # define _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM(formatstring_parameter, first_argument) \ 93 _GL_ATTRIBUTE_FORMAT ((__printf__, formatstring_parameter, first_argument)) 94 #endif 95 96 /* _GL_ATTRIBUTE_FORMAT_SCANF 97 indicates to GCC that the function takes a format string and arguments, 98 where the format string directives are the ones standardized by ISO C99 99 and POSIX. */ 100 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) 101 # define _GL_ATTRIBUTE_FORMAT_SCANF(formatstring_parameter, first_argument) \ 102 _GL_ATTRIBUTE_FORMAT ((__gnu_scanf__, formatstring_parameter, first_argument)) 103 #else 104 # define _GL_ATTRIBUTE_FORMAT_SCANF(formatstring_parameter, first_argument) \ 105 _GL_ATTRIBUTE_FORMAT ((__scanf__, formatstring_parameter, first_argument)) 106 #endif 107 108 /* _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM is like _GL_ATTRIBUTE_FORMAT_SCANF, 109 except that it indicates to GCC that the supported format string directives 110 are the ones of the system scanf(), rather than the ones standardized by 111 ISO C99 and POSIX. */ 112 #define _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM(formatstring_parameter, first_argument) \ 113 _GL_ATTRIBUTE_FORMAT ((__scanf__, formatstring_parameter, first_argument)) 114 115 /* Solaris 10 declares renameat in <unistd.h>, not in <stdio.h>. */ 116 /* But in any case avoid namespace pollution on glibc systems. */ 117 #if (0 || defined GNULIB_POSIXCHECK) && defined __sun \ 118 && ! defined __GLIBC__ 119 # include <unistd.h> 120 #endif 121 122 123 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 124 #ifndef _GL_CXXDEFS_H 125 #define _GL_CXXDEFS_H 126 127 /* The three most frequent use cases of these macros are: 128 129 * For providing a substitute for a function that is missing on some 130 platforms, but is declared and works fine on the platforms on which 131 it exists: 132 133 #if @GNULIB_FOO@ 134 # if !@HAVE_FOO@ 135 _GL_FUNCDECL_SYS (foo, ...); 136 # endif 137 _GL_CXXALIAS_SYS (foo, ...); 138 _GL_CXXALIASWARN (foo); 139 #elif defined GNULIB_POSIXCHECK 140 ... 141 #endif 142 143 * For providing a replacement for a function that exists on all platforms, 144 but is broken/insufficient and needs to be replaced on some platforms: 145 146 #if @GNULIB_FOO@ 147 # if @REPLACE_FOO@ 148 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 149 # undef foo 150 # define foo rpl_foo 151 # endif 152 _GL_FUNCDECL_RPL (foo, ...); 153 _GL_CXXALIAS_RPL (foo, ...); 154 # else 155 _GL_CXXALIAS_SYS (foo, ...); 156 # endif 157 _GL_CXXALIASWARN (foo); 158 #elif defined GNULIB_POSIXCHECK 159 ... 160 #endif 161 162 * For providing a replacement for a function that exists on some platforms 163 but is broken/insufficient and needs to be replaced on some of them and 164 is additionally either missing or undeclared on some other platforms: 165 166 #if @GNULIB_FOO@ 167 # if @REPLACE_FOO@ 168 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 169 # undef foo 170 # define foo rpl_foo 171 # endif 172 _GL_FUNCDECL_RPL (foo, ...); 173 _GL_CXXALIAS_RPL (foo, ...); 174 # else 175 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 176 _GL_FUNCDECL_SYS (foo, ...); 177 # endif 178 _GL_CXXALIAS_SYS (foo, ...); 179 # endif 180 _GL_CXXALIASWARN (foo); 181 #elif defined GNULIB_POSIXCHECK 182 ... 183 #endif 184 */ 185 186 /* _GL_EXTERN_C declaration; 187 performs the declaration with C linkage. */ 188 #if defined __cplusplus 189 # define _GL_EXTERN_C extern "C" 190 #else 191 # define _GL_EXTERN_C extern 192 #endif 193 194 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 195 declares a replacement function, named rpl_func, with the given prototype, 196 consisting of return type, parameters, and attributes. 197 Example: 198 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 199 _GL_ARG_NONNULL ((1))); 200 */ 201 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 202 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 203 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 204 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 205 206 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 207 declares the system function, named func, with the given prototype, 208 consisting of return type, parameters, and attributes. 209 Example: 210 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 211 _GL_ARG_NONNULL ((1))); 212 */ 213 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 214 _GL_EXTERN_C rettype func parameters_and_attributes 215 216 /* _GL_CXXALIAS_RPL (func, rettype, parameters); 217 declares a C++ alias called GNULIB_NAMESPACE::func 218 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 219 Example: 220 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 221 */ 222 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 223 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 224 #if defined __cplusplus && defined GNULIB_NAMESPACE 225 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 226 namespace GNULIB_NAMESPACE \ 227 { \ 228 rettype (*const func) parameters = ::rpl_func; \ 229 } \ 230 _GL_EXTERN_C int _gl_cxxalias_dummy 231 #else 232 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 233 _GL_EXTERN_C int _gl_cxxalias_dummy 234 #endif 235 236 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 237 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 238 except that the C function rpl_func may have a slightly different 239 declaration. A cast is used to silence the "invalid conversion" error 240 that would otherwise occur. */ 241 #if defined __cplusplus && defined GNULIB_NAMESPACE 242 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 243 namespace GNULIB_NAMESPACE \ 244 { \ 245 rettype (*const func) parameters = \ 246 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 247 } \ 248 _GL_EXTERN_C int _gl_cxxalias_dummy 249 #else 250 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 251 _GL_EXTERN_C int _gl_cxxalias_dummy 252 #endif 253 254 /* _GL_CXXALIAS_SYS (func, rettype, parameters); 255 declares a C++ alias called GNULIB_NAMESPACE::func 256 that redirects to the system provided function func, if GNULIB_NAMESPACE 257 is defined. 258 Example: 259 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 260 */ 261 #if defined __cplusplus && defined GNULIB_NAMESPACE 262 /* If we were to write 263 rettype (*const func) parameters = ::func; 264 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 265 better (remove an indirection through a 'static' pointer variable), 266 but then the _GL_CXXALIASWARN macro below would cause a warning not only 267 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 268 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 269 namespace GNULIB_NAMESPACE \ 270 { \ 271 static rettype (*func) parameters = ::func; \ 272 } \ 273 _GL_EXTERN_C int _gl_cxxalias_dummy 274 #else 275 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 276 _GL_EXTERN_C int _gl_cxxalias_dummy 277 #endif 278 279 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 280 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 281 except that the C function func may have a slightly different declaration. 282 A cast is used to silence the "invalid conversion" error that would 283 otherwise occur. */ 284 #if defined __cplusplus && defined GNULIB_NAMESPACE 285 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 286 namespace GNULIB_NAMESPACE \ 287 { \ 288 static rettype (*func) parameters = \ 289 reinterpret_cast<rettype(*)parameters>(::func); \ 290 } \ 291 _GL_EXTERN_C int _gl_cxxalias_dummy 292 #else 293 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 294 _GL_EXTERN_C int _gl_cxxalias_dummy 295 #endif 296 297 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 298 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 299 except that the C function is picked among a set of overloaded functions, 300 namely the one with rettype2 and parameters2. Two consecutive casts 301 are used to silence the "cannot find a match" and "invalid conversion" 302 errors that would otherwise occur. */ 303 #if defined __cplusplus && defined GNULIB_NAMESPACE 304 /* The outer cast must be a reinterpret_cast. 305 The inner cast: When the function is defined as a set of overloaded 306 functions, it works as a static_cast<>, choosing the designated variant. 307 When the function is defined as a single variant, it works as a 308 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 309 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 310 namespace GNULIB_NAMESPACE \ 311 { \ 312 static rettype (*func) parameters = \ 313 reinterpret_cast<rettype(*)parameters>( \ 314 (rettype2(*)parameters2)(::func)); \ 315 } \ 316 _GL_EXTERN_C int _gl_cxxalias_dummy 317 #else 318 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 319 _GL_EXTERN_C int _gl_cxxalias_dummy 320 #endif 321 322 /* _GL_CXXALIASWARN (func); 323 causes a warning to be emitted when ::func is used but not when 324 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 325 variants. */ 326 #if defined __cplusplus && defined GNULIB_NAMESPACE 327 # define _GL_CXXALIASWARN(func) \ 328 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 329 # define _GL_CXXALIASWARN_1(func,namespace) \ 330 _GL_CXXALIASWARN_2 (func, namespace) 331 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 332 we enable the warning only when not optimizing. */ 333 # if !__OPTIMIZE__ 334 # define _GL_CXXALIASWARN_2(func,namespace) \ 335 _GL_WARN_ON_USE (func, \ 336 "The symbol ::" #func " refers to the system function. " \ 337 "Use " #namespace "::" #func " instead.") 338 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 339 # define _GL_CXXALIASWARN_2(func,namespace) \ 340 extern __typeof__ (func) func 341 # else 342 # define _GL_CXXALIASWARN_2(func,namespace) \ 343 _GL_EXTERN_C int _gl_cxxalias_dummy 344 # endif 345 #else 346 # define _GL_CXXALIASWARN(func) \ 347 _GL_EXTERN_C int _gl_cxxalias_dummy 348 #endif 349 350 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 351 causes a warning to be emitted when the given overloaded variant of ::func 352 is used but not when GNULIB_NAMESPACE::func is used. */ 353 #if defined __cplusplus && defined GNULIB_NAMESPACE 354 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 355 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 356 GNULIB_NAMESPACE) 357 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 358 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 359 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 360 we enable the warning only when not optimizing. */ 361 # if !__OPTIMIZE__ 362 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 363 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 364 "The symbol ::" #func " refers to the system function. " \ 365 "Use " #namespace "::" #func " instead.") 366 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 367 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 368 extern __typeof__ (func) func 369 # else 370 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 371 _GL_EXTERN_C int _gl_cxxalias_dummy 372 # endif 373 #else 374 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 375 _GL_EXTERN_C int _gl_cxxalias_dummy 376 #endif 377 378 #endif /* _GL_CXXDEFS_H */ 379 380 /* The definition of _GL_ARG_NONNULL is copied here. */ 381 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 382 that the values passed as arguments n, ..., m must be non-NULL pointers. 383 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 384 #ifndef _GL_ARG_NONNULL 385 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 386 # define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 387 # else 388 # define _GL_ARG_NONNULL(params) 389 # endif 390 #endif 391 392 /* The definition of _GL_WARN_ON_USE is copied here. */ 393 #ifndef _GL_WARN_ON_USE 394 395 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 396 /* A compiler attribute is available in gcc versions 4.3.0 and later. */ 397 # define _GL_WARN_ON_USE(function, message) \ 398 extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 399 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 400 /* Verify the existence of the function. */ 401 # define _GL_WARN_ON_USE(function, message) \ 402 extern __typeof__ (function) function 403 # else /* Unsupported. */ 404 # define _GL_WARN_ON_USE(function, message) \ 405 _GL_WARN_EXTERN_C int _gl_warn_on_use 406 # endif 407 #endif 408 409 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 410 is like _GL_WARN_ON_USE (function, "string"), except that the function is 411 declared with the given prototype, consisting of return type, parameters, 412 and attributes. 413 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 414 not work in this case. */ 415 #ifndef _GL_WARN_ON_USE_CXX 416 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 417 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 418 extern rettype function parameters_and_attributes \ 419 __attribute__ ((__warning__ (msg))) 420 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 421 /* Verify the existence of the function. */ 422 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 423 extern rettype function parameters_and_attributes 424 # else /* Unsupported. */ 425 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 426 _GL_WARN_EXTERN_C int _gl_warn_on_use 427 # endif 428 #endif 429 430 /* _GL_WARN_EXTERN_C declaration; 431 performs the declaration with C linkage. */ 432 #ifndef _GL_WARN_EXTERN_C 433 # if defined __cplusplus 434 # define _GL_WARN_EXTERN_C extern "C" 435 # else 436 # define _GL_WARN_EXTERN_C extern 437 # endif 438 #endif 439 440 /* Macros for stringification. */ 441 #define _GL_STDIO_STRINGIZE(token) #token 442 #define _GL_STDIO_MACROEXPAND_AND_STRINGIZE(token) _GL_STDIO_STRINGIZE(token) 443 444 /* When also using extern inline, suppress the use of static inline in 445 standard headers of problematic Apple configurations, as Libc at 446 least through Libc-825.26 (2013-04-09) mishandles it; see, e.g., 447 <http://lists.gnu.org/archive/html/bug-gnulib/2012-12/msg00023.html>. 448 Perhaps Apple will fix this some day. */ 449 #if (defined _GL_EXTERN_INLINE_IN_USE && defined __APPLE__ \ 450 && defined __GNUC__ && defined __STDC__) 451 # undef putc_unlocked 452 #endif 453 454 #if 0 455 # if 0 456 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 457 # define dprintf rpl_dprintf 458 # endif 459 _GL_FUNCDECL_RPL (dprintf, int, (int fd, const char *format, ...) 460 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 461 _GL_ARG_NONNULL ((2))); 462 _GL_CXXALIAS_RPL (dprintf, int, (int fd, const char *format, ...)); 463 # else 464 # if !1 465 _GL_FUNCDECL_SYS (dprintf, int, (int fd, const char *format, ...) 466 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 467 _GL_ARG_NONNULL ((2))); 468 # endif 469 _GL_CXXALIAS_SYS (dprintf, int, (int fd, const char *format, ...)); 470 # endif 471 _GL_CXXALIASWARN (dprintf); 472 #elif defined GNULIB_POSIXCHECK 473 # undef dprintf 474 # if HAVE_RAW_DECL_DPRINTF 475 _GL_WARN_ON_USE (dprintf, "dprintf is unportable - " 476 "use gnulib module dprintf for portability"); 477 # endif 478 #endif 479 480 #if 0 481 /* Close STREAM and its underlying file descriptor. */ 482 # if 0 483 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 484 # define fclose rpl_fclose 485 # endif 486 _GL_FUNCDECL_RPL (fclose, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 487 _GL_CXXALIAS_RPL (fclose, int, (FILE *stream)); 488 # else 489 _GL_CXXALIAS_SYS (fclose, int, (FILE *stream)); 490 # endif 491 _GL_CXXALIASWARN (fclose); 492 #elif defined GNULIB_POSIXCHECK 493 # undef fclose 494 /* Assume fclose is always declared. */ 495 _GL_WARN_ON_USE (fclose, "fclose is not always POSIX compliant - " 496 "use gnulib module fclose for portable POSIX compliance"); 497 #endif 498 499 #if IN_GREP_GNULIB_TESTS 500 # if 0 501 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 502 # undef fdopen 503 # define fdopen rpl_fdopen 504 # endif 505 _GL_FUNCDECL_RPL (fdopen, FILE *, (int fd, const char *mode) 506 _GL_ARG_NONNULL ((2))); 507 _GL_CXXALIAS_RPL (fdopen, FILE *, (int fd, const char *mode)); 508 # else 509 _GL_CXXALIAS_SYS (fdopen, FILE *, (int fd, const char *mode)); 510 # endif 511 _GL_CXXALIASWARN (fdopen); 512 #elif defined GNULIB_POSIXCHECK 513 # undef fdopen 514 /* Assume fdopen is always declared. */ 515 _GL_WARN_ON_USE (fdopen, "fdopen on native Windows platforms is not POSIX compliant - " 516 "use gnulib module fdopen for portability"); 517 #endif 518 519 #if 0 520 /* Flush all pending data on STREAM according to POSIX rules. Both 521 output and seekable input streams are supported. 522 Note! LOSS OF DATA can occur if fflush is applied on an input stream 523 that is _not_seekable_ or on an update stream that is _not_seekable_ 524 and in which the most recent operation was input. Seekability can 525 be tested with lseek(fileno(fp),0,SEEK_CUR). */ 526 # if 0 527 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 528 # define fflush rpl_fflush 529 # endif 530 _GL_FUNCDECL_RPL (fflush, int, (FILE *gl_stream)); 531 _GL_CXXALIAS_RPL (fflush, int, (FILE *gl_stream)); 532 # else 533 _GL_CXXALIAS_SYS (fflush, int, (FILE *gl_stream)); 534 # endif 535 _GL_CXXALIASWARN (fflush); 536 #elif defined GNULIB_POSIXCHECK 537 # undef fflush 538 /* Assume fflush is always declared. */ 539 _GL_WARN_ON_USE (fflush, "fflush is not always POSIX compliant - " 540 "use gnulib module fflush for portable POSIX compliance"); 541 #endif 542 543 #if 1 544 # if 0 && 0 545 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 546 # undef fgetc 547 # define fgetc rpl_fgetc 548 # endif 549 _GL_FUNCDECL_RPL (fgetc, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 550 _GL_CXXALIAS_RPL (fgetc, int, (FILE *stream)); 551 # else 552 _GL_CXXALIAS_SYS (fgetc, int, (FILE *stream)); 553 # endif 554 _GL_CXXALIASWARN (fgetc); 555 #endif 556 557 #if 1 558 # if 0 && 0 559 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 560 # undef fgets 561 # define fgets rpl_fgets 562 # endif 563 _GL_FUNCDECL_RPL (fgets, char *, (char *s, int n, FILE *stream) 564 _GL_ARG_NONNULL ((1, 3))); 565 _GL_CXXALIAS_RPL (fgets, char *, (char *s, int n, FILE *stream)); 566 # else 567 _GL_CXXALIAS_SYS (fgets, char *, (char *s, int n, FILE *stream)); 568 # endif 569 _GL_CXXALIASWARN (fgets); 570 #endif 571 572 #if 0 573 # if 0 574 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 575 # undef fopen 576 # define fopen rpl_fopen 577 # endif 578 _GL_FUNCDECL_RPL (fopen, FILE *, (const char *filename, const char *mode) 579 _GL_ARG_NONNULL ((1, 2))); 580 _GL_CXXALIAS_RPL (fopen, FILE *, (const char *filename, const char *mode)); 581 # else 582 _GL_CXXALIAS_SYS (fopen, FILE *, (const char *filename, const char *mode)); 583 # endif 584 _GL_CXXALIASWARN (fopen); 585 #elif defined GNULIB_POSIXCHECK 586 # undef fopen 587 /* Assume fopen is always declared. */ 588 _GL_WARN_ON_USE (fopen, "fopen on native Windows platforms is not POSIX compliant - " 589 "use gnulib module fopen for portability"); 590 #endif 591 592 #if 0 || 1 593 # if (0 && 0) \ 594 || (1 && 0 && (0 || 0)) 595 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 596 # define fprintf rpl_fprintf 597 # endif 598 # define GNULIB_overrides_fprintf 1 599 # if 0 || 0 600 _GL_FUNCDECL_RPL (fprintf, int, (FILE *fp, const char *format, ...) 601 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 602 _GL_ARG_NONNULL ((1, 2))); 603 # else 604 _GL_FUNCDECL_RPL (fprintf, int, (FILE *fp, const char *format, ...) 605 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 3) 606 _GL_ARG_NONNULL ((1, 2))); 607 # endif 608 _GL_CXXALIAS_RPL (fprintf, int, (FILE *fp, const char *format, ...)); 609 # else 610 _GL_CXXALIAS_SYS (fprintf, int, (FILE *fp, const char *format, ...)); 611 # endif 612 _GL_CXXALIASWARN (fprintf); 613 #endif 614 #if !0 && defined GNULIB_POSIXCHECK 615 # if !GNULIB_overrides_fprintf 616 # undef fprintf 617 # endif 618 /* Assume fprintf is always declared. */ 619 _GL_WARN_ON_USE (fprintf, "fprintf is not always POSIX compliant - " 620 "use gnulib module fprintf-posix for portable " 621 "POSIX compliance"); 622 #endif 623 624 #if 0 625 /* Discard all pending buffered I/O data on STREAM. 626 STREAM must not be wide-character oriented. 627 When discarding pending output, the file position is set back to where it 628 was before the write calls. When discarding pending input, the file 629 position is advanced to match the end of the previously read input. 630 Return 0 if successful. Upon error, return -1 and set errno. */ 631 # if 0 632 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 633 # define fpurge rpl_fpurge 634 # endif 635 _GL_FUNCDECL_RPL (fpurge, int, (FILE *gl_stream) _GL_ARG_NONNULL ((1))); 636 _GL_CXXALIAS_RPL (fpurge, int, (FILE *gl_stream)); 637 # else 638 # if !1 639 _GL_FUNCDECL_SYS (fpurge, int, (FILE *gl_stream) _GL_ARG_NONNULL ((1))); 640 # endif 641 _GL_CXXALIAS_SYS (fpurge, int, (FILE *gl_stream)); 642 # endif 643 _GL_CXXALIASWARN (fpurge); 644 #elif defined GNULIB_POSIXCHECK 645 # undef fpurge 646 # if HAVE_RAW_DECL_FPURGE 647 _GL_WARN_ON_USE (fpurge, "fpurge is not always present - " 648 "use gnulib module fpurge for portability"); 649 # endif 650 #endif 651 652 #if 1 653 # if 0 && (0 || 0) 654 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 655 # undef fputc 656 # define fputc rpl_fputc 657 # endif 658 _GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream) _GL_ARG_NONNULL ((2))); 659 _GL_CXXALIAS_RPL (fputc, int, (int c, FILE *stream)); 660 # else 661 _GL_CXXALIAS_SYS (fputc, int, (int c, FILE *stream)); 662 # endif 663 _GL_CXXALIASWARN (fputc); 664 #endif 665 666 #if 1 667 # if 0 && (0 || 0) 668 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 669 # undef fputs 670 # define fputs rpl_fputs 671 # endif 672 _GL_FUNCDECL_RPL (fputs, int, (const char *string, FILE *stream) 673 _GL_ARG_NONNULL ((1, 2))); 674 _GL_CXXALIAS_RPL (fputs, int, (const char *string, FILE *stream)); 675 # else 676 _GL_CXXALIAS_SYS (fputs, int, (const char *string, FILE *stream)); 677 # endif 678 _GL_CXXALIASWARN (fputs); 679 #endif 680 681 #if 1 682 # if 0 && 0 683 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 684 # undef fread 685 # define fread rpl_fread 686 # endif 687 _GL_FUNCDECL_RPL (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream) 688 _GL_ARG_NONNULL ((4))); 689 _GL_CXXALIAS_RPL (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream)); 690 # else 691 _GL_CXXALIAS_SYS (fread, size_t, (void *ptr, size_t s, size_t n, FILE *stream)); 692 # endif 693 _GL_CXXALIASWARN (fread); 694 #endif 695 696 #if 0 697 # if 0 698 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 699 # undef freopen 700 # define freopen rpl_freopen 701 # endif 702 _GL_FUNCDECL_RPL (freopen, FILE *, 703 (const char *filename, const char *mode, FILE *stream) 704 _GL_ARG_NONNULL ((2, 3))); 705 _GL_CXXALIAS_RPL (freopen, FILE *, 706 (const char *filename, const char *mode, FILE *stream)); 707 # else 708 _GL_CXXALIAS_SYS (freopen, FILE *, 709 (const char *filename, const char *mode, FILE *stream)); 710 # endif 711 _GL_CXXALIASWARN (freopen); 712 #elif defined GNULIB_POSIXCHECK 713 # undef freopen 714 /* Assume freopen is always declared. */ 715 _GL_WARN_ON_USE (freopen, 716 "freopen on native Windows platforms is not POSIX compliant - " 717 "use gnulib module freopen for portability"); 718 #endif 719 720 #if 1 721 # if 0 && 0 722 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 723 # undef fscanf 724 # define fscanf rpl_fscanf 725 # endif 726 _GL_FUNCDECL_RPL (fscanf, int, (FILE *stream, const char *format, ...) 727 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 3) 728 _GL_ARG_NONNULL ((1, 2))); 729 _GL_CXXALIAS_RPL (fscanf, int, (FILE *stream, const char *format, ...)); 730 # else 731 _GL_CXXALIAS_SYS (fscanf, int, (FILE *stream, const char *format, ...)); 732 # endif 733 _GL_CXXALIASWARN (fscanf); 734 #endif 735 736 737 /* Set up the following warnings, based on which modules are in use. 738 GNU Coding Standards discourage the use of fseek, since it imposes 739 an arbitrary limitation on some 32-bit hosts. Remember that the 740 fseek module depends on the fseeko module, so we only have three 741 cases to consider: 742 743 1. The developer is not using either module. Issue a warning under 744 GNULIB_POSIXCHECK for both functions, to remind them that both 745 functions have bugs on some systems. _GL_NO_LARGE_FILES has no 746 impact on this warning. 747 748 2. The developer is using both modules. They may be unaware of the 749 arbitrary limitations of fseek, so issue a warning under 750 GNULIB_POSIXCHECK. On the other hand, they may be using both 751 modules intentionally, so the developer can define 752 _GL_NO_LARGE_FILES in the compilation units where the use of fseek 753 is safe, to silence the warning. 754 755 3. The developer is using the fseeko module, but not fseek. Gnulib 756 guarantees that fseek will still work around platform bugs in that 757 case, but we presume that the developer is aware of the pitfalls of 758 fseek and was trying to avoid it, so issue a warning even when 759 GNULIB_POSIXCHECK is undefined. Again, _GL_NO_LARGE_FILES can be 760 defined to silence the warning in particular compilation units. 761 In C++ compilations with GNULIB_NAMESPACE, in order to avoid that 762 fseek gets defined as a macro, it is recommended that the developer 763 uses the fseek module, even if he is not calling the fseek function. 764 765 Most gnulib clients that perform stream operations should fall into 766 category 3. */ 767 768 #if 0 769 # if defined GNULIB_POSIXCHECK && !defined _GL_NO_LARGE_FILES 770 # define _GL_FSEEK_WARN /* Category 2, above. */ 771 # undef fseek 772 # endif 773 # if 0 774 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 775 # undef fseek 776 # define fseek rpl_fseek 777 # endif 778 _GL_FUNCDECL_RPL (fseek, int, (FILE *fp, long offset, int whence) 779 _GL_ARG_NONNULL ((1))); 780 _GL_CXXALIAS_RPL (fseek, int, (FILE *fp, long offset, int whence)); 781 # else 782 _GL_CXXALIAS_SYS (fseek, int, (FILE *fp, long offset, int whence)); 783 # endif 784 _GL_CXXALIASWARN (fseek); 785 #endif 786 787 #if 0 788 # if !0 && !defined _GL_NO_LARGE_FILES 789 # define _GL_FSEEK_WARN /* Category 3, above. */ 790 # undef fseek 791 # endif 792 # if 0 793 /* Provide an fseeko function that is aware of a preceding fflush(), and which 794 detects pipes. */ 795 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 796 # undef fseeko 797 # define fseeko rpl_fseeko 798 # endif 799 _GL_FUNCDECL_RPL (fseeko, int, (FILE *fp, off_t offset, int whence) 800 _GL_ARG_NONNULL ((1))); 801 _GL_CXXALIAS_RPL (fseeko, int, (FILE *fp, off_t offset, int whence)); 802 # else 803 # if ! 1 804 _GL_FUNCDECL_SYS (fseeko, int, (FILE *fp, off_t offset, int whence) 805 _GL_ARG_NONNULL ((1))); 806 # endif 807 _GL_CXXALIAS_SYS (fseeko, int, (FILE *fp, off_t offset, int whence)); 808 # endif 809 _GL_CXXALIASWARN (fseeko); 810 #elif defined GNULIB_POSIXCHECK 811 # define _GL_FSEEK_WARN /* Category 1, above. */ 812 # undef fseek 813 # undef fseeko 814 # if HAVE_RAW_DECL_FSEEKO 815 _GL_WARN_ON_USE (fseeko, "fseeko is unportable - " 816 "use gnulib module fseeko for portability"); 817 # endif 818 #endif 819 820 #ifdef _GL_FSEEK_WARN 821 # undef _GL_FSEEK_WARN 822 /* Here, either fseek is undefined (but C89 guarantees that it is 823 declared), or it is defined as rpl_fseek (declared above). */ 824 _GL_WARN_ON_USE (fseek, "fseek cannot handle files larger than 4 GB " 825 "on 32-bit platforms - " 826 "use fseeko function for handling of large files"); 827 #endif 828 829 830 /* ftell, ftello. See the comments on fseek/fseeko. */ 831 832 #if 0 833 # if defined GNULIB_POSIXCHECK && !defined _GL_NO_LARGE_FILES 834 # define _GL_FTELL_WARN /* Category 2, above. */ 835 # undef ftell 836 # endif 837 # if 0 838 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 839 # undef ftell 840 # define ftell rpl_ftell 841 # endif 842 _GL_FUNCDECL_RPL (ftell, long, (FILE *fp) _GL_ARG_NONNULL ((1))); 843 _GL_CXXALIAS_RPL (ftell, long, (FILE *fp)); 844 # else 845 _GL_CXXALIAS_SYS (ftell, long, (FILE *fp)); 846 # endif 847 _GL_CXXALIASWARN (ftell); 848 #endif 849 850 #if 0 851 # if !0 && !defined _GL_NO_LARGE_FILES 852 # define _GL_FTELL_WARN /* Category 3, above. */ 853 # undef ftell 854 # endif 855 # if 0 856 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 857 # undef ftello 858 # define ftello rpl_ftello 859 # endif 860 _GL_FUNCDECL_RPL (ftello, off_t, (FILE *fp) _GL_ARG_NONNULL ((1))); 861 _GL_CXXALIAS_RPL (ftello, off_t, (FILE *fp)); 862 # else 863 # if ! 1 864 _GL_FUNCDECL_SYS (ftello, off_t, (FILE *fp) _GL_ARG_NONNULL ((1))); 865 # endif 866 _GL_CXXALIAS_SYS (ftello, off_t, (FILE *fp)); 867 # endif 868 _GL_CXXALIASWARN (ftello); 869 #elif defined GNULIB_POSIXCHECK 870 # define _GL_FTELL_WARN /* Category 1, above. */ 871 # undef ftell 872 # undef ftello 873 # if HAVE_RAW_DECL_FTELLO 874 _GL_WARN_ON_USE (ftello, "ftello is unportable - " 875 "use gnulib module ftello for portability"); 876 # endif 877 #endif 878 879 #ifdef _GL_FTELL_WARN 880 # undef _GL_FTELL_WARN 881 /* Here, either ftell is undefined (but C89 guarantees that it is 882 declared), or it is defined as rpl_ftell (declared above). */ 883 _GL_WARN_ON_USE (ftell, "ftell cannot handle files larger than 4 GB " 884 "on 32-bit platforms - " 885 "use ftello function for handling of large files"); 886 #endif 887 888 889 #if 1 890 # if 0 && (0 || 0) 891 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 892 # undef fwrite 893 # define fwrite rpl_fwrite 894 # endif 895 _GL_FUNCDECL_RPL (fwrite, size_t, 896 (const void *ptr, size_t s, size_t n, FILE *stream) 897 _GL_ARG_NONNULL ((1, 4))); 898 _GL_CXXALIAS_RPL (fwrite, size_t, 899 (const void *ptr, size_t s, size_t n, FILE *stream)); 900 # else 901 _GL_CXXALIAS_SYS (fwrite, size_t, 902 (const void *ptr, size_t s, size_t n, FILE *stream)); 903 904 /* Work around bug 11959 when fortifying glibc 2.4 through 2.15 905 <http://sources.redhat.com/bugzilla/show_bug.cgi?id=11959>, 906 which sometimes causes an unwanted diagnostic for fwrite calls. 907 This affects only function declaration attributes under certain 908 versions of gcc and clang, and is not needed for C++. */ 909 # if (0 < __USE_FORTIFY_LEVEL \ 910 && __GLIBC__ == 2 && 4 <= __GLIBC_MINOR__ && __GLIBC_MINOR__ <= 15 \ 911 && 3 < __GNUC__ + (4 <= __GNUC_MINOR__) \ 912 && !defined __cplusplus) 913 # undef fwrite 914 # undef fwrite_unlocked 915 extern size_t __REDIRECT (rpl_fwrite, 916 (const void *__restrict, size_t, size_t, 917 FILE *__restrict), 918 fwrite); 919 extern size_t __REDIRECT (rpl_fwrite_unlocked, 920 (const void *__restrict, size_t, size_t, 921 FILE *__restrict), 922 fwrite_unlocked); 923 # define fwrite rpl_fwrite 924 # define fwrite_unlocked rpl_fwrite_unlocked 925 # endif 926 # endif 927 _GL_CXXALIASWARN (fwrite); 928 #endif 929 930 #if 1 931 # if 0 && 0 932 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 933 # undef getc 934 # define getc rpl_fgetc 935 # endif 936 _GL_FUNCDECL_RPL (fgetc, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 937 _GL_CXXALIAS_RPL_1 (getc, rpl_fgetc, int, (FILE *stream)); 938 # else 939 _GL_CXXALIAS_SYS (getc, int, (FILE *stream)); 940 # endif 941 _GL_CXXALIASWARN (getc); 942 #endif 943 944 #if 1 945 # if 0 && 0 946 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 947 # undef getchar 948 # define getchar rpl_getchar 949 # endif 950 _GL_FUNCDECL_RPL (getchar, int, (void)); 951 _GL_CXXALIAS_RPL (getchar, int, (void)); 952 # else 953 _GL_CXXALIAS_SYS (getchar, int, (void)); 954 # endif 955 _GL_CXXALIASWARN (getchar); 956 #endif 957 958 #if 0 959 /* Read input, up to (and including) the next occurrence of DELIMITER, from 960 STREAM, store it in *LINEPTR (and NUL-terminate it). 961 *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE 962 bytes of space. It is realloc'd as necessary. 963 Return the number of bytes read and stored at *LINEPTR (not including the 964 NUL terminator), or -1 on error or EOF. */ 965 # if 0 966 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 967 # undef getdelim 968 # define getdelim rpl_getdelim 969 # endif 970 _GL_FUNCDECL_RPL (getdelim, ssize_t, 971 (char **lineptr, size_t *linesize, int delimiter, 972 FILE *stream) 973 _GL_ARG_NONNULL ((1, 2, 4))); 974 _GL_CXXALIAS_RPL (getdelim, ssize_t, 975 (char **lineptr, size_t *linesize, int delimiter, 976 FILE *stream)); 977 # else 978 # if !1 979 _GL_FUNCDECL_SYS (getdelim, ssize_t, 980 (char **lineptr, size_t *linesize, int delimiter, 981 FILE *stream) 982 _GL_ARG_NONNULL ((1, 2, 4))); 983 # endif 984 _GL_CXXALIAS_SYS (getdelim, ssize_t, 985 (char **lineptr, size_t *linesize, int delimiter, 986 FILE *stream)); 987 # endif 988 _GL_CXXALIASWARN (getdelim); 989 #elif defined GNULIB_POSIXCHECK 990 # undef getdelim 991 # if HAVE_RAW_DECL_GETDELIM 992 _GL_WARN_ON_USE (getdelim, "getdelim is unportable - " 993 "use gnulib module getdelim for portability"); 994 # endif 995 #endif 996 997 #if 0 998 /* Read a line, up to (and including) the next newline, from STREAM, store it 999 in *LINEPTR (and NUL-terminate it). 1000 *LINEPTR is a pointer returned from malloc (or NULL), pointing to *LINESIZE 1001 bytes of space. It is realloc'd as necessary. 1002 Return the number of bytes read and stored at *LINEPTR (not including the 1003 NUL terminator), or -1 on error or EOF. */ 1004 # if 0 1005 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1006 # undef getline 1007 # define getline rpl_getline 1008 # endif 1009 _GL_FUNCDECL_RPL (getline, ssize_t, 1010 (char **lineptr, size_t *linesize, FILE *stream) 1011 _GL_ARG_NONNULL ((1, 2, 3))); 1012 _GL_CXXALIAS_RPL (getline, ssize_t, 1013 (char **lineptr, size_t *linesize, FILE *stream)); 1014 # else 1015 # if !1 1016 _GL_FUNCDECL_SYS (getline, ssize_t, 1017 (char **lineptr, size_t *linesize, FILE *stream) 1018 _GL_ARG_NONNULL ((1, 2, 3))); 1019 # endif 1020 _GL_CXXALIAS_SYS (getline, ssize_t, 1021 (char **lineptr, size_t *linesize, FILE *stream)); 1022 # endif 1023 # if 1 1024 _GL_CXXALIASWARN (getline); 1025 # endif 1026 #elif defined GNULIB_POSIXCHECK 1027 # undef getline 1028 # if HAVE_RAW_DECL_GETLINE 1029 _GL_WARN_ON_USE (getline, "getline is unportable - " 1030 "use gnulib module getline for portability"); 1031 # endif 1032 #endif 1033 1034 /* It is very rare that the developer ever has full control of stdin, 1035 so any use of gets warrants an unconditional warning; besides, C11 1036 removed it. */ 1037 #undef gets 1038 #if HAVE_RAW_DECL_GETS && !defined __cplusplus 1039 _GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead"); 1040 #endif 1041 1042 #if 0 || 0 1043 struct obstack; 1044 /* Grow an obstack with formatted output. Return the number of 1045 bytes added to OBS. No trailing nul byte is added, and the 1046 object should be closed with obstack_finish before use. Upon 1047 memory allocation error, call obstack_alloc_failed_handler. Upon 1048 other error, return -1. */ 1049 # if 0 1050 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1051 # define obstack_printf rpl_obstack_printf 1052 # endif 1053 _GL_FUNCDECL_RPL (obstack_printf, int, 1054 (struct obstack *obs, const char *format, ...) 1055 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1056 _GL_ARG_NONNULL ((1, 2))); 1057 _GL_CXXALIAS_RPL (obstack_printf, int, 1058 (struct obstack *obs, const char *format, ...)); 1059 # else 1060 # if !1 1061 _GL_FUNCDECL_SYS (obstack_printf, int, 1062 (struct obstack *obs, const char *format, ...) 1063 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1064 _GL_ARG_NONNULL ((1, 2))); 1065 # endif 1066 _GL_CXXALIAS_SYS (obstack_printf, int, 1067 (struct obstack *obs, const char *format, ...)); 1068 # endif 1069 _GL_CXXALIASWARN (obstack_printf); 1070 # if 0 1071 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1072 # define obstack_vprintf rpl_obstack_vprintf 1073 # endif 1074 _GL_FUNCDECL_RPL (obstack_vprintf, int, 1075 (struct obstack *obs, const char *format, va_list args) 1076 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1077 _GL_ARG_NONNULL ((1, 2))); 1078 _GL_CXXALIAS_RPL (obstack_vprintf, int, 1079 (struct obstack *obs, const char *format, va_list args)); 1080 # else 1081 # if !1 1082 _GL_FUNCDECL_SYS (obstack_vprintf, int, 1083 (struct obstack *obs, const char *format, va_list args) 1084 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1085 _GL_ARG_NONNULL ((1, 2))); 1086 # endif 1087 _GL_CXXALIAS_SYS (obstack_vprintf, int, 1088 (struct obstack *obs, const char *format, va_list args)); 1089 # endif 1090 _GL_CXXALIASWARN (obstack_vprintf); 1091 #endif 1092 1093 #if 0 1094 # if !1 1095 _GL_FUNCDECL_SYS (pclose, int, (FILE *stream) _GL_ARG_NONNULL ((1))); 1096 # endif 1097 _GL_CXXALIAS_SYS (pclose, int, (FILE *stream)); 1098 _GL_CXXALIASWARN (pclose); 1099 #elif defined GNULIB_POSIXCHECK 1100 # undef pclose 1101 # if HAVE_RAW_DECL_PCLOSE 1102 _GL_WARN_ON_USE (pclose, "pclose is unportable - " 1103 "use gnulib module pclose for more portability"); 1104 # endif 1105 #endif 1106 1107 #if 0 1108 /* Print a message to standard error, describing the value of ERRNO, 1109 (if STRING is not NULL and not empty) prefixed with STRING and ": ", 1110 and terminated with a newline. */ 1111 # if 0 1112 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1113 # define perror rpl_perror 1114 # endif 1115 _GL_FUNCDECL_RPL (perror, void, (const char *string)); 1116 _GL_CXXALIAS_RPL (perror, void, (const char *string)); 1117 # else 1118 _GL_CXXALIAS_SYS (perror, void, (const char *string)); 1119 # endif 1120 _GL_CXXALIASWARN (perror); 1121 #elif defined GNULIB_POSIXCHECK 1122 # undef perror 1123 /* Assume perror is always declared. */ 1124 _GL_WARN_ON_USE (perror, "perror is not always POSIX compliant - " 1125 "use gnulib module perror for portability"); 1126 #endif 1127 1128 #if 0 1129 # if 0 1130 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1131 # undef popen 1132 # define popen rpl_popen 1133 # endif 1134 _GL_FUNCDECL_RPL (popen, FILE *, (const char *cmd, const char *mode) 1135 _GL_ARG_NONNULL ((1, 2))); 1136 _GL_CXXALIAS_RPL (popen, FILE *, (const char *cmd, const char *mode)); 1137 # else 1138 # if !1 1139 _GL_FUNCDECL_SYS (popen, FILE *, (const char *cmd, const char *mode) 1140 _GL_ARG_NONNULL ((1, 2))); 1141 # endif 1142 _GL_CXXALIAS_SYS (popen, FILE *, (const char *cmd, const char *mode)); 1143 # endif 1144 _GL_CXXALIASWARN (popen); 1145 #elif defined GNULIB_POSIXCHECK 1146 # undef popen 1147 # if HAVE_RAW_DECL_POPEN 1148 _GL_WARN_ON_USE (popen, "popen is buggy on some platforms - " 1149 "use gnulib module popen or pipe for more portability"); 1150 # endif 1151 #endif 1152 1153 #if 0 || 1 1154 # if (0 && 0) \ 1155 || (1 && 0 && (0 || 0)) 1156 # if defined __GNUC__ 1157 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1158 /* Don't break __attribute__((format(printf,M,N))). */ 1159 # define printf __printf__ 1160 # endif 1161 # if 0 || 0 1162 _GL_FUNCDECL_RPL_1 (__printf__, int, 1163 (const char *format, ...) 1164 __asm__ ( 1165 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)) 1166 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 2) 1167 _GL_ARG_NONNULL ((1))); 1168 # else 1169 _GL_FUNCDECL_RPL_1 (__printf__, int, 1170 (const char *format, ...) 1171 __asm__ ( 1172 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_printf)) 1173 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 2) 1174 _GL_ARG_NONNULL ((1))); 1175 # endif 1176 _GL_CXXALIAS_RPL_1 (printf, __printf__, int, (const char *format, ...)); 1177 # else 1178 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1179 # define printf rpl_printf 1180 # endif 1181 _GL_FUNCDECL_RPL (printf, int, 1182 (const char *format, ...) 1183 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 2) 1184 _GL_ARG_NONNULL ((1))); 1185 _GL_CXXALIAS_RPL (printf, int, (const char *format, ...)); 1186 # endif 1187 # define GNULIB_overrides_printf 1 1188 # else 1189 _GL_CXXALIAS_SYS (printf, int, (const char *format, ...)); 1190 # endif 1191 _GL_CXXALIASWARN (printf); 1192 #endif 1193 #if !0 && defined GNULIB_POSIXCHECK 1194 # if !GNULIB_overrides_printf 1195 # undef printf 1196 # endif 1197 /* Assume printf is always declared. */ 1198 _GL_WARN_ON_USE (printf, "printf is not always POSIX compliant - " 1199 "use gnulib module printf-posix for portable " 1200 "POSIX compliance"); 1201 #endif 1202 1203 #if 1 1204 # if 0 && (0 || 0) 1205 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1206 # undef putc 1207 # define putc rpl_fputc 1208 # endif 1209 _GL_FUNCDECL_RPL (fputc, int, (int c, FILE *stream) _GL_ARG_NONNULL ((2))); 1210 _GL_CXXALIAS_RPL_1 (putc, rpl_fputc, int, (int c, FILE *stream)); 1211 # else 1212 _GL_CXXALIAS_SYS (putc, int, (int c, FILE *stream)); 1213 # endif 1214 _GL_CXXALIASWARN (putc); 1215 #endif 1216 1217 #if 1 1218 # if 0 && (0 || 0) 1219 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1220 # undef putchar 1221 # define putchar rpl_putchar 1222 # endif 1223 _GL_FUNCDECL_RPL (putchar, int, (int c)); 1224 _GL_CXXALIAS_RPL (putchar, int, (int c)); 1225 # else 1226 _GL_CXXALIAS_SYS (putchar, int, (int c)); 1227 # endif 1228 _GL_CXXALIASWARN (putchar); 1229 #endif 1230 1231 #if 1 1232 # if 0 && (0 || 0) 1233 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1234 # undef puts 1235 # define puts rpl_puts 1236 # endif 1237 _GL_FUNCDECL_RPL (puts, int, (const char *string) _GL_ARG_NONNULL ((1))); 1238 _GL_CXXALIAS_RPL (puts, int, (const char *string)); 1239 # else 1240 _GL_CXXALIAS_SYS (puts, int, (const char *string)); 1241 # endif 1242 _GL_CXXALIASWARN (puts); 1243 #endif 1244 1245 #if 0 1246 # if 0 1247 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1248 # undef remove 1249 # define remove rpl_remove 1250 # endif 1251 _GL_FUNCDECL_RPL (remove, int, (const char *name) _GL_ARG_NONNULL ((1))); 1252 _GL_CXXALIAS_RPL (remove, int, (const char *name)); 1253 # else 1254 _GL_CXXALIAS_SYS (remove, int, (const char *name)); 1255 # endif 1256 _GL_CXXALIASWARN (remove); 1257 #elif defined GNULIB_POSIXCHECK 1258 # undef remove 1259 /* Assume remove is always declared. */ 1260 _GL_WARN_ON_USE (remove, "remove cannot handle directories on some platforms - " 1261 "use gnulib module remove for more portability"); 1262 #endif 1263 1264 #if 0 1265 # if 0 1266 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1267 # undef rename 1268 # define rename rpl_rename 1269 # endif 1270 _GL_FUNCDECL_RPL (rename, int, 1271 (const char *old_filename, const char *new_filename) 1272 _GL_ARG_NONNULL ((1, 2))); 1273 _GL_CXXALIAS_RPL (rename, int, 1274 (const char *old_filename, const char *new_filename)); 1275 # else 1276 _GL_CXXALIAS_SYS (rename, int, 1277 (const char *old_filename, const char *new_filename)); 1278 # endif 1279 _GL_CXXALIASWARN (rename); 1280 #elif defined GNULIB_POSIXCHECK 1281 # undef rename 1282 /* Assume rename is always declared. */ 1283 _GL_WARN_ON_USE (rename, "rename is buggy on some platforms - " 1284 "use gnulib module rename for more portability"); 1285 #endif 1286 1287 #if 0 1288 # if 0 1289 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1290 # undef renameat 1291 # define renameat rpl_renameat 1292 # endif 1293 _GL_FUNCDECL_RPL (renameat, int, 1294 (int fd1, char const *file1, int fd2, char const *file2) 1295 _GL_ARG_NONNULL ((2, 4))); 1296 _GL_CXXALIAS_RPL (renameat, int, 1297 (int fd1, char const *file1, int fd2, char const *file2)); 1298 # else 1299 # if !1 1300 _GL_FUNCDECL_SYS (renameat, int, 1301 (int fd1, char const *file1, int fd2, char const *file2) 1302 _GL_ARG_NONNULL ((2, 4))); 1303 # endif 1304 _GL_CXXALIAS_SYS (renameat, int, 1305 (int fd1, char const *file1, int fd2, char const *file2)); 1306 # endif 1307 _GL_CXXALIASWARN (renameat); 1308 #elif defined GNULIB_POSIXCHECK 1309 # undef renameat 1310 # if HAVE_RAW_DECL_RENAMEAT 1311 _GL_WARN_ON_USE (renameat, "renameat is not portable - " 1312 "use gnulib module renameat for portability"); 1313 # endif 1314 #endif 1315 1316 #if 1 1317 # if 0 && 0 1318 # if defined __GNUC__ 1319 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1320 # undef scanf 1321 /* Don't break __attribute__((format(scanf,M,N))). */ 1322 # define scanf __scanf__ 1323 # endif 1324 _GL_FUNCDECL_RPL_1 (__scanf__, int, 1325 (const char *format, ...) 1326 __asm__ ( 1327 _GL_STDIO_MACROEXPAND_AND_STRINGIZE(rpl_scanf)) 1328 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2) 1329 _GL_ARG_NONNULL ((1))); 1330 _GL_CXXALIAS_RPL_1 (scanf, __scanf__, int, (const char *format, ...)); 1331 # else 1332 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1333 # undef scanf 1334 # define scanf rpl_scanf 1335 # endif 1336 _GL_FUNCDECL_RPL (scanf, int, (const char *format, ...) 1337 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 2) 1338 _GL_ARG_NONNULL ((1))); 1339 _GL_CXXALIAS_RPL (scanf, int, (const char *format, ...)); 1340 # endif 1341 # else 1342 _GL_CXXALIAS_SYS (scanf, int, (const char *format, ...)); 1343 # endif 1344 _GL_CXXALIASWARN (scanf); 1345 #endif 1346 1347 #if IN_GREP_GNULIB_TESTS 1348 # if 0 1349 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1350 # define snprintf rpl_snprintf 1351 # endif 1352 _GL_FUNCDECL_RPL (snprintf, int, 1353 (char *str, size_t size, const char *format, ...) 1354 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 4) 1355 _GL_ARG_NONNULL ((3))); 1356 _GL_CXXALIAS_RPL (snprintf, int, 1357 (char *str, size_t size, const char *format, ...)); 1358 # else 1359 # if !1 1360 _GL_FUNCDECL_SYS (snprintf, int, 1361 (char *str, size_t size, const char *format, ...) 1362 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 4) 1363 _GL_ARG_NONNULL ((3))); 1364 # endif 1365 _GL_CXXALIAS_SYS (snprintf, int, 1366 (char *str, size_t size, const char *format, ...)); 1367 # endif 1368 _GL_CXXALIASWARN (snprintf); 1369 #elif defined GNULIB_POSIXCHECK 1370 # undef snprintf 1371 # if HAVE_RAW_DECL_SNPRINTF 1372 _GL_WARN_ON_USE (snprintf, "snprintf is unportable - " 1373 "use gnulib module snprintf for portability"); 1374 # endif 1375 #endif 1376 1377 /* Some people would argue that all sprintf uses should be warned about 1378 (for example, OpenBSD issues a link warning for it), 1379 since it can cause security holes due to buffer overruns. 1380 However, we believe that sprintf can be used safely, and is more 1381 efficient than snprintf in those safe cases; and as proof of our 1382 belief, we use sprintf in several gnulib modules. So this header 1383 intentionally avoids adding a warning to sprintf except when 1384 GNULIB_POSIXCHECK is defined. */ 1385 1386 #if 0 1387 # if 0 1388 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1389 # define sprintf rpl_sprintf 1390 # endif 1391 _GL_FUNCDECL_RPL (sprintf, int, (char *str, const char *format, ...) 1392 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1393 _GL_ARG_NONNULL ((1, 2))); 1394 _GL_CXXALIAS_RPL (sprintf, int, (char *str, const char *format, ...)); 1395 # else 1396 _GL_CXXALIAS_SYS (sprintf, int, (char *str, const char *format, ...)); 1397 # endif 1398 _GL_CXXALIASWARN (sprintf); 1399 #elif defined GNULIB_POSIXCHECK 1400 # undef sprintf 1401 /* Assume sprintf is always declared. */ 1402 _GL_WARN_ON_USE (sprintf, "sprintf is not always POSIX compliant - " 1403 "use gnulib module sprintf-posix for portable " 1404 "POSIX compliance"); 1405 #endif 1406 1407 #if 0 1408 # if 0 1409 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1410 # define tmpfile rpl_tmpfile 1411 # endif 1412 _GL_FUNCDECL_RPL (tmpfile, FILE *, (void)); 1413 _GL_CXXALIAS_RPL (tmpfile, FILE *, (void)); 1414 # else 1415 _GL_CXXALIAS_SYS (tmpfile, FILE *, (void)); 1416 # endif 1417 _GL_CXXALIASWARN (tmpfile); 1418 #elif defined GNULIB_POSIXCHECK 1419 # undef tmpfile 1420 # if HAVE_RAW_DECL_TMPFILE 1421 _GL_WARN_ON_USE (tmpfile, "tmpfile is not usable on mingw - " 1422 "use gnulib module tmpfile for portability"); 1423 # endif 1424 #endif 1425 1426 #if 0 1427 /* Write formatted output to a string dynamically allocated with malloc(). 1428 If the memory allocation succeeds, store the address of the string in 1429 *RESULT and return the number of resulting bytes, excluding the trailing 1430 NUL. Upon memory allocation error, or some other error, return -1. */ 1431 # if 0 1432 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1433 # define asprintf rpl_asprintf 1434 # endif 1435 _GL_FUNCDECL_RPL (asprintf, int, 1436 (char **result, const char *format, ...) 1437 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1438 _GL_ARG_NONNULL ((1, 2))); 1439 _GL_CXXALIAS_RPL (asprintf, int, 1440 (char **result, const char *format, ...)); 1441 # else 1442 # if !1 1443 _GL_FUNCDECL_SYS (asprintf, int, 1444 (char **result, const char *format, ...) 1445 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 3) 1446 _GL_ARG_NONNULL ((1, 2))); 1447 # endif 1448 _GL_CXXALIAS_SYS (asprintf, int, 1449 (char **result, const char *format, ...)); 1450 # endif 1451 _GL_CXXALIASWARN (asprintf); 1452 # if 0 1453 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1454 # define vasprintf rpl_vasprintf 1455 # endif 1456 _GL_FUNCDECL_RPL (vasprintf, int, 1457 (char **result, const char *format, va_list args) 1458 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1459 _GL_ARG_NONNULL ((1, 2))); 1460 _GL_CXXALIAS_RPL (vasprintf, int, 1461 (char **result, const char *format, va_list args)); 1462 # else 1463 # if !1 1464 _GL_FUNCDECL_SYS (vasprintf, int, 1465 (char **result, const char *format, va_list args) 1466 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1467 _GL_ARG_NONNULL ((1, 2))); 1468 # endif 1469 _GL_CXXALIAS_SYS (vasprintf, int, 1470 (char **result, const char *format, va_list args)); 1471 # endif 1472 _GL_CXXALIASWARN (vasprintf); 1473 #endif 1474 1475 #if 0 1476 # if 0 1477 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1478 # define vdprintf rpl_vdprintf 1479 # endif 1480 _GL_FUNCDECL_RPL (vdprintf, int, (int fd, const char *format, va_list args) 1481 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1482 _GL_ARG_NONNULL ((2))); 1483 _GL_CXXALIAS_RPL (vdprintf, int, (int fd, const char *format, va_list args)); 1484 # else 1485 # if !1 1486 _GL_FUNCDECL_SYS (vdprintf, int, (int fd, const char *format, va_list args) 1487 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1488 _GL_ARG_NONNULL ((2))); 1489 # endif 1490 /* Need to cast, because on Solaris, the third parameter will likely be 1491 __va_list args. */ 1492 _GL_CXXALIAS_SYS_CAST (vdprintf, int, 1493 (int fd, const char *format, va_list args)); 1494 # endif 1495 _GL_CXXALIASWARN (vdprintf); 1496 #elif defined GNULIB_POSIXCHECK 1497 # undef vdprintf 1498 # if HAVE_RAW_DECL_VDPRINTF 1499 _GL_WARN_ON_USE (vdprintf, "vdprintf is unportable - " 1500 "use gnulib module vdprintf for portability"); 1501 # endif 1502 #endif 1503 1504 #if 0 || 1 1505 # if (0 && 0) \ 1506 || (1 && 0 && (0 || 0)) 1507 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1508 # define vfprintf rpl_vfprintf 1509 # endif 1510 # define GNULIB_overrides_vfprintf 1 1511 # if 0 1512 _GL_FUNCDECL_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args) 1513 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1514 _GL_ARG_NONNULL ((1, 2))); 1515 # else 1516 _GL_FUNCDECL_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args) 1517 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (2, 0) 1518 _GL_ARG_NONNULL ((1, 2))); 1519 # endif 1520 _GL_CXXALIAS_RPL (vfprintf, int, (FILE *fp, const char *format, va_list args)); 1521 # else 1522 /* Need to cast, because on Solaris, the third parameter is 1523 __va_list args 1524 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1525 _GL_CXXALIAS_SYS_CAST (vfprintf, int, 1526 (FILE *fp, const char *format, va_list args)); 1527 # endif 1528 _GL_CXXALIASWARN (vfprintf); 1529 #endif 1530 #if !0 && defined GNULIB_POSIXCHECK 1531 # if !GNULIB_overrides_vfprintf 1532 # undef vfprintf 1533 # endif 1534 /* Assume vfprintf is always declared. */ 1535 _GL_WARN_ON_USE (vfprintf, "vfprintf is not always POSIX compliant - " 1536 "use gnulib module vfprintf-posix for portable " 1537 "POSIX compliance"); 1538 #endif 1539 1540 #if 0 1541 # if 0 && 0 1542 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1543 # undef vfscanf 1544 # define vfscanf rpl_vfscanf 1545 # endif 1546 _GL_FUNCDECL_RPL (vfscanf, int, 1547 (FILE *stream, const char *format, va_list args) 1548 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (2, 0) 1549 _GL_ARG_NONNULL ((1, 2))); 1550 _GL_CXXALIAS_RPL (vfscanf, int, 1551 (FILE *stream, const char *format, va_list args)); 1552 # else 1553 _GL_CXXALIAS_SYS (vfscanf, int, 1554 (FILE *stream, const char *format, va_list args)); 1555 # endif 1556 _GL_CXXALIASWARN (vfscanf); 1557 #endif 1558 1559 #if 0 || 1 1560 # if (0 && 0) \ 1561 || (1 && 0 && (0 || 0)) 1562 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1563 # define vprintf rpl_vprintf 1564 # endif 1565 # define GNULIB_overrides_vprintf 1 1566 # if 0 || 0 1567 _GL_FUNCDECL_RPL (vprintf, int, (const char *format, va_list args) 1568 _GL_ATTRIBUTE_FORMAT_PRINTF (1, 0) 1569 _GL_ARG_NONNULL ((1))); 1570 # else 1571 _GL_FUNCDECL_RPL (vprintf, int, (const char *format, va_list args) 1572 _GL_ATTRIBUTE_FORMAT_PRINTF_SYSTEM (1, 0) 1573 _GL_ARG_NONNULL ((1))); 1574 # endif 1575 _GL_CXXALIAS_RPL (vprintf, int, (const char *format, va_list args)); 1576 # else 1577 /* Need to cast, because on Solaris, the second parameter is 1578 __va_list args 1579 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1580 _GL_CXXALIAS_SYS_CAST (vprintf, int, (const char *format, va_list args)); 1581 # endif 1582 _GL_CXXALIASWARN (vprintf); 1583 #endif 1584 #if !0 && defined GNULIB_POSIXCHECK 1585 # if !GNULIB_overrides_vprintf 1586 # undef vprintf 1587 # endif 1588 /* Assume vprintf is always declared. */ 1589 _GL_WARN_ON_USE (vprintf, "vprintf is not always POSIX compliant - " 1590 "use gnulib module vprintf-posix for portable " 1591 "POSIX compliance"); 1592 #endif 1593 1594 #if 0 1595 # if 0 && 0 1596 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1597 # undef vscanf 1598 # define vscanf rpl_vscanf 1599 # endif 1600 _GL_FUNCDECL_RPL (vscanf, int, (const char *format, va_list args) 1601 _GL_ATTRIBUTE_FORMAT_SCANF_SYSTEM (1, 0) 1602 _GL_ARG_NONNULL ((1))); 1603 _GL_CXXALIAS_RPL (vscanf, int, (const char *format, va_list args)); 1604 # else 1605 _GL_CXXALIAS_SYS (vscanf, int, (const char *format, va_list args)); 1606 # endif 1607 _GL_CXXALIASWARN (vscanf); 1608 #endif 1609 1610 #if 0 1611 # if 0 1612 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1613 # define vsnprintf rpl_vsnprintf 1614 # endif 1615 _GL_FUNCDECL_RPL (vsnprintf, int, 1616 (char *str, size_t size, const char *format, va_list args) 1617 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 0) 1618 _GL_ARG_NONNULL ((3))); 1619 _GL_CXXALIAS_RPL (vsnprintf, int, 1620 (char *str, size_t size, const char *format, va_list args)); 1621 # else 1622 # if !1 1623 _GL_FUNCDECL_SYS (vsnprintf, int, 1624 (char *str, size_t size, const char *format, va_list args) 1625 _GL_ATTRIBUTE_FORMAT_PRINTF (3, 0) 1626 _GL_ARG_NONNULL ((3))); 1627 # endif 1628 _GL_CXXALIAS_SYS (vsnprintf, int, 1629 (char *str, size_t size, const char *format, va_list args)); 1630 # endif 1631 _GL_CXXALIASWARN (vsnprintf); 1632 #elif defined GNULIB_POSIXCHECK 1633 # undef vsnprintf 1634 # if HAVE_RAW_DECL_VSNPRINTF 1635 _GL_WARN_ON_USE (vsnprintf, "vsnprintf is unportable - " 1636 "use gnulib module vsnprintf for portability"); 1637 # endif 1638 #endif 1639 1640 #if 0 1641 # if 0 1642 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1643 # define vsprintf rpl_vsprintf 1644 # endif 1645 _GL_FUNCDECL_RPL (vsprintf, int, 1646 (char *str, const char *format, va_list args) 1647 _GL_ATTRIBUTE_FORMAT_PRINTF (2, 0) 1648 _GL_ARG_NONNULL ((1, 2))); 1649 _GL_CXXALIAS_RPL (vsprintf, int, 1650 (char *str, const char *format, va_list args)); 1651 # else 1652 /* Need to cast, because on Solaris, the third parameter is 1653 __va_list args 1654 and GCC's fixincludes did not change this to __gnuc_va_list. */ 1655 _GL_CXXALIAS_SYS_CAST (vsprintf, int, 1656 (char *str, const char *format, va_list args)); 1657 # endif 1658 _GL_CXXALIASWARN (vsprintf); 1659 #elif defined GNULIB_POSIXCHECK 1660 # undef vsprintf 1661 /* Assume vsprintf is always declared. */ 1662 _GL_WARN_ON_USE (vsprintf, "vsprintf is not always POSIX compliant - " 1663 "use gnulib module vsprintf-posix for portable " 1664 "POSIX compliance"); 1665 #endif 1666 1667 #endif /* _GL_STDIO_H */ 1668 #endif /* _GL_STDIO_H */ 1669 #endif 1670