gitweb.dragonflybsd.org Git - dragonfly.git/blob - gnu/usr.bin/diff/libdiffutils/fcntl.h

1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */

2 /* Like <fcntl.h>, but with non-working flags defined to 0.

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.

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.

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/>. */

19 /* written by Paul Eggert */

21 #if __GNUC__ >= 3

22 #pragma GCC system_header

23 #endif

26 #if defined __need_system_fcntl_h

27 /* Special invocation convention. */

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>

43 #else

44 /* Normal invocation convention. */

46 #ifndef _GL_FCNTL_H

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>

63 #ifndef _GL_FCNTL_H

64 #define _GL_FCNTL_H

66 #ifndef __GLIBC__ /* Avoid namespace pollution on glibc systems. */

67 # include <unistd.h>

68 #endif

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

77 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */

78 #ifndef _GL_CXXDEFS_H

79 #define _GL_CXXDEFS_H

81 /* The three most frequent use cases of these macros are:

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:

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

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:

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) \

352 extern __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) \

356 extern __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) \

372 extern 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) \

377 extern 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