/*[clinic input]

preserve

[clinic start generated code]*/

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

PyDoc_STRVAR(getpath_abspath__doc__,

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

"--\n"

"\n"

"Return the absolute path.");

#define GETPATH_ABSPATH_METHODDEF    \

    {"abspath", (PyCFunction)getpath_abspath, METH_O, getpath_abspath__doc__},

static PyObject *

getpath_abspath_impl(PyObject *module, const wchar_t *path);

static PyObject *

getpath_abspath(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    const wchar_t *path = NULL;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("abspath", "argument", "str", arg);

        goto exit;

    }

    path = PyUnicode_AsWideCharString(arg, NULL);

    if (path == NULL) {

        goto exit;

    }

    return_value = getpath_abspath_impl(module, path);

exit:

    /* Cleanup for path */

    PyMem_Free((void *)path);

    return return_value;

}

PyDoc_STRVAR(getpath_basename__doc__,

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

"--\n"

"\n"

"Return the final component of the path.");

#define GETPATH_BASENAME_METHODDEF    \

    {"basename", (PyCFunction)getpath_basename, METH_O, getpath_basename__doc__},

static PyObject *

getpath_basename_impl(PyObject *module, PyObject *path);

static PyObject *

getpath_basename(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *path;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("basename", "argument", "str", arg);

        goto exit;

    }

    path = arg;

    return_value = getpath_basename_impl(module, path);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_dirname__doc__,

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

"--\n"

"\n"

"Return the directory component of the path.");

#define GETPATH_DIRNAME_METHODDEF    \

    {"dirname", (PyCFunction)getpath_dirname, METH_O, getpath_dirname__doc__},

static PyObject *

getpath_dirname_impl(PyObject *module, PyObject *path);

static PyObject *

getpath_dirname(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *path;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("dirname", "argument", "str", arg);

        goto exit;

    }

    path = arg;

    return_value = getpath_dirname_impl(module, path);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_isabs__doc__,

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

"--\n"

"\n"

"Return True if the path is absolute.");

#define GETPATH_ISABS_METHODDEF    \

    {"isabs", (PyCFunction)getpath_isabs, METH_O, getpath_isabs__doc__},

static int

getpath_isabs_impl(PyObject *module, const wchar_t *path);

static PyObject *

getpath_isabs(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    const wchar_t *path = NULL;

    int _return_value;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("isabs", "argument", "str", arg);

        goto exit;

    }

    path = PyUnicode_AsWideCharString(arg, NULL);

    if (path == NULL) {

        goto exit;

    }

    _return_value = getpath_isabs_impl(module, path);

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

        goto exit;

    }

    return_value = PyBool_FromLong((long)_return_value);

exit:

    /* Cleanup for path */

    PyMem_Free((void *)path);

    return return_value;

}

PyDoc_STRVAR(getpath_hassuffix__doc__,

"hassuffix($module, path, suffix, /)\n"

"--\n"

"\n"

"Return True if the path ends with the suffix, ignoring the case.");

#define GETPATH_HASSUFFIX_METHODDEF    \

    {"hassuffix", _PyCFunction_CAST(getpath_hassuffix), METH_FASTCALL, getpath_hassuffix__doc__},

static int

getpath_hassuffix_impl(PyObject *module, PyObject *pathobj,

                       PyObject *suffixobj);

static PyObject *

getpath_hassuffix(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

    PyObject *return_value = NULL;

    PyObject *pathobj;

    PyObject *suffixobj;

    int _return_value;

    if (!_PyArg_CheckPositional("hassuffix", nargs, 2, 2)) {

        goto exit;

    }

    if (!PyUnicode_Check(args[0])) {

        _PyArg_BadArgument("hassuffix", "argument 1", "str", args[0]);

        goto exit;

    }

    pathobj = args[0];

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

        _PyArg_BadArgument("hassuffix", "argument 2", "str", args[1]);

        goto exit;

    }

    suffixobj = args[1];

    _return_value = getpath_hassuffix_impl(module, pathobj, suffixobj);

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

        goto exit;

    }

    return_value = PyBool_FromLong((long)_return_value);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_isdir__doc__,

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

"--\n"

"\n"

"Return True if the path is a directory.");

#define GETPATH_ISDIR_METHODDEF    \

    {"isdir", (PyCFunction)getpath_isdir, METH_O, getpath_isdir__doc__},

static int

getpath_isdir_impl(PyObject *module, const wchar_t *path);

static PyObject *

getpath_isdir(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    const wchar_t *path = NULL;

    int _return_value;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("isdir", "argument", "str", arg);

        goto exit;

    }

    path = PyUnicode_AsWideCharString(arg, NULL);

    if (path == NULL) {

        goto exit;

    }

    _return_value = getpath_isdir_impl(module, path);

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

        goto exit;

    }

    return_value = PyBool_FromLong((long)_return_value);

exit:

    /* Cleanup for path */

    PyMem_Free((void *)path);

    return return_value;

}

PyDoc_STRVAR(getpath_isfile__doc__,

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

"--\n"

"\n"

"Return True if the path is a regular file.");

#define GETPATH_ISFILE_METHODDEF    \

    {"isfile", (PyCFunction)getpath_isfile, METH_O, getpath_isfile__doc__},

static int

getpath_isfile_impl(PyObject *module, PyObject *pathobj);

static PyObject *

getpath_isfile(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *pathobj;

    int _return_value;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("isfile", "argument", "str", arg);

        goto exit;

    }

    pathobj = arg;

    _return_value = getpath_isfile_impl(module, pathobj);

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

        goto exit;

    }

    return_value = PyBool_FromLong((long)_return_value);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_isxfile__doc__,

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

"--\n"

"\n"

"Return True if the path is an executable file.");

#define GETPATH_ISXFILE_METHODDEF    \

    {"isxfile", (PyCFunction)getpath_isxfile, METH_O, getpath_isxfile__doc__},

static int

getpath_isxfile_impl(PyObject *module, PyObject *pathobj);

static PyObject *

getpath_isxfile(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *pathobj;

    int _return_value;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("isxfile", "argument", "str", arg);

        goto exit;

    }

    pathobj = arg;

    _return_value = getpath_isxfile_impl(module, pathobj);

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

        goto exit;

    }

    return_value = PyBool_FromLong((long)_return_value);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_joinpath__doc__,

"joinpath($module, /, *args)\n"

"--\n"

"\n"

"Join the path components.");

#define GETPATH_JOINPATH_METHODDEF    \

    {"joinpath", _PyCFunction_CAST(getpath_joinpath), METH_FASTCALL, getpath_joinpath__doc__},

static PyObject *

getpath_joinpath_impl(PyObject *module, PyObject *args);

static PyObject *

getpath_joinpath(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

    PyObject *return_value = NULL;

    PyObject *__clinic_args = NULL;

    __clinic_args = PyTuple_FromArray(args, nargs);

    if (__clinic_args == NULL) {

        goto exit;

    }

    return_value = getpath_joinpath_impl(module, __clinic_args);

exit:

    /* Cleanup for args */

    Py_XDECREF(__clinic_args);

    return return_value;

}

PyDoc_STRVAR(getpath_readlines__doc__,

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

"--\n"

"\n"

"Return the lines of the file.");

#define GETPATH_READLINES_METHODDEF    \

    {"readlines", (PyCFunction)getpath_readlines, METH_O, getpath_readlines__doc__},

static PyObject *

getpath_readlines_impl(PyObject *module, PyObject *pathobj);

static PyObject *

getpath_readlines(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *pathobj;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("readlines", "argument", "str", arg);

        goto exit;

    }

    pathobj = arg;

    return_value = getpath_readlines_impl(module, pathobj);

exit:

    return return_value;

}

PyDoc_STRVAR(getpath_realpath__doc__,

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

"--\n"

"\n"

"Resolve a symlinked file.");

#define GETPATH_REALPATH_METHODDEF    \

    {"realpath", (PyCFunction)getpath_realpath, METH_O, getpath_realpath__doc__},

static PyObject *

getpath_realpath_impl(PyObject *module, PyObject *pathobj);

static PyObject *

getpath_realpath(PyObject *module, PyObject *arg)

{

    PyObject *return_value = NULL;

    PyObject *pathobj;

    if (!PyUnicode_Check(arg)) {

        _PyArg_BadArgument("realpath", "argument", "str", arg);

        goto exit;

    }

    pathobj = arg;

    return_value = getpath_realpath_impl(module, pathobj);

exit:

    return return_value;

}

/*[clinic end generated code: output=74266cdd2d87e28d input=a9049054013a1b77]*/