Issue #20172: Convert the msvcrt module to Argument Clinic.

This commit is contained in:
Zachary Ware 2015-05-13 01:22:32 -05:00
parent fd2d482272
commit 4552089617
2 changed files with 937 additions and 284 deletions

604
PC/clinic/msvcrtmodule.c.h Normal file
View File

@ -0,0 +1,604 @@
/*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(msvcrt_heapmin__doc__,
"heapmin($module, /)\n"
"--\n"
"\n"
"Minimize the malloc() heap.\n"
"\n"
"Force the malloc() heap to clean itself up and return unused blocks\n"
"to the operating system. On failure, this raises OSError.");
#define MSVCRT_HEAPMIN_METHODDEF \
{"heapmin", (PyCFunction)msvcrt_heapmin, METH_NOARGS, msvcrt_heapmin__doc__},
static PyObject *
msvcrt_heapmin_impl(PyModuleDef *module);
static PyObject *
msvcrt_heapmin(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
return msvcrt_heapmin_impl(module);
}
PyDoc_STRVAR(msvcrt_locking__doc__,
"locking($module, fd, mode, nbytes, /)\n"
"--\n"
"\n"
"Lock part of a file based on file descriptor fd from the C runtime.\n"
"\n"
"Raises IOError on failure. The locked region of the file extends from\n"
"the current file position for nbytes bytes, and may continue beyond\n"
"the end of the file. mode must be one of the LK_* constants listed\n"
"below. Multiple regions in a file may be locked at the same time, but\n"
"may not overlap. Adjacent regions are not merged; they must be unlocked\n"
"individually.");
#define MSVCRT_LOCKING_METHODDEF \
{"locking", (PyCFunction)msvcrt_locking, METH_VARARGS, msvcrt_locking__doc__},
static PyObject *
msvcrt_locking_impl(PyModuleDef *module, int fd, int mode, long nbytes);
static PyObject *
msvcrt_locking(PyModuleDef *module, PyObject *args)
{
PyObject *return_value = NULL;
int fd;
int mode;
long nbytes;
if (!PyArg_ParseTuple(args,
"iil:locking",
&fd, &mode, &nbytes))
goto exit;
return_value = msvcrt_locking_impl(module, fd, mode, nbytes);
exit:
return return_value;
}
PyDoc_STRVAR(msvcrt_setmode__doc__,
"setmode($module, fd, mode, /)\n"
"--\n"
"\n"
"Set the line-end translation mode for the file descriptor fd.\n"
"\n"
"To set it to text mode, flags should be os.O_TEXT; for binary, it\n"
"should be os.O_BINARY.\n"
"\n"
"Return value is the previous mode.");
#define MSVCRT_SETMODE_METHODDEF \
{"setmode", (PyCFunction)msvcrt_setmode, METH_VARARGS, msvcrt_setmode__doc__},
static long
msvcrt_setmode_impl(PyModuleDef *module, int fd, int flags);
static PyObject *
msvcrt_setmode(PyModuleDef *module, PyObject *args)
{
PyObject *return_value = NULL;
int fd;
int flags;
long _return_value;
if (!PyArg_ParseTuple(args,
"ii:setmode",
&fd, &flags))
goto exit;
_return_value = msvcrt_setmode_impl(module, fd, flags);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
PyDoc_STRVAR(msvcrt_open_osfhandle__doc__,
"open_osfhandle($module, handle, flags, /)\n"
"--\n"
"\n"
"Create a C runtime file descriptor from the file handle handle.\n"
"\n"
"The flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,\n"
"and os.O_TEXT. The returned file descriptor may be used as a parameter\n"
"to os.fdopen() to create a file object.");
#define MSVCRT_OPEN_OSFHANDLE_METHODDEF \
{"open_osfhandle", (PyCFunction)msvcrt_open_osfhandle, METH_VARARGS, msvcrt_open_osfhandle__doc__},
static long
msvcrt_open_osfhandle_impl(PyModuleDef *module, Py_intptr_t handle, int flags);
static PyObject *
msvcrt_open_osfhandle(PyModuleDef *module, PyObject *args)
{
PyObject *return_value = NULL;
Py_intptr_t handle;
int flags;
long _return_value;
if (!PyArg_ParseTuple(args,
""_Py_PARSE_INTPTR"i:open_osfhandle",
&handle, &flags))
goto exit;
_return_value = msvcrt_open_osfhandle_impl(module, handle, flags);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
PyDoc_STRVAR(msvcrt_get_osfhandle__doc__,
"get_osfhandle($module, fd, /)\n"
"--\n"
"\n"
"Return the file handle for the file descriptor fd.\n"
"\n"
"Raises IOError if fd is not recognized.");
#define MSVCRT_GET_OSFHANDLE_METHODDEF \
{"get_osfhandle", (PyCFunction)msvcrt_get_osfhandle, METH_O, msvcrt_get_osfhandle__doc__},
static Py_intptr_t
msvcrt_get_osfhandle_impl(PyModuleDef *module, int fd);
static PyObject *
msvcrt_get_osfhandle(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
int fd;
Py_intptr_t _return_value;
if (!PyArg_Parse(arg,
"i:get_osfhandle",
&fd))
goto exit;
_return_value = msvcrt_get_osfhandle_impl(module, fd);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromVoidPtr((void *)_return_value);
exit:
return return_value;
}
PyDoc_STRVAR(msvcrt_kbhit__doc__,
"kbhit($module, /)\n"
"--\n"
"\n"
"Return true if a keypress is waiting to be read.");
#define MSVCRT_KBHIT_METHODDEF \
{"kbhit", (PyCFunction)msvcrt_kbhit, METH_NOARGS, msvcrt_kbhit__doc__},
static long
msvcrt_kbhit_impl(PyModuleDef *module);
static PyObject *
msvcrt_kbhit(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
PyObject *return_value = NULL;
long _return_value;
_return_value = msvcrt_kbhit_impl(module);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
PyDoc_STRVAR(msvcrt_getch__doc__,
"getch($module, /)\n"
"--\n"
"\n"
"Read a keypress and return the resulting character as a byte string.\n"
"\n"
"Nothing is echoed to the console. This call will block if a keypress is\n"
"not already available, but will not wait for Enter to be pressed. If the\n"
"pressed key was a special function key, this will return \'\\000\' or\n"
"\'\\xe0\'; the next call will return the keycode. The Control-C keypress\n"
"cannot be read with this function.");
#define MSVCRT_GETCH_METHODDEF \
{"getch", (PyCFunction)msvcrt_getch, METH_NOARGS, msvcrt_getch__doc__},
static int
msvcrt_getch_impl(PyModuleDef *module);
static PyObject *
msvcrt_getch(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
PyObject *return_value = NULL;
char s[1];
s[0] = msvcrt_getch_impl(module);
return_value = PyBytes_FromStringAndSize(s, 1);
return return_value;
}
#if defined(_WCONIO_DEFINED)
PyDoc_STRVAR(msvcrt_getwch__doc__,
"getwch($module, /)\n"
"--\n"
"\n"
"Wide char variant of getch(), returning a Unicode value.");
#define MSVCRT_GETWCH_METHODDEF \
{"getwch", (PyCFunction)msvcrt_getwch, METH_NOARGS, msvcrt_getwch__doc__},
static wchar_t
msvcrt_getwch_impl(PyModuleDef *module);
static PyObject *
msvcrt_getwch(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
PyObject *return_value = NULL;
wchar_t _return_value;
_return_value = msvcrt_getwch_impl(module);
return_value = PyUnicode_FromOrdinal(_return_value);
return return_value;
}
#endif /* defined(_WCONIO_DEFINED) */
PyDoc_STRVAR(msvcrt_getche__doc__,
"getche($module, /)\n"
"--\n"
"\n"
"Similar to getch(), but the keypress will be echoed if possible.");
#define MSVCRT_GETCHE_METHODDEF \
{"getche", (PyCFunction)msvcrt_getche, METH_NOARGS, msvcrt_getche__doc__},
static int
msvcrt_getche_impl(PyModuleDef *module);
static PyObject *
msvcrt_getche(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
PyObject *return_value = NULL;
char s[1];
s[0] = msvcrt_getche_impl(module);
return_value = PyBytes_FromStringAndSize(s, 1);
return return_value;
}
#if defined(_WCONIO_DEFINED)
PyDoc_STRVAR(msvcrt_getwche__doc__,
"getwche($module, /)\n"
"--\n"
"\n"
"Wide char variant of getche(), returning a Unicode value.");
#define MSVCRT_GETWCHE_METHODDEF \
{"getwche", (PyCFunction)msvcrt_getwche, METH_NOARGS, msvcrt_getwche__doc__},
static wchar_t
msvcrt_getwche_impl(PyModuleDef *module);
static PyObject *
msvcrt_getwche(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
{
PyObject *return_value = NULL;
wchar_t _return_value;
_return_value = msvcrt_getwche_impl(module);
return_value = PyUnicode_FromOrdinal(_return_value);
return return_value;
}
#endif /* defined(_WCONIO_DEFINED) */
PyDoc_STRVAR(msvcrt_putch__doc__,
"putch($module, char, /)\n"
"--\n"
"\n"
"Print the byte string char to the console without buffering.");
#define MSVCRT_PUTCH_METHODDEF \
{"putch", (PyCFunction)msvcrt_putch, METH_O, msvcrt_putch__doc__},
static PyObject *
msvcrt_putch_impl(PyModuleDef *module, char char_value);
static PyObject *
msvcrt_putch(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
char char_value;
if (!PyArg_Parse(arg,
"c:putch",
&char_value))
goto exit;
return_value = msvcrt_putch_impl(module, char_value);
exit:
return return_value;
}
#if defined(_WCONIO_DEFINED)
PyDoc_STRVAR(msvcrt_putwch__doc__,
"putwch($module, unicode_char, /)\n"
"--\n"
"\n"
"Wide char variant of putch(), accepting a Unicode value.");
#define MSVCRT_PUTWCH_METHODDEF \
{"putwch", (PyCFunction)msvcrt_putwch, METH_O, msvcrt_putwch__doc__},
static PyObject *
msvcrt_putwch_impl(PyModuleDef *module, int unicode_char);
static PyObject *
msvcrt_putwch(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
int unicode_char;
if (!PyArg_Parse(arg,
"C:putwch",
&unicode_char))
goto exit;
return_value = msvcrt_putwch_impl(module, unicode_char);
exit:
return return_value;
}
#endif /* defined(_WCONIO_DEFINED) */
PyDoc_STRVAR(msvcrt_ungetch__doc__,
"ungetch($module, char, /)\n"
"--\n"
"\n"
"Opposite of getch.\n"
"\n"
"Cause the byte string char to be \"pushed back\" into the\n"
"console buffer; it will be the next character read by\n"
"getch() or getche().");
#define MSVCRT_UNGETCH_METHODDEF \
{"ungetch", (PyCFunction)msvcrt_ungetch, METH_O, msvcrt_ungetch__doc__},
static PyObject *
msvcrt_ungetch_impl(PyModuleDef *module, char char_value);
static PyObject *
msvcrt_ungetch(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
char char_value;
if (!PyArg_Parse(arg,
"c:ungetch",
&char_value))
goto exit;
return_value = msvcrt_ungetch_impl(module, char_value);
exit:
return return_value;
}
#if defined(_WCONIO_DEFINED)
PyDoc_STRVAR(msvcrt_ungetwch__doc__,
"ungetwch($module, unicode_char, /)\n"
"--\n"
"\n"
"Wide char variant of ungetch(), accepting a Unicode value.");
#define MSVCRT_UNGETWCH_METHODDEF \
{"ungetwch", (PyCFunction)msvcrt_ungetwch, METH_O, msvcrt_ungetwch__doc__},
static PyObject *
msvcrt_ungetwch_impl(PyModuleDef *module, int unicode_char);
static PyObject *
msvcrt_ungetwch(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
int unicode_char;
if (!PyArg_Parse(arg,
"C:ungetwch",
&unicode_char))
goto exit;
return_value = msvcrt_ungetwch_impl(module, unicode_char);
exit:
return return_value;
}
#endif /* defined(_WCONIO_DEFINED) */
#if defined(_DEBUG)
PyDoc_STRVAR(msvcrt_CrtSetReportFile__doc__,
"CrtSetReportFile($module, type, file, /)\n"
"--\n"
"\n"
"Wrapper around _CrtSetReportFile.\n"
"\n"
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTFILE_METHODDEF \
{"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_VARARGS, msvcrt_CrtSetReportFile__doc__},
static long
msvcrt_CrtSetReportFile_impl(PyModuleDef *module, int type, int file);
static PyObject *
msvcrt_CrtSetReportFile(PyModuleDef *module, PyObject *args)
{
PyObject *return_value = NULL;
int type;
int file;
long _return_value;
if (!PyArg_ParseTuple(args,
"ii:CrtSetReportFile",
&type, &file))
goto exit;
_return_value = msvcrt_CrtSetReportFile_impl(module, type, file);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
#endif /* defined(_DEBUG) */
#if defined(_DEBUG)
PyDoc_STRVAR(msvcrt_CrtSetReportMode__doc__,
"CrtSetReportMode($module, type, mode, /)\n"
"--\n"
"\n"
"Wrapper around _CrtSetReportMode.\n"
"\n"
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTMODE_METHODDEF \
{"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_VARARGS, msvcrt_CrtSetReportMode__doc__},
static long
msvcrt_CrtSetReportMode_impl(PyModuleDef *module, int type, int mode);
static PyObject *
msvcrt_CrtSetReportMode(PyModuleDef *module, PyObject *args)
{
PyObject *return_value = NULL;
int type;
int mode;
long _return_value;
if (!PyArg_ParseTuple(args,
"ii:CrtSetReportMode",
&type, &mode))
goto exit;
_return_value = msvcrt_CrtSetReportMode_impl(module, type, mode);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
#endif /* defined(_DEBUG) */
#if defined(_DEBUG)
PyDoc_STRVAR(msvcrt_set_error_mode__doc__,
"set_error_mode($module, mode, /)\n"
"--\n"
"\n"
"Wrapper around _set_error_mode.\n"
"\n"
"Only available on Debug builds.");
#define MSVCRT_SET_ERROR_MODE_METHODDEF \
{"set_error_mode", (PyCFunction)msvcrt_set_error_mode, METH_O, msvcrt_set_error_mode__doc__},
static long
msvcrt_set_error_mode_impl(PyModuleDef *module, int mode);
static PyObject *
msvcrt_set_error_mode(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
int mode;
long _return_value;
if (!PyArg_Parse(arg,
"i:set_error_mode",
&mode))
goto exit;
_return_value = msvcrt_set_error_mode_impl(module, mode);
if ((_return_value == -1) && PyErr_Occurred())
goto exit;
return_value = PyLong_FromLong(_return_value);
exit:
return return_value;
}
#endif /* defined(_DEBUG) */
PyDoc_STRVAR(msvcrt_SetErrorMode__doc__,
"SetErrorMode($module, mode, /)\n"
"--\n"
"\n"
"Wrapper around SetErrorMode.");
#define MSVCRT_SETERRORMODE_METHODDEF \
{"SetErrorMode", (PyCFunction)msvcrt_SetErrorMode, METH_O, msvcrt_SetErrorMode__doc__},
static PyObject *
msvcrt_SetErrorMode_impl(PyModuleDef *module, unsigned int mode);
static PyObject *
msvcrt_SetErrorMode(PyModuleDef *module, PyObject *arg)
{
PyObject *return_value = NULL;
unsigned int mode;
if (!PyArg_Parse(arg,
"I:SetErrorMode",
&mode))
goto exit;
return_value = msvcrt_SetErrorMode_impl(module, mode);
exit:
return return_value;
}
#ifndef MSVCRT_GETWCH_METHODDEF
#define MSVCRT_GETWCH_METHODDEF
#endif /* !defined(MSVCRT_GETWCH_METHODDEF) */
#ifndef MSVCRT_GETWCHE_METHODDEF
#define MSVCRT_GETWCHE_METHODDEF
#endif /* !defined(MSVCRT_GETWCHE_METHODDEF) */
#ifndef MSVCRT_PUTWCH_METHODDEF
#define MSVCRT_PUTWCH_METHODDEF
#endif /* !defined(MSVCRT_PUTWCH_METHODDEF) */
#ifndef MSVCRT_UNGETWCH_METHODDEF
#define MSVCRT_UNGETWCH_METHODDEF
#endif /* !defined(MSVCRT_UNGETWCH_METHODDEF) */
#ifndef MSVCRT_CRTSETREPORTFILE_METHODDEF
#define MSVCRT_CRTSETREPORTFILE_METHODDEF
#endif /* !defined(MSVCRT_CRTSETREPORTFILE_METHODDEF) */
#ifndef MSVCRT_CRTSETREPORTMODE_METHODDEF
#define MSVCRT_CRTSETREPORTMODE_METHODDEF
#endif /* !defined(MSVCRT_CRTSETREPORTMODE_METHODDEF) */
#ifndef MSVCRT_SET_ERROR_MODE_METHODDEF
#define MSVCRT_SET_ERROR_MODE_METHODDEF
#endif /* !defined(MSVCRT_SET_ERROR_MODE_METHODDEF) */
/*[clinic end generated code: output=41dfb6ca722afa4f input=a9049054013a1b77]*/

View File

@ -32,423 +32,458 @@
#endif
#endif
// Force the malloc heap to clean itself up, and free unused blocks
// back to the OS. (According to the docs, only works on NT.)
static PyObject *
msvcrt_heapmin(PyObject *self, PyObject *args)
{
if (!PyArg_ParseTuple(args, ":heapmin"))
return NULL;
/*[python input]
class Py_intptr_t_converter(CConverter):
type = 'Py_intptr_t'
format_unit = '"_Py_PARSE_INTPTR"'
class handle_return_converter(long_return_converter):
type = 'Py_intptr_t'
cast = '(void *)'
conversion_fn = 'PyLong_FromVoidPtr'
class byte_char_return_converter(CReturnConverter):
type = 'int'
def render(self, function, data):
data.declarations.append('char s[1];')
data.return_value = 's[0]'
data.return_conversion.append(
'return_value = PyBytes_FromStringAndSize(s, 1);\n')
class wchar_t_return_converter(CReturnConverter):
type = 'wchar_t'
def render(self, function, data):
self.declare(data)
data.return_conversion.append(
'return_value = PyUnicode_FromOrdinal(_return_value);\n')
[python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=6a54fc4e73d0b367]*/
/*[clinic input]
module msvcrt
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=f31a87a783d036cd]*/
#include "clinic/msvcrtmodule.c.h"
/*[clinic input]
msvcrt.heapmin
Minimize the malloc() heap.
Force the malloc() heap to clean itself up and return unused blocks
to the operating system. On failure, this raises OSError.
[clinic start generated code]*/
static PyObject *
msvcrt_heapmin_impl(PyModuleDef *module)
/*[clinic end generated code: output=464f866feb57c436 input=82e1771d21bde2d8]*/
{
if (_heapmin() != 0)
return PyErr_SetFromErrno(PyExc_IOError);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
/*[clinic input]
msvcrt.locking
PyDoc_STRVAR(heapmin_doc,
"heapmin() -> None\n\
\n\
Force the malloc() heap to clean itself up and return unused blocks\n\
to the operating system. On failure, this raises IOError.");
fd: int
mode: int
nbytes: long
/
Lock part of a file based on file descriptor fd from the C runtime.
Raises IOError on failure. The locked region of the file extends from
the current file position for nbytes bytes, and may continue beyond
the end of the file. mode must be one of the LK_* constants listed
below. Multiple regions in a file may be locked at the same time, but
may not overlap. Adjacent regions are not merged; they must be unlocked
individually.
[clinic start generated code]*/
// Perform locking operations on a C runtime file descriptor.
static PyObject *
msvcrt_locking(PyObject *self, PyObject *args)
msvcrt_locking_impl(PyModuleDef *module, int fd, int mode, long nbytes)
/*[clinic end generated code: output=dff41e5e76d544de input=d9f13f0f6a713ba7]*/
{
int fd;
int mode;
long nbytes;
int err;
if (!PyArg_ParseTuple(args, "iil:locking", &fd, &mode, &nbytes))
return NULL;
Py_BEGIN_ALLOW_THREADS
err = _locking(fd, mode, nbytes);
Py_END_ALLOW_THREADS
if (err != 0)
return PyErr_SetFromErrno(PyExc_IOError);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
PyDoc_STRVAR(locking_doc,
"locking(fd, mode, nbytes) -> None\n\
\n\
Lock part of a file based on file descriptor fd from the C runtime.\n\
Raises IOError on failure. The locked region of the file extends from\n\
the current file position for nbytes bytes, and may continue beyond\n\
the end of the file. mode must be one of the LK_* constants listed\n\
below. Multiple regions in a file may be locked at the same time, but\n\
may not overlap. Adjacent regions are not merged; they must be unlocked\n\
individually.");
/*[clinic input]
msvcrt.setmode -> long
// Set the file translation mode for a C runtime file descriptor.
static PyObject *
msvcrt_setmode(PyObject *self, PyObject *args)
fd: int
mode as flags: int
/
Set the line-end translation mode for the file descriptor fd.
To set it to text mode, flags should be os.O_TEXT; for binary, it
should be os.O_BINARY.
Return value is the previous mode.
[clinic start generated code]*/
static long
msvcrt_setmode_impl(PyModuleDef *module, int fd, int flags)
/*[clinic end generated code: output=8c84e5b37c586d0d input=76e7c01f6b137f75]*/
{
int fd;
int flags;
if (!PyArg_ParseTuple(args,"ii:setmode", &fd, &flags))
return NULL;
flags = _setmode(fd, flags);
if (flags == -1)
return PyErr_SetFromErrno(PyExc_IOError);
PyErr_SetFromErrno(PyExc_IOError);
return PyLong_FromLong(flags);
return flags;
}
PyDoc_STRVAR(setmode_doc,
"setmode(fd, mode) -> Previous mode\n\
\n\
Set the line-end translation mode for the file descriptor fd. To set\n\
it to text mode, flags should be os.O_TEXT; for binary, it should be\n\
os.O_BINARY.");
/*[clinic input]
msvcrt.open_osfhandle -> long
// Convert an OS file handle to a C runtime file descriptor.
static PyObject *
msvcrt_open_osfhandle(PyObject *self, PyObject *args)
handle: Py_intptr_t
flags: int
/
Create a C runtime file descriptor from the file handle handle.
The flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,
and os.O_TEXT. The returned file descriptor may be used as a parameter
to os.fdopen() to create a file object.
[clinic start generated code]*/
static long
msvcrt_open_osfhandle_impl(PyModuleDef *module, Py_intptr_t handle, int flags)
/*[clinic end generated code: output=8cda35b8e4ea4178 input=4d8516ed32db8f65]*/
{
Py_intptr_t handle;
int flags;
int fd;
if (!PyArg_ParseTuple(args, _Py_PARSE_INTPTR "i:open_osfhandle",
&handle, &flags))
return NULL;
fd = _open_osfhandle(handle, flags);
if (fd == -1)
return PyErr_SetFromErrno(PyExc_IOError);
PyErr_SetFromErrno(PyExc_IOError);
return PyLong_FromLong(fd);
return fd;
}
PyDoc_STRVAR(open_osfhandle_doc,
"open_osfhandle(handle, flags) -> file descriptor\n\
\n\
Create a C runtime file descriptor from the file handle handle. The\n\
flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,\n\
and os.O_TEXT. The returned file descriptor may be used as a parameter\n\
to os.fdopen() to create a file object.");
/*[clinic input]
msvcrt.get_osfhandle -> handle
// Convert a C runtime file descriptor to an OS file handle.
static PyObject *
msvcrt_get_osfhandle(PyObject *self, PyObject *args)
fd: int
/
Return the file handle for the file descriptor fd.
Raises IOError if fd is not recognized.
[clinic start generated code]*/
static Py_intptr_t
msvcrt_get_osfhandle_impl(PyModuleDef *module, int fd)
/*[clinic end generated code: output=376bff52586b55a6 input=c7d18d02c8017ec1]*/
{
int fd;
Py_intptr_t handle;
if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))
return NULL;
if (!_PyVerify_fd(fd))
return PyErr_SetFromErrno(PyExc_IOError);
Py_intptr_t handle = -1;
if (!_PyVerify_fd(fd)) {
PyErr_SetFromErrno(PyExc_IOError);
}
else {
_Py_BEGIN_SUPPRESS_IPH
handle = _get_osfhandle(fd);
handle = _get_osfhandle(fd);
_Py_END_SUPPRESS_IPH
if (handle == -1)
return PyErr_SetFromErrno(PyExc_IOError);
if (handle == -1)
PyErr_SetFromErrno(PyExc_IOError);
}
/* technically 'handle' is not a pointer, but a integer as
large as a pointer, Python's *VoidPtr interface is the
most appropriate here */
return PyLong_FromVoidPtr((void*)handle);
return handle;
}
PyDoc_STRVAR(get_osfhandle_doc,
"get_osfhandle(fd) -> file handle\n\
\n\
Return the file handle for the file descriptor fd. Raises IOError\n\
if fd is not recognized.");
/* Console I/O */
/*[clinic input]
msvcrt.kbhit -> long
static PyObject *
msvcrt_kbhit(PyObject *self, PyObject *args)
Return true if a keypress is waiting to be read.
[clinic start generated code]*/
static long
msvcrt_kbhit_impl(PyModuleDef *module)
/*[clinic end generated code: output=2b7293fcbe5cb24e input=e70d678a5c2f6acc]*/
{
int ok;
if (!PyArg_ParseTuple(args, ":kbhit"))
return NULL;
ok = _kbhit();
return PyLong_FromLong(ok);
return _kbhit();
}
PyDoc_STRVAR(kbhit_doc,
"kbhit() -> bool\n\
\n\
Return true if a keypress is waiting to be read.");
/*[clinic input]
msvcrt.getch -> byte_char
static PyObject *
msvcrt_getch(PyObject *self, PyObject *args)
Read a keypress and return the resulting character as a byte string.
Nothing is echoed to the console. This call will block if a keypress is
not already available, but will not wait for Enter to be pressed. If the
pressed key was a special function key, this will return '\000' or
'\xe0'; the next call will return the keycode. The Control-C keypress
cannot be read with this function.
[clinic start generated code]*/
static int
msvcrt_getch_impl(PyModuleDef *module)
/*[clinic end generated code: output=199e3d89f49c166a input=37a40cf0ed0d1153]*/
{
int ch;
char s[1];
if (!PyArg_ParseTuple(args, ":getch"))
return NULL;
Py_BEGIN_ALLOW_THREADS
ch = _getch();
Py_END_ALLOW_THREADS
s[0] = ch;
return PyBytes_FromStringAndSize(s, 1);
return ch;
}
PyDoc_STRVAR(getch_doc,
"getch() -> key character\n\
\n\
Read a keypress and return the resulting character as a byte string.\n\
Nothing is echoed to the console. This call will block if a keypress is\n\
not already available, but will not wait for Enter to be pressed. If the\n\
pressed key was a special function key, this will return '\\000' or\n\
'\\xe0'; the next call will return the keycode. The Control-C keypress\n\
cannot be read with this function.");
#ifdef _WCONIO_DEFINED
static PyObject *
msvcrt_getwch(PyObject *self, PyObject *args)
/*[clinic input]
msvcrt.getwch -> wchar_t
Wide char variant of getch(), returning a Unicode value.
[clinic start generated code]*/
static wchar_t
msvcrt_getwch_impl(PyModuleDef *module)
/*[clinic end generated code: output=9d3762861328b1fe input=27b3dec8ad823d7c]*/
{
wchar_t ch;
if (!PyArg_ParseTuple(args, ":getwch"))
return NULL;
Py_BEGIN_ALLOW_THREADS
ch = _getwch();
Py_END_ALLOW_THREADS
return PyUnicode_FromOrdinal(ch);
return ch;
}
#endif /* _WCONIO_DEFINED */
PyDoc_STRVAR(getwch_doc,
"getwch() -> Unicode key character\n\
\n\
Wide char variant of getch(), returning a Unicode value.");
#endif
/*[clinic input]
msvcrt.getche -> byte_char
static PyObject *
msvcrt_getche(PyObject *self, PyObject *args)
Similar to getch(), but the keypress will be echoed if possible.
[clinic start generated code]*/
static int
msvcrt_getche_impl(PyModuleDef *module)
/*[clinic end generated code: output=8aa369be6550068e input=43311ade9ed4a9c0]*/
{
int ch;
char s[1];
if (!PyArg_ParseTuple(args, ":getche"))
return NULL;
Py_BEGIN_ALLOW_THREADS
ch = _getche();
Py_END_ALLOW_THREADS
s[0] = ch;
return PyBytes_FromStringAndSize(s, 1);
return ch;
}
PyDoc_STRVAR(getche_doc,
"getche() -> key character\n\
\n\
Similar to getch(), but the keypress will be echoed if it represents\n\
a printable character.");
#ifdef _WCONIO_DEFINED
static PyObject *
msvcrt_getwche(PyObject *self, PyObject *args)
/*[clinic input]
msvcrt.getwche -> wchar_t
Wide char variant of getche(), returning a Unicode value.
[clinic start generated code]*/
static wchar_t
msvcrt_getwche_impl(PyModuleDef *module)
/*[clinic end generated code: output=3693cf78e3ea0cf6 input=49337d59d1a591f8]*/
{
wchar_t ch;
if (!PyArg_ParseTuple(args, ":getwche"))
return NULL;
Py_BEGIN_ALLOW_THREADS
ch = _getwche();
Py_END_ALLOW_THREADS
return PyUnicode_FromOrdinal(ch);
return ch;
}
#endif /* _WCONIO_DEFINED */
PyDoc_STRVAR(getwche_doc,
"getwche() -> Unicode key character\n\
\n\
Wide char variant of getche(), returning a Unicode value.");
#endif
/*[clinic input]
msvcrt.putch
char: char
/
Print the byte string char to the console without buffering.
[clinic start generated code]*/
static PyObject *
msvcrt_putch(PyObject *self, PyObject *args)
msvcrt_putch_impl(PyModuleDef *module, char char_value)
/*[clinic end generated code: output=c05548b11554f36f input=ec078dd10cb054d6]*/
{
char ch;
if (!PyArg_ParseTuple(args, "c:putch", &ch))
return NULL;
_putch(ch);
Py_INCREF(Py_None);
return Py_None;
_putch(char_value);
Py_RETURN_NONE;
}
PyDoc_STRVAR(putch_doc,
"putch(char) -> None\n\
\n\
Print the byte string char to the console without buffering.");
#ifdef _WCONIO_DEFINED
/*[clinic input]
msvcrt.putwch
unicode_char: int(types='str')
/
Wide char variant of putch(), accepting a Unicode value.
[clinic start generated code]*/
static PyObject *
msvcrt_putwch(PyObject *self, PyObject *args)
msvcrt_putwch_impl(PyModuleDef *module, int unicode_char)
/*[clinic end generated code: output=c216a73694ca73dd input=74377c932af728a4]*/
{
int ch;
if (!PyArg_ParseTuple(args, "C:putwch", &ch))
return NULL;
_putwch(ch);
_putwch(unicode_char);
Py_RETURN_NONE;
}
#endif /* _WCONIO_DEFINED */
PyDoc_STRVAR(putwch_doc,
"putwch(unicode_char) -> None\n\
\n\
Wide char variant of putch(), accepting a Unicode value.");
#endif
/*[clinic input]
msvcrt.ungetch
char: char
/
Opposite of getch.
Cause the byte string char to be "pushed back" into the
console buffer; it will be the next character read by
getch() or getche().
[clinic start generated code]*/
static PyObject *
msvcrt_ungetch(PyObject *self, PyObject *args)
msvcrt_ungetch_impl(PyModuleDef *module, char char_value)
/*[clinic end generated code: output=19a4cd3249709ec9 input=22f07ee9001bbf0f]*/
{
char ch;
if (!PyArg_ParseTuple(args, "c:ungetch", &ch))
return NULL;
if (_ungetch(ch) == EOF)
if (_ungetch(char_value) == EOF)
return PyErr_SetFromErrno(PyExc_IOError);
Py_INCREF(Py_None);
return Py_None;
Py_RETURN_NONE;
}
PyDoc_STRVAR(ungetch_doc,
"ungetch(char) -> None\n\
\n\
Cause the byte string char to be \"pushed back\" into the\n\
console buffer; it will be the next character read by\n\
getch() or getche().");
#ifdef _WCONIO_DEFINED
/*[clinic input]
msvcrt.ungetwch
unicode_char: int(types='str')
/
Wide char variant of ungetch(), accepting a Unicode value.
[clinic start generated code]*/
static PyObject *
msvcrt_ungetwch(PyObject *self, PyObject *args)
msvcrt_ungetwch_impl(PyModuleDef *module, int unicode_char)
/*[clinic end generated code: output=1ee7674710322bd1 input=6bcd16276e035902]*/
{
int ch;
if (!PyArg_ParseTuple(args, "C:ungetwch", &ch))
return NULL;
if (_ungetwch(ch) == WEOF)
if (_ungetwch(unicode_char) == WEOF)
return PyErr_SetFromErrno(PyExc_IOError);
Py_INCREF(Py_None);
return Py_None;
}
PyDoc_STRVAR(ungetwch_doc,
"ungetwch(unicode_char) -> None\n\
\n\
Wide char variant of ungetch(), accepting a Unicode value.");
#endif
static void
insertint(PyObject *d, char *name, int value)
{
PyObject *v = PyLong_FromLong((long) value);
if (v == NULL) {
/* Don't bother reporting this error */
PyErr_Clear();
}
else {
PyDict_SetItemString(d, name, v);
Py_DECREF(v);
}
Py_RETURN_NONE;
}
#endif /* _WCONIO_DEFINED */
#ifdef _DEBUG
/*[clinic input]
msvcrt.CrtSetReportFile -> long
static PyObject*
msvcrt_setreportfile(PyObject *self, PyObject *args)
type: int
file: int
/
Wrapper around _CrtSetReportFile.
Only available on Debug builds.
[clinic start generated code]*/
static long
msvcrt_CrtSetReportFile_impl(PyModuleDef *module, int type, int file)
/*[clinic end generated code: output=8c3644fb2edfa808 input=bb8f721a604fcc45]*/
{
int type, file;
_HFILE res;
if (!PyArg_ParseTuple(args, "ii", &type, &file))
return NULL;
res = _CrtSetReportFile(type, (_HFILE)file);
return PyLong_FromLong((long)res);
Py_INCREF(Py_None);
return Py_None;
return (long)_CrtSetReportFile(type, (_HFILE)file);
}
static PyObject*
msvcrt_setreportmode(PyObject *self, PyObject *args)
/*[clinic input]
msvcrt.CrtSetReportMode -> long
type: int
mode: int
/
Wrapper around _CrtSetReportMode.
Only available on Debug builds.
[clinic start generated code]*/
static long
msvcrt_CrtSetReportMode_impl(PyModuleDef *module, int type, int mode)
/*[clinic end generated code: output=b407fbf8716a52b9 input=9319d29b4319426b]*/
{
int type, mode;
int res;
if (!PyArg_ParseTuple(args, "ii", &type, &mode))
return NULL;
res = _CrtSetReportMode(type, mode);
if (res == -1)
return PyErr_SetFromErrno(PyExc_IOError);
return PyLong_FromLong(res);
PyErr_SetFromErrno(PyExc_IOError);
return res;
}
static PyObject*
msvcrt_seterrormode(PyObject *self, PyObject *args)
{
int mode, res;
/*[clinic input]
msvcrt.set_error_mode -> long
if (!PyArg_ParseTuple(args, "i", &mode))
return NULL;
res = _set_error_mode(mode);
return PyLong_FromLong(res);
mode: int
/
Wrapper around _set_error_mode.
Only available on Debug builds.
[clinic start generated code]*/
static long
msvcrt_set_error_mode_impl(PyModuleDef *module, int mode)
/*[clinic end generated code: output=62148adffa90867d input=046fca59c0f20872]*/
{
return _set_error_mode(mode);
}
#endif /* _DEBUG */
#endif
/*[clinic input]
msvcrt.SetErrorMode
static PyObject*
seterrormode(PyObject *self, PyObject *args)
mode: unsigned_int(bitwise=True)
/
Wrapper around SetErrorMode.
[clinic start generated code]*/
static PyObject *
msvcrt_SetErrorMode_impl(PyModuleDef *module, unsigned int mode)
/*[clinic end generated code: output=544c60b085be79c6 input=d8b167258d32d907]*/
{
unsigned int mode, res;
unsigned int res;
if (!PyArg_ParseTuple(args, "I", &mode))
return NULL;
res = SetErrorMode(mode);
return PyLong_FromUnsignedLong(res);
}
/*[clinic input]
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=da39a3ee5e6b4b0d]*/
/* List of functions exported by this module */
static struct PyMethodDef msvcrt_functions[] = {
{"heapmin", msvcrt_heapmin, METH_VARARGS, heapmin_doc},
{"locking", msvcrt_locking, METH_VARARGS, locking_doc},
{"setmode", msvcrt_setmode, METH_VARARGS, setmode_doc},
{"open_osfhandle", msvcrt_open_osfhandle, METH_VARARGS, open_osfhandle_doc},
{"get_osfhandle", msvcrt_get_osfhandle, METH_VARARGS, get_osfhandle_doc},
{"kbhit", msvcrt_kbhit, METH_VARARGS, kbhit_doc},
{"getch", msvcrt_getch, METH_VARARGS, getch_doc},
{"getche", msvcrt_getche, METH_VARARGS, getche_doc},
{"putch", msvcrt_putch, METH_VARARGS, putch_doc},
{"ungetch", msvcrt_ungetch, METH_VARARGS, ungetch_doc},
{"SetErrorMode", seterrormode, METH_VARARGS},
#ifdef _DEBUG
{"CrtSetReportFile", msvcrt_setreportfile, METH_VARARGS},
{"CrtSetReportMode", msvcrt_setreportmode, METH_VARARGS},
{"set_error_mode", msvcrt_seterrormode, METH_VARARGS},
#endif
#ifdef _WCONIO_DEFINED
{"getwch", msvcrt_getwch, METH_VARARGS, getwch_doc},
{"getwche", msvcrt_getwche, METH_VARARGS, getwche_doc},
{"putwch", msvcrt_putwch, METH_VARARGS, putwch_doc},
{"ungetwch", msvcrt_ungetwch, METH_VARARGS, ungetwch_doc},
#endif
MSVCRT_HEAPMIN_METHODDEF
MSVCRT_LOCKING_METHODDEF
MSVCRT_SETMODE_METHODDEF
MSVCRT_OPEN_OSFHANDLE_METHODDEF
MSVCRT_GET_OSFHANDLE_METHODDEF
MSVCRT_KBHIT_METHODDEF
MSVCRT_GETCH_METHODDEF
MSVCRT_GETCHE_METHODDEF
MSVCRT_PUTCH_METHODDEF
MSVCRT_UNGETCH_METHODDEF
MSVCRT_SETERRORMODE_METHODDEF
MSVCRT_CRTSETREPORTFILE_METHODDEF
MSVCRT_CRTSETREPORTMODE_METHODDEF
MSVCRT_SET_ERROR_MODE_METHODDEF
MSVCRT_GETWCH_METHODDEF
MSVCRT_GETWCHE_METHODDEF
MSVCRT_PUTWCH_METHODDEF
MSVCRT_UNGETWCH_METHODDEF
{NULL, NULL}
};
@ -465,6 +500,20 @@ static struct PyModuleDef msvcrtmodule = {
NULL
};
static void
insertint(PyObject *d, char *name, int value)
{
PyObject *v = PyLong_FromLong((long) value);
if (v == NULL) {
/* Don't bother reporting this error */
PyErr_Clear();
}
else {
PyDict_SetItemString(d, name, v);
Py_DECREF(v);
}
}
PyMODINIT_FUNC
PyInit_msvcrt(void)
{