/* DO NOT EDIT! GENERATED AUTOMATICALLY! */

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

Copyright (C) 2006-2018 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>. */

/* written by Paul Eggert */

#if __GNUC__ >= 3

#pragma GCC system_header

#endif

#if defined __need_system_fcntl_h

/* Special invocation convention. */

/* Needed before <sys/stat.h>.

May also define off_t to a 64-bit type on native Windows. */

#include <sys/types.h>

/* On some systems other than glibc, <sys/stat.h> is a prerequisite of

<fcntl.h>. On glibc systems, we would like to avoid namespace pollution.

But on glibc systems, <fcntl.h> includes <sys/stat.h> inside an

extern "C" { ... } block, which leads to errors in C mode with the

overridden <sys/stat.h> from gnulib. These errors are known to be gone

with g version >= 4.3. */

#if !(defined __GLIBC__ || defined __UCLIBC__) || (defined __cplusplus && defined GNULIB_NAMESPACE && (defined __ICC || !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))))

# include <sys/stat.h>

#endif

#include_next <fcntl.h>

#else

/* Normal invocation convention. */

#ifndef _GL_FCNTL_H

/* Needed before <sys/stat.h>.

May also define off_t to a 64-bit type on native Windows. */

#include <sys/types.h>

/* On some systems other than glibc, <sys/stat.h> is a prerequisite of

<fcntl.h>. On glibc systems, we would like to avoid namespace pollution.

But on glibc systems, <fcntl.h> includes <sys/stat.h> inside an

extern "C" { ... } block, which leads to errors in C mode with the

overridden <sys/stat.h> from gnulib. These errors are known to be gone

with g version >= 4.3. */

#if !(defined __GLIBC__ || defined __UCLIBC__) || (defined __cplusplus && defined GNULIB_NAMESPACE && (defined __ICC || !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))))

# include <sys/stat.h>

#endif

/* The include_next requires a split double-inclusion guard. */

#include_next <fcntl.h>

#ifndef _GL_FCNTL_H

#define _GL_FCNTL_H

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

# include <unistd.h>

#endif

/* Native Windows platforms declare open(), creat() in <io.h>. */

#if (0 || defined GNULIB_POSIXCHECK) \

&& (defined _WIN32 && ! defined __CYGWIN__)

# include <io.h>

#endif

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

/* C compatible function declaration macros.

Copyright (C) 2010-2018 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify it

under the terms of the GNU General Public License as published

by the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>. */

#ifndef _GL_CXXDEFS_H

#define _GL_CXXDEFS_H

/* Begin/end the GNULIB_NAMESPACE namespace. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_BEGIN_NAMESPACE namespace GNULIB_NAMESPACE {

# define _GL_END_NAMESPACE }

#else

# define _GL_BEGIN_NAMESPACE

# define _GL_END_NAMESPACE

#endif

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

* For providing a substitute for a function that is missing on some

platforms, but is declared and works fine on the platforms on which

it exists:

#if @GNULIB_FOO@

# if !@HAVE_FOO@

_GL_FUNCDECL_SYS (foo, ...);

# endif

_GL_CXXALIAS_SYS (foo, ...);

_GL_CXXALIASWARN (foo);

#elif defined GNULIB_POSIXCHECK

...

#endif

* For providing a replacement for a function that exists on all platforms,

but is broken/insufficient and needs to be replaced on some platforms:

#if @GNULIB_FOO@

# if @REPLACE_FOO@

# if !(defined __cplusplus && defined GNULIB_NAMESPACE)

# undef foo

# define foo rpl_foo

# endif

_GL_FUNCDECL_RPL (foo, ...);

_GL_CXXALIAS_RPL (foo, ...);

# else

_GL_CXXALIAS_SYS (foo, ...);

# endif

_GL_CXXALIASWARN (foo);

#elif defined GNULIB_POSIXCHECK

...

#endif

* For providing a replacement for a function that exists on some platforms

but is broken/insufficient and needs to be replaced on some of them and

is additionally either missing or undeclared on some other platforms:

#if @GNULIB_FOO@

# if @REPLACE_FOO@

# if !(defined __cplusplus && defined GNULIB_NAMESPACE)

# undef foo

# define foo rpl_foo

# endif

_GL_FUNCDECL_RPL (foo, ...);

_GL_CXXALIAS_RPL (foo, ...);

# else

# if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@

_GL_FUNCDECL_SYS (foo, ...);

# endif

_GL_CXXALIAS_SYS (foo, ...);

# endif

_GL_CXXALIASWARN (foo);

#elif defined GNULIB_POSIXCHECK

...

#endif

*/

/* _GL_EXTERN_C declaration;

performs the declaration with C linkage. */

#if defined __cplusplus

# define _GL_EXTERN_C extern "C"

#else

# define _GL_EXTERN_C extern

#endif

/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);

declares a replacement function, named rpl_func, with the given prototype,

consisting of return type, parameters, and attributes.

Example:

_GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)

_GL_ARG_NONNULL ((1)));

*/

#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \

_GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)

#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \

_GL_EXTERN_C rettype rpl_func parameters_and_attributes

/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);

declares the system function, named func, with the given prototype,

consisting of return type, parameters, and attributes.

Example:

_GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)

_GL_ARG_NONNULL ((1)));

*/

#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \

_GL_EXTERN_C rettype func parameters_and_attributes

/* _GL_CXXALIAS_RPL (func, rettype, parameters);

declares a C alias called GNULIB_NAMESPACE::func

that redirects to rpl_func, if GNULIB_NAMESPACE is defined.

Example:

_GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));

Wrapping rpl_func in an object with an inline conversion operator

avoids a reference to rpl_func unless GNULIB_NAMESPACE::func is

actually used in the program. */

#define _GL_CXXALIAS_RPL(func,rettype,parameters) \

_GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

namespace GNULIB_NAMESPACE \

{ \

static const struct _gl_ ## func ## _wrapper \

{ \

typedef rettype (*type) parameters; \

\

inline operator type () const \

{ \

return ::rpl_func; \

} \

} func = {}; \

} \

_GL_EXTERN_C int _gl_cxxalias_dummy

#else

# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);

is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);

except that the C function rpl_func may have a slightly different

declaration. A cast is used to silence the "invalid conversion" error

that would otherwise occur. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

namespace GNULIB_NAMESPACE \

{ \

static const struct _gl_ ## func ## _wrapper \

{ \

typedef rettype (*type) parameters; \

\

inline operator type () const \

{ \

return reinterpret_cast<type>(::rpl_func); \

} \

} func = {}; \

} \

_GL_EXTERN_C int _gl_cxxalias_dummy

#else

# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIAS_SYS (func, rettype, parameters);

declares a C alias called GNULIB_NAMESPACE::func

that redirects to the system provided function func, if GNULIB_NAMESPACE

is defined.

Example:

_GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));

Wrapping func in an object with an inline conversion operator

avoids a reference to func unless GNULIB_NAMESPACE::func is

actually used in the program. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIAS_SYS(func,rettype,parameters) \

namespace GNULIB_NAMESPACE \

{ \

static const struct _gl_ ## func ## _wrapper \

{ \

typedef rettype (*type) parameters; \

\

inline operator type () const \

{ \

return ::func; \

} \

} func = {}; \

} \

_GL_EXTERN_C int _gl_cxxalias_dummy

#else

# define _GL_CXXALIAS_SYS(func,rettype,parameters) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);

is like _GL_CXXALIAS_SYS (func, rettype, parameters);

except that the C function func may have a slightly different declaration.

A cast is used to silence the "invalid conversion" error that would

otherwise occur. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

namespace GNULIB_NAMESPACE \

{ \

static const struct _gl_ ## func ## _wrapper \

{ \

typedef rettype (*type) parameters; \

\

inline operator type () const \

{ \

return reinterpret_cast<type>(::func); \

} \

} func = {}; \

} \

_GL_EXTERN_C int _gl_cxxalias_dummy

#else

# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);

is like _GL_CXXALIAS_SYS (func, rettype, parameters);

except that the C function is picked among a set of overloaded functions,

namely the one with rettype2 and parameters2. Two consecutive casts

are used to silence the "cannot find a match" and "invalid conversion"

errors that would otherwise occur. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

/* The outer cast must be a reinterpret_cast.

The inner cast: When the function is defined as a set of overloaded

functions, it works as a static_cast<>, choosing the designated variant.

When the function is defined as a single variant, it works as a

reinterpret_cast<>. The parenthesized cast syntax works both ways. */

# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

namespace GNULIB_NAMESPACE \

{ \

static const struct _gl_ ## func ## _wrapper \

{ \

typedef rettype (*type) parameters; \

\

inline operator type () const \

{ \

return reinterpret_cast<type>((rettype2 (*) parameters2)(::func)); \

} \

} func = {}; \

} \

_GL_EXTERN_C int _gl_cxxalias_dummy

#else

# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIASWARN (func);

causes a warning to be emitted when ::func is used but not when

GNULIB_NAMESPACE::func is used. func must be defined without overloaded

variants. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIASWARN(func) \

_GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)

# define _GL_CXXALIASWARN_1(func,namespace) \

_GL_CXXALIASWARN_2 (func, namespace)

/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

we enable the warning only when not optimizing. */

# if !__OPTIMIZE__

# define _GL_CXXALIASWARN_2(func,namespace) \

_GL_WARN_ON_USE (func, \

"The symbol ::" #func " refers to the system function. " \

"Use " #namespace "::" #func " instead.")

# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

# define _GL_CXXALIASWARN_2(func,namespace) \

extern __typeof__ (func) func

# else

# define _GL_CXXALIASWARN_2(func,namespace) \

_GL_EXTERN_C int _gl_cxxalias_dummy

# endif

#else

# define _GL_CXXALIASWARN(func) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);

causes a warning to be emitted when the given overloaded variant of ::func

is used but not when GNULIB_NAMESPACE::func is used. */

#if defined __cplusplus && defined GNULIB_NAMESPACE

# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

_GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \

GNULIB_NAMESPACE)

# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \

_GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)

/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

we enable the warning only when not optimizing. */

# if !__OPTIMIZE__

# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

_GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \

"The symbol ::" #func " refers to the system function. " \

"Use " #namespace "::" #func " instead.")

# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

extern __typeof__ (func) func

# else

# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

_GL_EXTERN_C int _gl_cxxalias_dummy

# endif

#else

# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

_GL_EXTERN_C int _gl_cxxalias_dummy

#endif

#endif /* _GL_CXXDEFS_H */

/* The definition of _GL_ARG_NONNULL is copied here. */

/* A C macro for declaring that specific arguments must not be NULL.

Copyright (C) 2009-2018 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify it

under the terms of the GNU General Public License as published

by the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>. */

/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools

that the values passed as arguments n, ..., m must be non-NULL pointers.

n = 1 stands for the first argument, n = 2 for the second argument etc. */

#ifndef _GL_ARG_NONNULL

# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3

# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))

# else

# define _GL_ARG_NONNULL(params)

# endif

#endif

/* The definition of _GL_WARN_ON_USE is copied here. */

/* A C macro for emitting warnings if a function is used.

Copyright (C) 2010-2018 Free Software Foundation, Inc.

This program is free software: you can redistribute it and/or modify it

under the terms of the GNU General Public License as published

by the Free Software Foundation; either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>. */

/* _GL_WARN_ON_USE (function, "literal string") issues a declaration

for FUNCTION which will then trigger a compiler warning containing

the text of "literal string" anywhere that function is called, if

supported by the compiler. If the compiler does not support this

feature, the macro expands to an unused extern declaration.

_GL_WARN_ON_USE_ATTRIBUTE ("literal string") expands to the

attribute used in _GL_WARN_ON_USE. If the compiler does not support

this feature, it expands to empty.

These macros are useful for marking a function as a potential

portability trap, with the intent that "literal string" include

instructions on the replacement function that should be used

instead.

_GL_WARN_ON_USE is for functions with 'extern' linkage.

_GL_WARN_ON_USE_ATTRIBUTE is for functions with 'static' or 'inline'

linkage.

However, one of the reasons that a function is a portability trap is

if it has the wrong signature. Declaring FUNCTION with a different

signature in C is a compilation error, so this macro must use the

same type as any existing declaration so that programs that avoid

the problematic FUNCTION do not fail to compile merely because they

included a header that poisoned the function. But this implies that

_GL_WARN_ON_USE is only safe to use if FUNCTION is known to already

have a declaration. Use of this macro implies that there must not

be any other macro hiding the declaration of FUNCTION; but

undefining FUNCTION first is part of the poisoning process anyway

(although for symbols that are provided only via a macro, the result

is a compilation error rather than a warning containing

"literal string"). Also note that in C , it is only safe to use if

FUNCTION has no overloads.

For an example, it is possible to poison 'getline' by:

- adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]],

[getline]) in configure.ac, which potentially defines

HAVE_RAW_DECL_GETLINE

- adding this code to a header that wraps the system <stdio.h>:

#undef getline

#if HAVE_RAW_DECL_GETLINE

_GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but"

"not universally present; use the gnulib module getline");

#endif

It is not possible to directly poison global variables. But it is

possible to write a wrapper accessor function, and poison that

(less common usage, like &environ, will cause a compilation error

rather than issue the nice warning, but the end result of informing

the developer about their portability problem is still achieved):

#if HAVE_RAW_DECL_ENVIRON

static char ***

rpl_environ (void) { return &environ; }

_GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared");

# undef environ

# define environ (*rpl_environ ())

#endif

or better (avoiding contradictory use of 'static' and 'extern'):

#if HAVE_RAW_DECL_ENVIRON

static char ***

_GL_WARN_ON_USE_ATTRIBUTE ("environ is not always properly declared")

rpl_environ (void) { return &environ; }

# undef environ

# define environ (*rpl_environ ())

#endif

*/

#ifndef _GL_WARN_ON_USE

# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

/* A compiler attribute is available in gcc versions 4.3.0 and later. */

# define _GL_WARN_ON_USE(function, message) \

extern __typeof__ (function) function __attribute__ ((__warning__ (message)))

# define _GL_WARN_ON_USE_ATTRIBUTE(message) \

__attribute__ ((__warning__ (message)))

# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

/* Verify the existence of the function. */

# define _GL_WARN_ON_USE(function, message) \

extern __typeof__ (function) function

# define _GL_WARN_ON_USE_ATTRIBUTE(message)

# else /* Unsupported. */

# define _GL_WARN_ON_USE(function, message) \

_GL_WARN_EXTERN_C int _gl_warn_on_use

# define _GL_WARN_ON_USE_ATTRIBUTE(message)

# endif

#endif

/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")

is like _GL_WARN_ON_USE (function, "string"), except that the function is

declared with the given prototype, consisting of return type, parameters,

and attributes.

This variant is useful for overloaded functions in C . _GL_WARN_ON_USE does

not work in this case. */

#ifndef _GL_WARN_ON_USE_CXX

# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

extern rettype function parameters_and_attributes \

__attribute__ ((__warning__ (msg)))

# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

/* Verify the existence of the function. */

# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

extern rettype function parameters_and_attributes

# else /* Unsupported. */

# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

_GL_WARN_EXTERN_C int _gl_warn_on_use

# endif

#endif

/* _GL_WARN_EXTERN_C declaration;

performs the declaration with C linkage. */

#ifndef _GL_WARN_EXTERN_C

# if defined __cplusplus

# define _GL_WARN_EXTERN_C extern "C"

# else

# define _GL_WARN_EXTERN_C extern

# endif

#endif

/* Declare overridden functions. */

#if 0

# if 0

# if !(defined __cplusplus && defined GNULIB_NAMESPACE)

# undef fcntl

# define fcntl rpl_fcntl

# endif

_GL_FUNCDECL_RPL (fcntl, int, (int fd, int action, ...));

_GL_CXXALIAS_RPL (fcntl, int, (int fd, int action, ...));

# else

# if !1

_GL_FUNCDECL_SYS (fcntl, int, (int fd, int action, ...));

# endif

_GL_CXXALIAS_SYS (fcntl, int, (int fd, int action, ...));

# endif

_GL_CXXALIASWARN (fcntl);

#elif defined GNULIB_POSIXCHECK

# undef fcntl

# if HAVE_RAW_DECL_FCNTL

_GL_WARN_ON_USE (fcntl, "fcntl is not always POSIX compliant - "

"use gnulib module fcntl for portability");

# endif

#endif

#if 0

# if 0

# if !(defined __cplusplus && defined GNULIB_NAMESPACE)

# undef open

# define open rpl_open

# endif

_GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)

_GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));

# else

_GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));

# endif

/* On HP-UX 11, in C mode, open() is defined as an inline function with a

default argument. _GL_CXXALIASWARN does not work in this case. */

# if !defined __hpux

_GL_CXXALIASWARN (open);

# endif

#elif defined GNULIB_POSIXCHECK

# undef open

/* Assume open is always declared. */

_GL_WARN_ON_USE (open, "open is not always POSIX compliant - "

"use gnulib module open for portability");

#endif

#if 0

# if 0

# if !(defined __cplusplus && defined GNULIB_NAMESPACE)

# undef openat

# define openat rpl_openat

# endif

_GL_FUNCDECL_RPL (openat, int,

(int fd, char const *file, int flags, /* mode_t mode */ ...)

_GL_ARG_NONNULL ((2)));

_GL_CXXALIAS_RPL (openat, int,

(int fd, char const *file, int flags, /* mode_t mode */ ...));

# else

# if !1

_GL_FUNCDECL_SYS (openat, int,

(int fd, char const *file, int flags, /* mode_t mode */ ...)

_GL_ARG_NONNULL ((2)));

# endif

_GL_CXXALIAS_SYS (openat, int,

(int fd, char const *file, int flags, /* mode_t mode */ ...));

# endif

_GL_CXXALIASWARN (openat);

#elif defined GNULIB_POSIXCHECK

# undef openat

# if HAVE_RAW_DECL_OPENAT

_GL_WARN_ON_USE (openat, "openat is not portable - "

"use gnulib module openat for portability");

# endif

#endif

/* Fix up the FD_* macros, only known to be missing on mingw. */

#ifndef FD_CLOEXEC

# define FD_CLOEXEC 1

#endif

/* Fix up the supported F_* macros. Intentionally leave other F_*

macros undefined. Only known to be missing on mingw. */

#ifndef F_DUPFD_CLOEXEC

# define F_DUPFD_CLOEXEC 0x40000000

/* Witness variable: 1 if gnulib defined F_DUPFD_CLOEXEC, 0 otherwise. */

# define GNULIB_defined_F_DUPFD_CLOEXEC 1

#else

# define GNULIB_defined_F_DUPFD_CLOEXEC 0

#endif

#ifndef F_DUPFD

# define F_DUPFD 1

#endif

#ifndef F_GETFD

# define F_GETFD 2

#endif

/* Fix up the O_* macros. */

/* AIX 7.1 with XL C 12.1 defines O_CLOEXEC, O_NOFOLLOW, and O_TTY_INIT

to values outside 'int' range, so omit these misdefinitions.

But avoid namespace pollution on non-AIX systems. */

#ifdef _AIX

# include <limits.h>

# if defined O_CLOEXEC && ! (INT_MIN <= O_CLOEXEC && O_CLOEXEC <= INT_MAX)

# undef O_CLOEXEC

# endif

# if defined O_NOFOLLOW && ! (INT_MIN <= O_NOFOLLOW && O_NOFOLLOW <= INT_MAX)

# undef O_NOFOLLOW

# endif

# if defined O_TTY_INIT && ! (INT_MIN <= O_TTY_INIT && O_TTY_INIT <= INT_MAX)

# undef O_TTY_INIT

# endif

#endif

#if !defined O_DIRECT && defined O_DIRECTIO

/* Tru64 spells it 'O_DIRECTIO'. */

# define O_DIRECT O_DIRECTIO

#endif

#if !defined O_CLOEXEC && defined O_NOINHERIT

/* Mingw spells it 'O_NOINHERIT'. */

# define O_CLOEXEC O_NOINHERIT

#endif

#ifndef O_CLOEXEC

# define O_CLOEXEC 0x40000000 /* Try to not collide with system O_* flags. */

# define GNULIB_defined_O_CLOEXEC 1

#else

# define GNULIB_defined_O_CLOEXEC 0

#endif

#ifndef O_DIRECT

# define O_DIRECT 0

#endif

#ifndef O_DIRECTORY

# define O_DIRECTORY 0

#endif

#ifndef O_DSYNC

# define O_DSYNC 0

#endif

#ifndef O_EXEC

# define O_EXEC O_RDONLY /* This is often close enough in older systems. */

#endif

#ifndef O_IGNORE_CTTY

# define O_IGNORE_CTTY 0

#endif

#ifndef O_NDELAY

# define O_NDELAY 0

#endif

#ifndef O_NOATIME

# define O_NOATIME 0

#endif

#ifndef O_NONBLOCK

# define O_NONBLOCK O_NDELAY

#endif

/* If the gnulib module 'nonblocking' is in use, guarantee a working non-zero

value of O_NONBLOCK. Otherwise, O_NONBLOCK is defined (above) to O_NDELAY

or to 0 as fallback. */

#if 0

# if O_NONBLOCK

# define GNULIB_defined_O_NONBLOCK 0

# else

# define GNULIB_defined_O_NONBLOCK 1

# undef O_NONBLOCK

# define O_NONBLOCK 0x40000000

# endif

#endif

#ifndef O_NOCTTY

# define O_NOCTTY 0

#endif

#ifndef O_NOFOLLOW

# define O_NOFOLLOW 0

#endif

#ifndef O_NOLINK

# define O_NOLINK 0

#endif

#ifndef O_NOLINKS

# define O_NOLINKS 0

#endif

#ifndef O_NOTRANS

# define O_NOTRANS 0

#endif

#ifndef O_RSYNC

# define O_RSYNC 0

#endif

#ifndef O_SEARCH

# define O_SEARCH O_RDONLY /* This is often close enough in older systems. */

#endif

#ifndef O_SYNC

# define O_SYNC 0

#endif

#ifndef O_TTY_INIT

# define O_TTY_INIT 0

#endif

#if ~O_ACCMODE & (O_RDONLY | O_WRONLY | O_RDWR | O_EXEC | O_SEARCH)

# undef O_ACCMODE

# define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR | O_EXEC | O_SEARCH)

#endif

/* For systems that distinguish between text and binary I/O.

O_BINARY is usually declared in fcntl.h */

#if !defined O_BINARY && defined _O_BINARY

/* For MSC-compatible compilers. */

# define O_BINARY _O_BINARY

# define O_TEXT _O_TEXT

#endif

#if defined __BEOS__ || defined __HAIKU__

/* BeOS 5 and Haiku have O_BINARY and O_TEXT, but they have no effect. */

# undef O_BINARY

# undef O_TEXT

#endif

#ifndef O_BINARY

# define O_BINARY 0

# define O_TEXT 0

#endif

/* Fix up the AT_* macros. */

/* Work around a bug in Solaris 9 and 10: AT_FDCWD is positive. Its

value exceeds INT_MAX, so its use as an int doesn't conform to the

C standard, and GCC and Sun C complain in some cases. If the bug

is present, undef AT_FDCWD here, so it can be redefined below. */

#if 0 < AT_FDCWD && AT_FDCWD == 0xffd19553

# undef AT_FDCWD

#endif

/* Use the same bit pattern as Solaris 9, but with the proper

signedness. The bit pattern is important, in case this actually is

Solaris with the above workaround. */

#ifndef AT_FDCWD

# define AT_FDCWD (-3041965)

#endif

/* Use the same values as Solaris 9. This shouldn't matter, but

there's no real reason to differ. */

#ifndef AT_SYMLINK_NOFOLLOW

# define AT_SYMLINK_NOFOLLOW 4096

#endif

#ifndef AT_REMOVEDIR

# define AT_REMOVEDIR 1

#endif

/* Solaris 9 lacks these two, so just pick unique values. */

#ifndef AT_SYMLINK_FOLLOW

# define AT_SYMLINK_FOLLOW 2

#endif

#ifndef AT_EACCESS

# define AT_EACCESS 4

#endif

#endif /* _GL_FCNTL_H */

#endif /* _GL_FCNTL_H */

#endif