1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2/* Like <fcntl.h>, but with non-working flags defined to 0. 3 4 Copyright (C) 2006-2012 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 of the License, or 9 (at your option) 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/* written by Paul Eggert */ 20 21#if __GNUC__ >= 3 22#pragma GCC system_header 23#endif 24 25 26#if defined __need_system_fcntl_h 27/* Special invocation convention. */ 28 29/* Needed before <sys/stat.h>. 30 May also define off_t to a 64-bit type on native Windows. */ 31#include <sys/types.h> 32/* On some systems other than glibc, <sys/stat.h> is a prerequisite of 33 <fcntl.h>. On glibc systems, we would like to avoid namespace pollution. 34 But on glibc systems, <fcntl.h> includes <sys/stat.h> inside an 35 extern "C" { ... } block, which leads to errors in C++ mode with the 36 overridden <sys/stat.h> from gnulib. These errors are known to be gone 37 with g++ version >= 4.3. */ 38#if !(defined __GLIBC__ || defined __UCLIBC__) || (defined __cplusplus && defined GNULIB_NAMESPACE && !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) 39# include <sys/stat.h> 40#endif 41#include_next <fcntl.h> 42 43#else 44/* Normal invocation convention. */ 45 46#ifndef _GL_FCNTL_H 47 48/* Needed before <sys/stat.h>. 49 May also define off_t to a 64-bit type on native Windows. */ 50#include <sys/types.h> 51/* On some systems other than glibc, <sys/stat.h> is a prerequisite of 52 <fcntl.h>. On glibc systems, we would like to avoid namespace pollution. 53 But on glibc systems, <fcntl.h> includes <sys/stat.h> inside an 54 extern "C" { ... } block, which leads to errors in C++ mode with the 55 overridden <sys/stat.h> from gnulib. These errors are known to be gone 56 with g++ version >= 4.3. */ 57#if !(defined __GLIBC__ || defined __UCLIBC__) || (defined __cplusplus && defined GNULIB_NAMESPACE && !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) 58# include <sys/stat.h> 59#endif 60/* The include_next requires a split double-inclusion guard. */ 61#include_next <fcntl.h> 62 63#ifndef _GL_FCNTL_H 64#define _GL_FCNTL_H 65 66#ifndef __GLIBC__ /* Avoid namespace pollution on glibc systems. */ 67# include <unistd.h> 68#endif 69 70/* Native Windows platforms declare open(), creat() in <io.h>. */ 71#if (1 || defined GNULIB_POSIXCHECK) \ 72 && ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__) 73# include <io.h> 74#endif 75 76 77/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 78#ifndef _GL_CXXDEFS_H 79#define _GL_CXXDEFS_H 80 81/* The three most frequent use cases of these macros are: 82 83 * For providing a substitute for a function that is missing on some 84 platforms, but is declared and works fine on the platforms on which 85 it exists: 86 87 #if @GNULIB_FOO@ 88 # if !@HAVE_FOO@ 89 _GL_FUNCDECL_SYS (foo, ...); 90 # endif 91 _GL_CXXALIAS_SYS (foo, ...); 92 _GL_CXXALIASWARN (foo); 93 #elif defined GNULIB_POSIXCHECK 94 ... 95 #endif 96 97 * For providing a replacement for a function that exists on all platforms, 98 but is broken/insufficient and needs to be replaced on some platforms: 99 100 #if @GNULIB_FOO@ 101 # if @REPLACE_FOO@ 102 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 103 # undef foo 104 # define foo rpl_foo 105 # endif 106 _GL_FUNCDECL_RPL (foo, ...); 107 _GL_CXXALIAS_RPL (foo, ...); 108 # else 109 _GL_CXXALIAS_SYS (foo, ...); 110 # endif 111 _GL_CXXALIASWARN (foo); 112 #elif defined GNULIB_POSIXCHECK 113 ... 114 #endif 115 116 * For providing a replacement for a function that exists on some platforms 117 but is broken/insufficient and needs to be replaced on some of them and 118 is additionally either missing or undeclared on some other platforms: 119 120 #if @GNULIB_FOO@ 121 # if @REPLACE_FOO@ 122 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 123 # undef foo 124 # define foo rpl_foo 125 # endif 126 _GL_FUNCDECL_RPL (foo, ...); 127 _GL_CXXALIAS_RPL (foo, ...); 128 # else 129 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 130 _GL_FUNCDECL_SYS (foo, ...); 131 # endif 132 _GL_CXXALIAS_SYS (foo, ...); 133 # endif 134 _GL_CXXALIASWARN (foo); 135 #elif defined GNULIB_POSIXCHECK 136 ... 137 #endif 138*/ 139 140/* _GL_EXTERN_C declaration; 141 performs the declaration with C linkage. */ 142#if defined __cplusplus 143# define _GL_EXTERN_C extern "C" 144#else 145# define _GL_EXTERN_C extern 146#endif 147 148/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 149 declares a replacement function, named rpl_func, with the given prototype, 150 consisting of return type, parameters, and attributes. 151 Example: 152 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 153 _GL_ARG_NONNULL ((1))); 154 */ 155#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 156 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 157#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 158 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 159 160/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 161 declares the system function, named func, with the given prototype, 162 consisting of return type, parameters, and attributes. 163 Example: 164 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 165 _GL_ARG_NONNULL ((1))); 166 */ 167#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 168 _GL_EXTERN_C rettype func parameters_and_attributes 169 170/* _GL_CXXALIAS_RPL (func, rettype, parameters); 171 declares a C++ alias called GNULIB_NAMESPACE::func 172 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 173 Example: 174 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 175 */ 176#define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 177 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 178#if defined __cplusplus && defined GNULIB_NAMESPACE 179# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 180 namespace GNULIB_NAMESPACE \ 181 { \ 182 rettype (*const func) parameters = ::rpl_func; \ 183 } \ 184 _GL_EXTERN_C int _gl_cxxalias_dummy 185#else 186# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 187 _GL_EXTERN_C int _gl_cxxalias_dummy 188#endif 189 190/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 191 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 192 except that the C function rpl_func may have a slightly different 193 declaration. A cast is used to silence the "invalid conversion" error 194 that would otherwise occur. */ 195#if defined __cplusplus && defined GNULIB_NAMESPACE 196# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 197 namespace GNULIB_NAMESPACE \ 198 { \ 199 rettype (*const func) parameters = \ 200 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 201 } \ 202 _GL_EXTERN_C int _gl_cxxalias_dummy 203#else 204# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 205 _GL_EXTERN_C int _gl_cxxalias_dummy 206#endif 207 208/* _GL_CXXALIAS_SYS (func, rettype, parameters); 209 declares a C++ alias called GNULIB_NAMESPACE::func 210 that redirects to the system provided function func, if GNULIB_NAMESPACE 211 is defined. 212 Example: 213 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 214 */ 215#if defined __cplusplus && defined GNULIB_NAMESPACE 216 /* If we were to write 217 rettype (*const func) parameters = ::func; 218 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 219 better (remove an indirection through a 'static' pointer variable), 220 but then the _GL_CXXALIASWARN macro below would cause a warning not only 221 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 222# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 223 namespace GNULIB_NAMESPACE \ 224 { \ 225 static rettype (*func) parameters = ::func; \ 226 } \ 227 _GL_EXTERN_C int _gl_cxxalias_dummy 228#else 229# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 230 _GL_EXTERN_C int _gl_cxxalias_dummy 231#endif 232 233/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 234 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 235 except that the C function func may have a slightly different declaration. 236 A cast is used to silence the "invalid conversion" error that would 237 otherwise occur. */ 238#if defined __cplusplus && defined GNULIB_NAMESPACE 239# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 240 namespace GNULIB_NAMESPACE \ 241 { \ 242 static rettype (*func) parameters = \ 243 reinterpret_cast<rettype(*)parameters>(::func); \ 244 } \ 245 _GL_EXTERN_C int _gl_cxxalias_dummy 246#else 247# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 248 _GL_EXTERN_C int _gl_cxxalias_dummy 249#endif 250 251/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 252 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 253 except that the C function is picked among a set of overloaded functions, 254 namely the one with rettype2 and parameters2. Two consecutive casts 255 are used to silence the "cannot find a match" and "invalid conversion" 256 errors that would otherwise occur. */ 257#if defined __cplusplus && defined GNULIB_NAMESPACE 258 /* The outer cast must be a reinterpret_cast. 259 The inner cast: When the function is defined as a set of overloaded 260 functions, it works as a static_cast<>, choosing the designated variant. 261 When the function is defined as a single variant, it works as a 262 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 263# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 264 namespace GNULIB_NAMESPACE \ 265 { \ 266 static rettype (*func) parameters = \ 267 reinterpret_cast<rettype(*)parameters>( \ 268 (rettype2(*)parameters2)(::func)); \ 269 } \ 270 _GL_EXTERN_C int _gl_cxxalias_dummy 271#else 272# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 273 _GL_EXTERN_C int _gl_cxxalias_dummy 274#endif 275 276/* _GL_CXXALIASWARN (func); 277 causes a warning to be emitted when ::func is used but not when 278 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 279 variants. */ 280#if defined __cplusplus && defined GNULIB_NAMESPACE 281# define _GL_CXXALIASWARN(func) \ 282 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 283# define _GL_CXXALIASWARN_1(func,namespace) \ 284 _GL_CXXALIASWARN_2 (func, namespace) 285/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 286 we enable the warning only when not optimizing. */ 287# if !__OPTIMIZE__ 288# define _GL_CXXALIASWARN_2(func,namespace) \ 289 _GL_WARN_ON_USE (func, \ 290 "The symbol ::" #func " refers to the system function. " \ 291 "Use " #namespace "::" #func " instead.") 292# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 293# define _GL_CXXALIASWARN_2(func,namespace) \ 294 extern __typeof__ (func) func 295# else 296# define _GL_CXXALIASWARN_2(func,namespace) \ 297 _GL_EXTERN_C int _gl_cxxalias_dummy 298# endif 299#else 300# define _GL_CXXALIASWARN(func) \ 301 _GL_EXTERN_C int _gl_cxxalias_dummy 302#endif 303 304/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 305 causes a warning to be emitted when the given overloaded variant of ::func 306 is used but not when GNULIB_NAMESPACE::func is used. */ 307#if defined __cplusplus && defined GNULIB_NAMESPACE 308# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 309 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 310 GNULIB_NAMESPACE) 311# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 312 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 313/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 314 we enable the warning only when not optimizing. */ 315# if !__OPTIMIZE__ 316# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 317 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 318 "The symbol ::" #func " refers to the system function. " \ 319 "Use " #namespace "::" #func " instead.") 320# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 321# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 322 extern __typeof__ (func) func 323# else 324# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 325 _GL_EXTERN_C int _gl_cxxalias_dummy 326# endif 327#else 328# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 329 _GL_EXTERN_C int _gl_cxxalias_dummy 330#endif 331 332#endif /* _GL_CXXDEFS_H */ 333 334/* The definition of _GL_ARG_NONNULL is copied here. */ 335/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 336 that the values passed as arguments n, ..., m must be non-NULL pointers. 337 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 338#ifndef _GL_ARG_NONNULL 339# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 340# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 341# else 342# define _GL_ARG_NONNULL(params) 343# endif 344#endif 345 346/* The definition of _GL_WARN_ON_USE is copied here. */ 347#ifndef _GL_WARN_ON_USE 348 349# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 350/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 351# define _GL_WARN_ON_USE(function, message) \ 352extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 353# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 354/* Verify the existence of the function. */ 355# define _GL_WARN_ON_USE(function, message) \ 356extern __typeof__ (function) function 357# else /* Unsupported. */ 358# define _GL_WARN_ON_USE(function, message) \ 359_GL_WARN_EXTERN_C int _gl_warn_on_use 360# endif 361#endif 362 363/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 364 is like _GL_WARN_ON_USE (function, "string"), except that the function is 365 declared with the given prototype, consisting of return type, parameters, 366 and attributes. 367 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 368 not work in this case. */ 369#ifndef _GL_WARN_ON_USE_CXX 370# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 371# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 372extern rettype function parameters_and_attributes \ 373 __attribute__ ((__warning__ (msg))) 374# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 375/* Verify the existence of the function. */ 376# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 377extern rettype function parameters_and_attributes 378# else /* Unsupported. */ 379# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 380_GL_WARN_EXTERN_C int _gl_warn_on_use 381# endif 382#endif 383 384/* _GL_WARN_EXTERN_C declaration; 385 performs the declaration with C linkage. */ 386#ifndef _GL_WARN_EXTERN_C 387# if defined __cplusplus 388# define _GL_WARN_EXTERN_C extern "C" 389# else 390# define _GL_WARN_EXTERN_C extern 391# endif 392#endif 393 394 395/* Declare overridden functions. */ 396 397#if 1 398# if 1 399# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 400# undef fcntl 401# define fcntl rpl_fcntl 402# endif 403_GL_FUNCDECL_RPL (fcntl, int, (int fd, int action, ...)); 404_GL_CXXALIAS_RPL (fcntl, int, (int fd, int action, ...)); 405# else 406# if !1 407_GL_FUNCDECL_SYS (fcntl, int, (int fd, int action, ...)); 408# endif 409_GL_CXXALIAS_SYS (fcntl, int, (int fd, int action, ...)); 410# endif 411_GL_CXXALIASWARN (fcntl); 412#elif defined GNULIB_POSIXCHECK 413# undef fcntl 414# if HAVE_RAW_DECL_FCNTL 415_GL_WARN_ON_USE (fcntl, "fcntl is not always POSIX compliant - " 416 "use gnulib module fcntl for portability"); 417# endif 418#endif 419 420#if 1 421# if 0 422# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 423# undef open 424# define open rpl_open 425# endif 426_GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 427 _GL_ARG_NONNULL ((1))); 428_GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 429# else 430_GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 431# endif 432/* On HP-UX 11, in C++ mode, open() is defined as an inline function with a 433 default argument. _GL_CXXALIASWARN does not work in this case. */ 434# if !defined __hpux 435_GL_CXXALIASWARN (open); 436# endif 437#elif defined GNULIB_POSIXCHECK 438# undef open 439/* Assume open is always declared. */ 440_GL_WARN_ON_USE (open, "open is not always POSIX compliant - " 441 "use gnulib module open for portability"); 442#endif 443 444#if 0 445# if 0 446# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 447# undef openat 448# define openat rpl_openat 449# endif 450_GL_FUNCDECL_RPL (openat, int, 451 (int fd, char const *file, int flags, /* mode_t mode */ ...) 452 _GL_ARG_NONNULL ((2))); 453_GL_CXXALIAS_RPL (openat, int, 454 (int fd, char const *file, int flags, /* mode_t mode */ ...)); 455# else 456# if !1 457_GL_FUNCDECL_SYS (openat, int, 458 (int fd, char const *file, int flags, /* mode_t mode */ ...) 459 _GL_ARG_NONNULL ((2))); 460# endif 461_GL_CXXALIAS_SYS (openat, int, 462 (int fd, char const *file, int flags, /* mode_t mode */ ...)); 463# endif 464_GL_CXXALIASWARN (openat); 465#elif defined GNULIB_POSIXCHECK 466# undef openat 467# if HAVE_RAW_DECL_OPENAT 468_GL_WARN_ON_USE (openat, "openat is not portable - " 469 "use gnulib module openat for portability"); 470# endif 471#endif 472 473 474/* Fix up the FD_* macros, only known to be missing on mingw. */ 475 476#ifndef FD_CLOEXEC 477# define FD_CLOEXEC 1 478#endif 479 480/* Fix up the supported F_* macros. Intentionally leave other F_* 481 macros undefined. Only known to be missing on mingw. */ 482 483#ifndef F_DUPFD_CLOEXEC 484# define F_DUPFD_CLOEXEC 0x40000000 485/* Witness variable: 1 if gnulib defined F_DUPFD_CLOEXEC, 0 otherwise. */ 486# define GNULIB_defined_F_DUPFD_CLOEXEC 1 487#else 488# define GNULIB_defined_F_DUPFD_CLOEXEC 0 489#endif 490 491#ifndef F_DUPFD 492# define F_DUPFD 1 493#endif 494 495#ifndef F_GETFD 496# define F_GETFD 2 497#endif 498 499/* Fix up the O_* macros. */ 500 501#if !defined O_DIRECT && defined O_DIRECTIO 502/* Tru64 spells it 'O_DIRECTIO'. */ 503# define O_DIRECT O_DIRECTIO 504#endif 505 506#if !defined O_CLOEXEC && defined O_NOINHERIT 507/* Mingw spells it 'O_NOINHERIT'. */ 508# define O_CLOEXEC O_NOINHERIT 509#endif 510 511#ifndef O_CLOEXEC 512# define O_CLOEXEC 0 513#endif 514 515#ifndef O_DIRECT 516# define O_DIRECT 0 517#endif 518 519#ifndef O_DIRECTORY 520# define O_DIRECTORY 0 521#endif 522 523#ifndef O_DSYNC 524# define O_DSYNC 0 525#endif 526 527#ifndef O_EXEC 528# define O_EXEC O_RDONLY /* This is often close enough in older systems. */ 529#endif 530 531#ifndef O_IGNORE_CTTY 532# define O_IGNORE_CTTY 0 533#endif 534 535#ifndef O_NDELAY 536# define O_NDELAY 0 537#endif 538 539#ifndef O_NOATIME 540# define O_NOATIME 0 541#endif 542 543#ifndef O_NONBLOCK 544# define O_NONBLOCK O_NDELAY 545#endif 546 547/* If the gnulib module 'nonblocking' is in use, guarantee a working non-zero 548 value of O_NONBLOCK. Otherwise, O_NONBLOCK is defined (above) to O_NDELAY 549 or to 0 as fallback. */ 550#if 0 551# if O_NONBLOCK 552# define GNULIB_defined_O_NONBLOCK 0 553# else 554# define GNULIB_defined_O_NONBLOCK 1 555# undef O_NONBLOCK 556# define O_NONBLOCK 0x40000000 557# endif 558#endif 559 560#ifndef O_NOCTTY 561# define O_NOCTTY 0 562#endif 563 564#ifndef O_NOFOLLOW 565# define O_NOFOLLOW 0 566#endif 567 568#ifndef O_NOLINK 569# define O_NOLINK 0 570#endif 571 572#ifndef O_NOLINKS 573# define O_NOLINKS 0 574#endif 575 576#ifndef O_NOTRANS 577# define O_NOTRANS 0 578#endif 579 580#ifndef O_RSYNC 581# define O_RSYNC 0 582#endif 583 584#ifndef O_SEARCH 585# define O_SEARCH O_RDONLY /* This is often close enough in older systems. */ 586#endif 587 588#ifndef O_SYNC 589# define O_SYNC 0 590#endif 591 592#ifndef O_TTY_INIT 593# define O_TTY_INIT 0 594#endif 595 596#if ~O_ACCMODE & (O_RDONLY | O_WRONLY | O_RDWR | O_EXEC | O_SEARCH) 597# undef O_ACCMODE 598# define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR | O_EXEC | O_SEARCH) 599#endif 600 601/* For systems that distinguish between text and binary I/O. 602 O_BINARY is usually declared in fcntl.h */ 603#if !defined O_BINARY && defined _O_BINARY 604 /* For MSC-compatible compilers. */ 605# define O_BINARY _O_BINARY 606# define O_TEXT _O_TEXT 607#endif 608 609#if defined __BEOS__ || defined __HAIKU__ 610 /* BeOS 5 and Haiku have O_BINARY and O_TEXT, but they have no effect. */ 611# undef O_BINARY 612# undef O_TEXT 613#endif 614 615#ifndef O_BINARY 616# define O_BINARY 0 617# define O_TEXT 0 618#endif 619 620/* Fix up the AT_* macros. */ 621 622/* Work around a bug in Solaris 9 and 10: AT_FDCWD is positive. Its 623 value exceeds INT_MAX, so its use as an int doesn't conform to the 624 C standard, and GCC and Sun C complain in some cases. If the bug 625 is present, undef AT_FDCWD here, so it can be redefined below. */ 626#if 0 < AT_FDCWD && AT_FDCWD == 0xffd19553 627# undef AT_FDCWD 628#endif 629 630/* Use the same bit pattern as Solaris 9, but with the proper 631 signedness. The bit pattern is important, in case this actually is 632 Solaris with the above workaround. */ 633#ifndef AT_FDCWD 634# define AT_FDCWD (-3041965) 635#endif 636 637/* Use the same values as Solaris 9. This shouldn't matter, but 638 there's no real reason to differ. */ 639#ifndef AT_SYMLINK_NOFOLLOW 640# define AT_SYMLINK_NOFOLLOW 4096 641#endif 642 643#ifndef AT_REMOVEDIR 644# define AT_REMOVEDIR 1 645#endif 646 647/* Solaris 9 lacks these two, so just pick unique values. */ 648#ifndef AT_SYMLINK_FOLLOW 649# define AT_SYMLINK_FOLLOW 2 650#endif 651 652#ifndef AT_EACCESS 653# define AT_EACCESS 4 654#endif 655 656 657#endif /* _GL_FCNTL_H */ 658#endif /* _GL_FCNTL_H */ 659#endif 660