PyDoc_STRVAR(os_stat__doc__,

" an open file descriptor.");

#define OS_STAT_METHODDEF \

{"stat", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&|$O&p:stat", _keywords, 0};

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

int dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = 1;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, FSTATAT_DIR_FD_CONVERTER, &dir_fd, &follow_symlinks)) {

goto exit;

}

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__,

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

#define OS_LSTAT_METHODDEF \

{"lstat", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&|$O&:lstat", _keywords, 0};

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

int dir_fd = DEFAULT_DIR_FD;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, FSTATAT_DIR_FD_CONVERTER, &dir_fd)) {

goto exit;

}

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

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

PyDoc_STRVAR(os_access__doc__,

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

#define OS_ACCESS_METHODDEF \

{"access", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&i|$O&pp:access", _keywords, 0};

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

int mode;

int dir_fd = DEFAULT_DIR_FD;

int effective_ids = 0;

int follow_symlinks = 1;

int _return_value;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, &mode, FACCESSAT_DIR_FD_CONVERTER, &dir_fd, &effective_ids, &follow_symlinks)) {

goto exit;

}

_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__,

" Integer file descriptor handle.");

#define OS_TTYNAME_METHODDEF \

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

static char *

os_ttyname_impl(PyObject *module, int fd);

static PyObject *

os_ttyname(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

int fd;

char *_return_value;

if (!PyArg_Parse(arg, "i:ttyname", &fd)) {

goto exit;

}

_return_value = os_ttyname_impl(module, fd);

if (_return_value == NULL) {

goto exit;

}

return_value = PyUnicode_DecodeFSDefault(_return_value);

exit:

return return_value;

}

#endif /* defined(HAVE_TTYNAME) */

#if defined(HAVE_CTERMID)

PyDoc_STRVAR(os_ctermid__doc__,

"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__,

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

#define OS_CHDIR_METHODDEF \

{"chdir", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&:chdir", _keywords, 0};

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

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &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__,

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

#define OS_FCHDIR_METHODDEF \

{"fchdir", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&:fchdir", _keywords, 0};

int fd;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

fildes_converter, &fd)) {

goto exit;

}

return_value = os_fchdir_impl(module, fd);

exit:

return return_value;

}

#endif /* defined(HAVE_FCHDIR) */

PyDoc_STRVAR(os_chmod__doc__,

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

#define OS_CHMOD_METHODDEF \

{"chmod", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&i|$O&p:chmod", _keywords, 0};

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

int mode;

int dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = 1;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, &mode, FCHMODAT_DIR_FD_CONVERTER, &dir_fd, &follow_symlinks)) {

goto exit;

}

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)

PyDoc_STRVAR(os_fchmod__doc__,

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

#define OS_FCHMOD_METHODDEF \

{"fchmod", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"ii:fchmod", _keywords, 0};

int fd;

int mode;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

&fd, &mode)) {

goto exit;

}

return_value = os_fchmod_impl(module, fd, mode);

exit:

return return_value;

}

#endif /* defined(HAVE_FCHMOD) */

#if defined(HAVE_LCHMOD)

PyDoc_STRVAR(os_lchmod__doc__,

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

#define OS_LCHMOD_METHODDEF \

{"lchmod", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&i:lchmod", _keywords, 0};

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

int mode;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, &mode)) {

goto exit;

}

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

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_LCHMOD) */

#if defined(HAVE_CHFLAGS)

PyDoc_STRVAR(os_chflags__doc__,

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

#define OS_CHFLAGS_METHODDEF \

{"chflags", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&k|p:chflags", _keywords, 0};

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

unsigned long flags;

int follow_symlinks = 1;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, &flags, &follow_symlinks)) {

goto exit;

}

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__,

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

#define OS_LCHFLAGS_METHODDEF \

{"lchflags", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&k:lchflags", _keywords, 0};

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

unsigned long flags;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, &flags)) {

goto exit;

}

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__,

"Change root directory to path.");

#define OS_CHROOT_METHODDEF \

{"chroot", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&:chroot", _keywords, 0};

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

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &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__,

"Force write of fd to disk.");

#define OS_FSYNC_METHODDEF \

{"fsync", (PyCFunction)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;

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

static _PyArg_Parser _parser = {"O&:fsync", _keywords, 0};

int fd;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

fildes_converter, &fd)) {

goto exit;

}

return_value = os_fsync_impl(module, fd);

exit:

return return_value;

}

#endif /* defined(HAVE_FSYNC) */

#if defined(HAVE_SYNC)

PyDoc_STRVAR(os_sync__doc__,

"Force write of everything to disk.");

#define OS_SYNC_METHODDEF \

{"sync", (PyCFunction)os_sync, METH_NOARGS, os_sync__doc__},

static PyObject *

os_sync_impl(PyObject *module);

static PyObject *

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

{

return os_sync_impl(module);

}

#endif /* defined(HAVE_SYNC) */

#if defined(HAVE_FDATASYNC)

PyDoc_STRVAR(os_fdatasync__doc__,

"Force write of fd to disk without forcing update of metadata.");

#define OS_FDATASYNC_METHODDEF \

{"fdatasync", (PyCFunction)os_fdatasync, METH_FASTCALL|METH_KEYWORDS, os_fdatasync__doc__},

static PyObject *

os_fdatasync_impl(PyObject *module, int fd);

static PyObject *

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

{

PyObject *return_value = NULL;

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

static _PyArg_Parser _parser = {"O&:fdatasync", _keywords, 0};

int fd;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

fildes_converter, &fd)) {

goto exit;

}

return_value = os_fdatasync_impl(module, fd);

exit:

return return_value;

}

#endif /* defined(HAVE_FDATASYNC) */

#if defined(HAVE_CHOWN)

PyDoc_STRVAR(os_chown__doc__,

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

#define OS_CHOWN_METHODDEF \

{"chown", (PyCFunction)os_chown, METH_FASTCALL|METH_KEYWORDS, os_chown__doc__},

static PyObject *

os_chown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid,

int dir_fd, int follow_symlinks);

static PyObject *

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

{

PyObject *return_value = NULL;

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

static _PyArg_Parser _parser = {"O&O&O&|$O&p:chown", _keywords, 0};

path_t path = PATH_T_INITIALIZE("chown", "path", 0, PATH_HAVE_FCHOWN);

uid_t uid;

gid_t gid;

int dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = 1;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, _Py_Uid_Converter, &uid, _Py_Gid_Converter, &gid, FCHOWNAT_DIR_FD_CONVERTER, &dir_fd, &follow_symlinks)) {

goto exit;

}

return_value = os_chown_impl(module, &path, uid, gid, dir_fd, follow_symlinks);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_CHOWN) */

#if defined(HAVE_FCHOWN)

PyDoc_STRVAR(os_fchown__doc__,

"Equivalent to os.chown(fd, uid, gid).");

#define OS_FCHOWN_METHODDEF \

{"fchown", (PyCFunction)os_fchown, METH_FASTCALL|METH_KEYWORDS, os_fchown__doc__},

static PyObject *

os_fchown_impl(PyObject *module, int fd, uid_t uid, gid_t gid);

static PyObject *

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

{

PyObject *return_value = NULL;

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

static _PyArg_Parser _parser = {"iO&O&:fchown", _keywords, 0};

int fd;

uid_t uid;

gid_t gid;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

&fd, _Py_Uid_Converter, &uid, _Py_Gid_Converter, &gid)) {

goto exit;

}

return_value = os_fchown_impl(module, fd, uid, gid);

exit:

return return_value;

}

#endif /* defined(HAVE_FCHOWN) */

#if defined(HAVE_LCHOWN)

PyDoc_STRVAR(os_lchown__doc__,

"Equivalent to os.chown(path, uid, gid, follow_symlinks=False).");

#define OS_LCHOWN_METHODDEF \

{"lchown", (PyCFunction)os_lchown, METH_FASTCALL|METH_KEYWORDS, os_lchown__doc__},

static PyObject *

os_lchown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid);

static PyObject *

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

{

PyObject *return_value = NULL;

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

static _PyArg_Parser _parser = {"O&O&O&:lchown", _keywords, 0};

path_t path = PATH_T_INITIALIZE("lchown", "path", 0, 0);

uid_t uid;

gid_t gid;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path, _Py_Uid_Converter, &uid, _Py_Gid_Converter, &gid)) {

goto exit;

}

return_value = os_lchown_impl(module, &path, uid, gid);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(HAVE_LCHOWN) */

PyDoc_STRVAR(os_getcwd__doc__,

"Return a unicode string representing the current working directory.");

#define OS_GETCWD_METHODDEF \

{"getcwd", (PyCFunction)os_getcwd, METH_NOARGS, os_getcwd__doc__},

static PyObject *

os_getcwd_impl(PyObject *module);

static PyObject *

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

{

return os_getcwd_impl(module);

}

PyDoc_STRVAR(os_getcwdb__doc__,

"Return a bytes string representing the current working directory.");

#define OS_GETCWDB_METHODDEF \

{"getcwdb", (PyCFunction)os_getcwdb, METH_NOARGS, os_getcwdb__doc__},

static PyObject *

os_getcwdb_impl(PyObject *module);

static PyObject *

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

{

return os_getcwdb_impl(module);

}

#if defined(HAVE_LINK)

PyDoc_STRVAR(os_link__doc__,

" NotImplementedError.");

#define OS_LINK_METHODDEF \

{"link", (PyCFunction)os_link, METH_FASTCALL|METH_KEYWORDS, os_link__doc__},

static PyObject *

os_link_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,

int dst_dir_fd, int follow_symlinks);

static PyObject *

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

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"src", "dst", "src_dir_fd", "dst_dir_fd", "follow_symlinks", NULL};

static _PyArg_Parser _parser = {"O&O&|$O&O&p:link", _keywords, 0};

path_t src = PATH_T_INITIALIZE("link", "src", 0, 0);

path_t dst = PATH_T_INITIALIZE("link", "dst", 0, 0);

int src_dir_fd = DEFAULT_DIR_FD;

int dst_dir_fd = DEFAULT_DIR_FD;

int follow_symlinks = 1;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &src, path_converter, &dst, dir_fd_converter, &src_dir_fd, dir_fd_converter, &dst_dir_fd, &follow_symlinks)) {

goto exit;

}

return_value = os_link_impl(module, &src, &dst, src_dir_fd, dst_dir_fd, follow_symlinks);

exit:

/* Cleanup for src */

path_cleanup(&src);

/* Cleanup for dst */

path_cleanup(&dst);

return return_value;

}

#endif /* defined(HAVE_LINK) */

PyDoc_STRVAR(os_listdir__doc__,

"entries \'.\' and \'..\' even if they are present in the directory.");

#define OS_LISTDIR_METHODDEF \

{"listdir", (PyCFunction)os_listdir, METH_FASTCALL|METH_KEYWORDS, os_listdir__doc__},

static PyObject *

os_listdir_impl(PyObject *module, path_t *path);

static PyObject *

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

{

PyObject *return_value = NULL;

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

static _PyArg_Parser _parser = {"|O&:listdir", _keywords, 0};

path_t path = PATH_T_INITIALIZE("listdir", "path", 1, PATH_HAVE_FDOPENDIR);

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

path_converter, &path)) {

goto exit;

}

return_value = os_listdir_impl(module, &path);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#if defined(MS_WINDOWS)

PyDoc_STRVAR(os__getfullpathname__doc__,

"\n");

#define OS__GETFULLPATHNAME_METHODDEF \

{"_getfullpathname", (PyCFunction)os__getfullpathname, METH_O, os__getfullpathname__doc__},

static PyObject *

os__getfullpathname_impl(PyObject *module, path_t *path);

static PyObject *

os__getfullpathname(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

path_t path = PATH_T_INITIALIZE("_getfullpathname", "path", 0, 0);

if (!PyArg_Parse(arg, "O&:_getfullpathname", path_converter, &path)) {

goto exit;

}

return_value = os__getfullpathname_impl(module, &path);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(MS_WINDOWS) */

#if defined(MS_WINDOWS)

PyDoc_STRVAR(os__getfinalpathname__doc__,

"A helper function for samepath on windows.");

#define OS__GETFINALPATHNAME_METHODDEF \

{"_getfinalpathname", (PyCFunction)os__getfinalpathname, METH_O, os__getfinalpathname__doc__},

static PyObject *

os__getfinalpathname_impl(PyObject *module, path_t *path);

static PyObject *

os__getfinalpathname(PyObject *module, PyObject *arg)

{

PyObject *return_value = NULL;

path_t path = PATH_T_INITIALIZE("_getfinalpathname", "path", 0, 0);

if (!PyArg_Parse(arg, "O&:_getfinalpathname", path_converter, &path)) {

goto exit;

}

return_value = os__getfinalpathname_impl(module, &path);

exit:

/* Cleanup for path */

path_cleanup(&path);

return return_value;

}

#endif /* defined(MS_WINDOWS) */

#if defined(MS_WINDOWS)

PyDoc_STRVAR(os__isdir__doc__,