/*[clinic input]

preserve

[clinic start generated code]*/

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

# include "pycore_gc.h" // PyGC_Head

# include "pycore_runtime.h" // _Py_ID()

#endif

#include "pycore_abstract.h" // _PyNumber_Index()

#include "pycore_long.h" // _PyLong_UnsignedInt_Converter()

#include "pycore_modsupport.h" // _PyArg_UnpackKeywords()

PyDoc_STRVAR(os_stat__doc__,

"stat($module, /, path, *, dir_fd=None, follow_symlinks=True)\n"

"--\n"

"\n"

"Perform a stat system call on the given path.\n"

"\n"

" path\n"

" Path to be examined; can be string, bytes, a path-like object or\n"

" open-file-descriptor int.\n"

" dir_fd\n"

" If not None, it should be a file descriptor open to a directory,\n"

" and path should be a relative string; path will then be relative to\n"

" that directory.\n"

" follow_symlinks\n"

" If False, and the last element of the path is a symbolic link,\n"

" stat will examine the symbolic link itself instead of the file\n"

" the link points to.\n"

"\n"

"dir_fd and follow_symlinks may not be implemented\n"

" on your platform. If they are unavailable, using them will raise a\n"

" NotImplementedError.\n"

"\n"

"It\'s an error to use dir_fd or follow_symlinks when specifying path as\n"

" an open file descriptor.");

#define OS_STAT_METHODDEF \

{"stat", _PyCFunction_CAST(os_stat), METH_FASTCALL|METH_KEYWORDS, os_stat__doc__},

static PyObject *

os_stat_impl(PyObject *module, path_t *path, int dir_fd, int follow_symlinks);

static PyObject *

os_stat(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(dir_fd), &_Py_ID(follow_symlinks), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "dir_fd", "follow_symlinks", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "stat",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

path_t path = PATH_T_INITIALIZE_P("stat", "path", 0, 0, 0, 1);

int dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = 1;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

if (!noptargs) {

goto skip_optional_kwonly;

}

if (args[1]) {

if (!FSTATAT_DIR_FD_CONVERTER(args[1], &dir_fd)) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

follow_symlinks = PyObject_IsTrue(args[2]);

if (follow_symlinks < 0) {

goto exit;

}

skip_optional_kwonly:

return_value = os_stat_impl(module, &path, dir_fd, follow_symlinks);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

PyDoc_STRVAR(os_lstat__doc__,

"lstat($module, /, path, *, dir_fd=None)\n"

"--\n"

"\n"

"Perform a stat system call on the given path, without following symbolic links.\n"

"\n"

"Like stat(), but do not follow symbolic links.\n"

"Equivalent to stat(path, follow_symlinks=False).");

#define OS_LSTAT_METHODDEF \

{"lstat", _PyCFunction_CAST(os_lstat), METH_FASTCALL|METH_KEYWORDS, os_lstat__doc__},

static PyObject *

os_lstat_impl(PyObject *module, path_t *path, int dir_fd);

static PyObject *

os_lstat(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(dir_fd), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "dir_fd", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "lstat",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;

path_t path = PATH_T_INITIALIZE_P("lstat", "path", 0, 0, 0, 0);

int dir_fd = DEFAULT_DIR_FD;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

if (!noptargs) {

goto skip_optional_kwonly;

}

if (!FSTATAT_DIR_FD_CONVERTER(args[1], &dir_fd)) {

goto exit;

}

skip_optional_kwonly:

return_value = os_lstat_impl(module, &path, dir_fd);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

PyDoc_STRVAR(os_access__doc__,

"access($module, /, path, mode, *, dir_fd=None, effective_ids=False,\n"

" follow_symlinks=True)\n"

"--\n"

"\n"

"Use the real uid/gid to test for access to a path.\n"

"\n"

" path\n"

" Path to be tested; can be string, bytes, or a path-like object.\n"

" mode\n"

" Operating-system mode bitfield. Can be F_OK to test existence,\n"

" or the inclusive-OR of R_OK, W_OK, and X_OK.\n"

" dir_fd\n"

" If not None, it should be a file descriptor open to a directory,\n"

" and path should be relative; path will then be relative to that\n"

" directory.\n"

" effective_ids\n"

" If True, access will use the effective uid/gid instead of\n"

" the real uid/gid.\n"

" follow_symlinks\n"

" If False, and the last element of the path is a symbolic link,\n"

" access will examine the symbolic link itself instead of the file\n"

" the link points to.\n"

"\n"

"dir_fd, effective_ids, and follow_symlinks may not be implemented\n"

" on your platform. If they are unavailable, using them will raise a\n"

" NotImplementedError.\n"

"\n"

"Note that most operations will use the effective uid/gid, therefore this\n"

" routine can be used in a suid/sgid environment to test if the invoking user\n"

" has the specified access to the path.");

#define OS_ACCESS_METHODDEF \

{"access", _PyCFunction_CAST(os_access), METH_FASTCALL|METH_KEYWORDS, os_access__doc__},

static int

os_access_impl(PyObject *module, path_t *path, int mode, int dir_fd,

int effective_ids, int follow_symlinks);

static PyObject *

os_access(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 5

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(mode), &_Py_ID(dir_fd), &_Py_ID(effective_ids), &_Py_ID(follow_symlinks), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "mode", "dir_fd", "effective_ids", "follow_symlinks", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "access",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[5];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;

path_t path = PATH_T_INITIALIZE_P("access", "path", 0, 0, 0, 0);

int mode;

int dir_fd = DEFAULT_DIR_FD;

int effective_ids = 0;

int follow_symlinks = 1;

int _return_value;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

mode = PyLong_AsInt(args[1]);

if (mode == -1 && PyErr_Occurred()) {

goto exit;

}

if (!noptargs) {

goto skip_optional_kwonly;

}

if (args[2]) {

if (!FACCESSAT_DIR_FD_CONVERTER(args[2], &dir_fd)) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

if (args[3]) {

effective_ids = PyObject_IsTrue(args[3]);

if (effective_ids < 0) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

follow_symlinks = PyObject_IsTrue(args[4]);

if (follow_symlinks < 0) {

goto exit;

}

skip_optional_kwonly:

_return_value = os_access_impl(module, &path, mode, dir_fd, effective_ids, follow_symlinks);

if ((_return_value == -1) && PyErr_Occurred()) {

goto exit;

}

return_value = PyBool_FromLong((long)_return_value);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#if defined(HAVE_TTYNAME)

PyDoc_STRVAR(os_ttyname__doc__,

"ttyname($module, fd, /)\n"

"--\n"

"\n"

"Return the name of the terminal device connected to \'fd\'.\n"

"\n"

" fd\n"

" Integer file descriptor handle.");

#define OS_TTYNAME_METHODDEF \

{"ttyname", (PyCFunction)os_ttyname, METH_O, os_ttyname__doc__},

static PyObject *

os_ttyname_impl(PyObject *module, int fd);

static PyObject *

os_ttyname(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int fd;

fd = PyLong_AsInt(arg);

if (fd == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = os_ttyname_impl(module, fd);

exit:

return return_value;

}

#endif /* defined(HAVE_TTYNAME) */

#if defined(HAVE_CTERMID)

PyDoc_STRVAR(os_ctermid__doc__,

"ctermid($module, /)\n"

"--\n"

"\n"

"Return the name of the controlling terminal for this process.");

#define OS_CTERMID_METHODDEF \

{"ctermid", (PyCFunction)os_ctermid, METH_NOARGS, os_ctermid__doc__},

static PyObject *

os_ctermid_impl(PyObject *module);

static PyObject *

os_ctermid(PyObject *module, PyObject *Py_UNUSED(ignored))

{

return os_ctermid_impl(module);

}

#endif /* defined(HAVE_CTERMID) */

PyDoc_STRVAR(os_chdir__doc__,

"chdir($module, /, path)\n"

"--\n"

"\n"

"Change the current working directory to the specified path.\n"

"\n"

"path may always be specified as a string.\n"

"On some platforms, path may also be specified as an open file descriptor.\n"

" If this functionality is unavailable, using it raises an exception.");

#define OS_CHDIR_METHODDEF \

{"chdir", _PyCFunction_CAST(os_chdir), METH_FASTCALL|METH_KEYWORDS, os_chdir__doc__},

static PyObject *

os_chdir_impl(PyObject *module, path_t *path);

static PyObject *

os_chdir(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "chdir",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

path_t path = PATH_T_INITIALIZE_P("chdir", "path", 0, 0, 0, PATH_HAVE_FCHDIR);

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

return_value = os_chdir_impl(module, &path);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#if defined(HAVE_FCHDIR)

PyDoc_STRVAR(os_fchdir__doc__,

"fchdir($module, /, fd)\n"

"--\n"

"\n"

"Change to the directory of the given file descriptor.\n"

"\n"

"fd must be opened on a directory, not a file.\n"

"Equivalent to os.chdir(fd).");

#define OS_FCHDIR_METHODDEF \

{"fchdir", _PyCFunction_CAST(os_fchdir), METH_FASTCALL|METH_KEYWORDS, os_fchdir__doc__},

static PyObject *

os_fchdir_impl(PyObject *module, int fd);

static PyObject *

os_fchdir(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(fd), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"fd", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "fchdir",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

int fd;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

fd = PyObject_AsFileDescriptor(args[0]);

if (fd < 0) {

goto exit;

}

return_value = os_fchdir_impl(module, fd);

exit:

return return_value;

}

#endif /* defined(HAVE_FCHDIR) */

PyDoc_STRVAR(os_chmod__doc__,

"chmod($module, /, path, mode, *, dir_fd=None,\n"

" follow_symlinks=(os.name != \'nt\'))\n"

"--\n"

"\n"

"Change the access permissions of a file.\n"

"\n"

" path\n"

" Path to be modified. May always be specified as a str, bytes, or a path-like object.\n"

" On some platforms, path may also be specified as an open file descriptor.\n"

" If this functionality is unavailable, using it raises an exception.\n"

" mode\n"

" Operating-system mode bitfield.\n"

" Be careful when using number literals for *mode*. The conventional UNIX notation for\n"

" numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in\n"

" Python.\n"

" dir_fd\n"

" If not None, it should be a file descriptor open to a directory,\n"

" and path should be relative; path will then be relative to that\n"

" directory.\n"

" follow_symlinks\n"

" If False, and the last element of the path is a symbolic link,\n"

" chmod will modify the symbolic link itself instead of the file\n"

" the link points to.\n"

"\n"

"It is an error to use dir_fd or follow_symlinks when specifying path as\n"

" an open file descriptor.\n"

"dir_fd and follow_symlinks may not be implemented on your platform.\n"

" If they are unavailable, using them will raise a NotImplementedError.");

#define OS_CHMOD_METHODDEF \

{"chmod", _PyCFunction_CAST(os_chmod), METH_FASTCALL|METH_KEYWORDS, os_chmod__doc__},

static PyObject *

os_chmod_impl(PyObject *module, path_t *path, int mode, int dir_fd,

int follow_symlinks);

static PyObject *

os_chmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 4

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(mode), &_Py_ID(dir_fd), &_Py_ID(follow_symlinks), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "mode", "dir_fd", "follow_symlinks", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "chmod",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[4];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;

path_t path = PATH_T_INITIALIZE_P("chmod", "path", 0, 0, 0, PATH_HAVE_FCHMOD);

int mode;

int dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = CHMOD_DEFAULT_FOLLOW_SYMLINKS;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

mode = PyLong_AsInt(args[1]);

if (mode == -1 && PyErr_Occurred()) {

goto exit;

}

if (!noptargs) {

goto skip_optional_kwonly;

}

if (args[2]) {

if (!FCHMODAT_DIR_FD_CONVERTER(args[2], &dir_fd)) {

goto exit;

}

if (!--noptargs) {

goto skip_optional_kwonly;

}

}

follow_symlinks = PyObject_IsTrue(args[3]);

if (follow_symlinks < 0) {

goto exit;

}

skip_optional_kwonly:

return_value = os_chmod_impl(module, &path, mode, dir_fd, follow_symlinks);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#if (defined(HAVE_FCHMOD) || defined(MS_WINDOWS))

PyDoc_STRVAR(os_fchmod__doc__,

"fchmod($module, /, fd, mode)\n"

"--\n"

"\n"

"Change the access permissions of the file given by file descriptor fd.\n"

"\n"

" fd\n"

" The file descriptor of the file to be modified.\n"

" mode\n"

" Operating-system mode bitfield.\n"

" Be careful when using number literals for *mode*. The conventional UNIX notation for\n"

" numeric modes uses an octal base, which needs to be indicated with a ``0o`` prefix in\n"

" Python.\n"

"\n"

"Equivalent to os.chmod(fd, mode).");

#define OS_FCHMOD_METHODDEF \

{"fchmod", _PyCFunction_CAST(os_fchmod), METH_FASTCALL|METH_KEYWORDS, os_fchmod__doc__},

static PyObject *

os_fchmod_impl(PyObject *module, int fd, int mode);

static PyObject *

os_fchmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(fd), &_Py_ID(mode), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"fd", "mode", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "fchmod",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

int fd;

int mode;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

fd = PyLong_AsInt(args[0]);

if (fd == -1 && PyErr_Occurred()) {

goto exit;

}

mode = PyLong_AsInt(args[1]);

if (mode == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = os_fchmod_impl(module, fd, mode);

exit:

return return_value;

}

#endif /* (defined(HAVE_FCHMOD) || defined(MS_WINDOWS)) */

#if (defined(HAVE_LCHMOD) || defined(MS_WINDOWS))

PyDoc_STRVAR(os_lchmod__doc__,

"lchmod($module, /, path, mode)\n"

"--\n"

"\n"

"Change the access permissions of a file, without following symbolic links.\n"

"\n"

"If path is a symlink, this affects the link itself rather than the target.\n"

"Equivalent to chmod(path, mode, follow_symlinks=False).\"");

#define OS_LCHMOD_METHODDEF \

{"lchmod", _PyCFunction_CAST(os_lchmod), METH_FASTCALL|METH_KEYWORDS, os_lchmod__doc__},

static PyObject *

os_lchmod_impl(PyObject *module, path_t *path, int mode);

static PyObject *

os_lchmod(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(mode), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "mode", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "lchmod",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

path_t path = PATH_T_INITIALIZE_P("lchmod", "path", 0, 0, 0, 0);

int mode;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

mode = PyLong_AsInt(args[1]);

if (mode == -1 && PyErr_Occurred()) {

goto exit;

}

return_value = os_lchmod_impl(module, &path, mode);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* (defined(HAVE_LCHMOD) || defined(MS_WINDOWS)) */

#if defined(HAVE_CHFLAGS)

PyDoc_STRVAR(os_chflags__doc__,

"chflags($module, /, path, flags, follow_symlinks=True)\n"

"--\n"

"\n"

"Set file flags.\n"

"\n"

"If follow_symlinks is False, and the last element of the path is a symbolic\n"

" link, chflags will change flags on the symbolic link itself instead of the\n"

" file the link points to.\n"

"follow_symlinks may not be implemented on your platform. If it is\n"

"unavailable, using it will raise a NotImplementedError.");

#define OS_CHFLAGS_METHODDEF \

{"chflags", _PyCFunction_CAST(os_chflags), METH_FASTCALL|METH_KEYWORDS, os_chflags__doc__},

static PyObject *

os_chflags_impl(PyObject *module, path_t *path, unsigned long flags,

int follow_symlinks);

static PyObject *

os_chflags(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 3

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(flags), &_Py_ID(follow_symlinks), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "flags", "follow_symlinks", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "chflags",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[3];

Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;

path_t path = PATH_T_INITIALIZE_P("chflags", "path", 0, 0, 0, 0);

unsigned long flags;

int follow_symlinks = 1;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

if (!PyLong_Check(args[1])) {

_PyArg_BadArgument("chflags", "argument 'flags'", "int", args[1]);

goto exit;

}

flags = PyLong_AsUnsignedLongMask(args[1]);

if (!noptargs) {

goto skip_optional_pos;

}

follow_symlinks = PyObject_IsTrue(args[2]);

if (follow_symlinks < 0) {

goto exit;

}

skip_optional_pos:

return_value = os_chflags_impl(module, &path, flags, follow_symlinks);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_CHFLAGS) */

#if defined(HAVE_LCHFLAGS)

PyDoc_STRVAR(os_lchflags__doc__,

"lchflags($module, /, path, flags)\n"

"--\n"

"\n"

"Set file flags.\n"

"\n"

"This function will not follow symbolic links.\n"

"Equivalent to chflags(path, flags, follow_symlinks=False).");

#define OS_LCHFLAGS_METHODDEF \

{"lchflags", _PyCFunction_CAST(os_lchflags), METH_FASTCALL|METH_KEYWORDS, os_lchflags__doc__},

static PyObject *

os_lchflags_impl(PyObject *module, path_t *path, unsigned long flags);

static PyObject *

os_lchflags(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 2

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), &_Py_ID(flags), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", "flags", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "lchflags",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[2];

path_t path = PATH_T_INITIALIZE_P("lchflags", "path", 0, 0, 0, 0);

unsigned long flags;

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

if (!PyLong_Check(args[1])) {

_PyArg_BadArgument("lchflags", "argument 'flags'", "int", args[1]);

goto exit;

}

flags = PyLong_AsUnsignedLongMask(args[1]);

return_value = os_lchflags_impl(module, &path, flags);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_LCHFLAGS) */

#if defined(HAVE_CHROOT)

PyDoc_STRVAR(os_chroot__doc__,

"chroot($module, /, path)\n"

"--\n"

"\n"

"Change root directory to path.");

#define OS_CHROOT_METHODDEF \

{"chroot", _PyCFunction_CAST(os_chroot), METH_FASTCALL|METH_KEYWORDS, os_chroot__doc__},

static PyObject *

os_chroot_impl(PyObject *module, path_t *path);

static PyObject *

os_chroot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD

PyObject *ob_item[NUM_KEYWORDS];

} _kwtuple = {

.ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)

.ob_item = { &_Py_ID(path), },

};

#undef NUM_KEYWORDS

#define KWTUPLE (&_kwtuple.ob_base.ob_base)

#else // !Py_BUILD_CORE

# define KWTUPLE NULL

#endif // !Py_BUILD_CORE

static const char * const _keywords[] = {"path", NULL};

static _PyArg_Parser _parser = {

.keywords = _keywords,

.fname = "chroot",

.kwtuple = KWTUPLE,

};

#undef KWTUPLE

PyObject *argsbuf[1];

path_t path = PATH_T_INITIALIZE_P("chroot", "path", 0, 0, 0, 0);

args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);

if (!args) {

goto exit;

}

if (!path_converter(args[0], &path)) {

goto exit;

}

return_value = os_chroot_impl(module, &path);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_CHROOT) */

#if defined(HAVE_FSYNC)

PyDoc_STRVAR(os_fsync__doc__,

"fsync($module, /, fd)\n"

"--\n"

"\n"

"Force write of fd to disk.");

#define OS_FSYNC_METHODDEF \

{"fsync", _PyCFunction_CAST(os_fsync), METH_FASTCALL|METH_KEYWORDS, os_fsync__doc__},

static PyObject *

os_fsync_impl(PyObject *module, int fd);

static PyObject *

os_fsync(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)

#define NUM_KEYWORDS 1

static struct {

PyGC_Head _this_is_not_used;

PyObject_VAR_HEAD