summaryrefslogtreecommitdiffstats
path: root/PC
diff options
context:
space:
mode:
Diffstat (limited to 'PC')
-rw-r--r--PC/clinic/msvcrtmodule.c.h604
-rw-r--r--PC/msvcrtmodule.c607
2 files changed, 932 insertions, 279 deletions
diff --git a/PC/clinic/msvcrtmodule.c.h b/PC/clinic/msvcrtmodule.c.h
new file mode 100644
index 0000000..de6fa29
--- /dev/null
+++ b/PC/clinic/msvcrtmodule.c.h
@@ -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]*/
diff --git a/PC/msvcrtmodule.c b/PC/msvcrtmodule.c
index c8345c5..0779ac7 100644
--- a/PC/msvcrtmodule.c
+++ b/PC/msvcrtmodule.c
@@ -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.)
+/*[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(PyObject *self, PyObject *args)
+msvcrt_heapmin_impl(PyModuleDef *module)
+/*[clinic end generated code: output=464f866feb57c436 input=82e1771d21bde2d8]*/
{
- if (!PyArg_ParseTuple(args, ":heapmin"))
- return NULL;
-
if (_heapmin() != 0)
return PyErr_SetFromErrno(PyExc_IOError);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_RETURN_NONE;
}
+/*[clinic input]
+msvcrt.locking
+
+ fd: int
+ mode: int
+ nbytes: long
+ /
-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.");
+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.");
-
-// Set the file translation mode for a C runtime file descriptor.
-static PyObject *
-msvcrt_setmode(PyObject *self, PyObject *args)
-{
- int fd;
- int flags;
- if (!PyArg_ParseTuple(args,"ii:setmode", &fd, &flags))
- return NULL;
+/*[clinic input]
+msvcrt.setmode -> long
+
+ 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]*/
+{
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)
-{
- int fd;
- Py_intptr_t handle;
+ fd: int
+ /
- if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))
- return NULL;
+Return the file handle for the file descriptor fd.
- if (!_PyVerify_fd(fd))
- return PyErr_SetFromErrno(PyExc_IOError);
+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]*/
+{
+ 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;
+ return _kbhit();
+}
- if (!PyArg_ParseTuple(args, ":kbhit"))
- return NULL;
+/*[clinic input]
+msvcrt.getch -> byte_char
- ok = _kbhit();
- return PyLong_FromLong(ok);
-}
+Read a keypress and return the resulting character as a byte string.
-PyDoc_STRVAR(kbhit_doc,
-"kbhit() -> bool\n\
-\n\
-Return true if a keypress is waiting to be read.");
+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 PyObject *
-msvcrt_getch(PyObject *self, PyObject *args)
+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;
+ _putch(char_value);
+ Py_RETURN_NONE;
+}
- if (!PyArg_ParseTuple(args, "c:putch", &ch))
- return NULL;
+#ifdef _WCONIO_DEFINED
+/*[clinic input]
+msvcrt.putwch
- _putch(ch);
- Py_INCREF(Py_None);
- return Py_None;
-}
+ unicode_char: int(types='str')
+ /
-PyDoc_STRVAR(putch_doc,
-"putch(char) -> None\n\
-\n\
-Print the byte string char to the console without buffering.");
+Wide char variant of putch(), accepting a Unicode value.
+[clinic start generated code]*/
-#ifdef _WCONIO_DEFINED
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
-static PyObject *
-msvcrt_ungetch(PyObject *self, PyObject *args)
-{
- char ch;
+ char: char
+ /
- if (!PyArg_ParseTuple(args, "c:ungetch", &ch))
- return NULL;
+Opposite of getch.
- if (_ungetch(ch) == EOF)
+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_impl(PyModuleDef *module, char char_value)
+/*[clinic end generated code: output=19a4cd3249709ec9 input=22f07ee9001bbf0f]*/
+{
+ 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
-static PyObject *
-msvcrt_ungetwch(PyObject *self, PyObject *args)
-{
- int ch;
+/*[clinic input]
+msvcrt.ungetwch
- if (!PyArg_ParseTuple(args, "C:ungetwch", &ch))
- return NULL;
+ unicode_char: int(types='str')
+ /
+
+Wide char variant of ungetch(), accepting a Unicode value.
+[clinic start generated code]*/
- if (_ungetwch(ch) == WEOF)
+static PyObject *
+msvcrt_ungetwch_impl(PyModuleDef *module, int unicode_char)
+/*[clinic end generated code: output=1ee7674710322bd1 input=6bcd16276e035902]*/
+{
+ if (_ungetwch(unicode_char) == WEOF)
return PyErr_SetFromErrno(PyExc_IOError);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_RETURN_NONE;
}
+#endif /* _WCONIO_DEFINED */
-PyDoc_STRVAR(ungetwch_doc,
-"ungetwch(unicode_char) -> None\n\
-\n\
-Wide char variant of ungetch(), accepting a Unicode value.");
-#endif
+#ifdef _DEBUG
+/*[clinic input]
+msvcrt.CrtSetReportFile -> long
-static void
-insertint(PyObject *d, char *name, int value)
+ 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]*/
{
- 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);
- }
+ return (long)_CrtSetReportFile(type, (_HFILE)file);
}
-#ifdef _DEBUG
+/*[clinic input]
+msvcrt.CrtSetReportMode -> long
-static PyObject*
-msvcrt_setreportfile(PyObject *self, PyObject *args)
-{
- int type, file;
- _HFILE res;
+ type: int
+ mode: int
+ /
- 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;
-}
+Wrapper around _CrtSetReportMode.
+
+Only available on Debug builds.
+[clinic start generated code]*/
-static PyObject*
-msvcrt_setreportmode(PyObject *self, PyObject *args)
+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
+
+ mode: unsigned_int(bitwise=True)
+ /
-static PyObject*
-seterrormode(PyObject *self, PyObject *args)
+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)
{
generated by cgit v0.12 at 2024-11-28 18:21:12 (GMT)