Made it real. Changed locking() to work with file descriptors instead

of Python file objects.  Added open_osfhandle() (Mark had done some
work for that), get_osfhandle(), setmode(), and the console I/O
functions kbhit(), getch(), getche(), ungetch(), and putch().

diff --git a/PC/msvcrtmodule.c b/PC/msvcrtmodule.c
index dec628516acf7ddb708c9128351e006ef15bb7d1..3c19ce77678362e5a68bc5fa325025d265191ac4 100755 (executable)
--- a/PC/msvcrtmodule.c
+++ b/PC/msvcrtmodule.c
@@ -9,82 +9,172 @@
        Only ever compiled with an MS compiler, so no attempt
        has been made to avoid MS language extensions, etc...
 
+       This may only work on NT or 95...
+
+       Author: Mark Hammond and Guido van Rossum.
+       Maintenance: Guido van Rossum.
+
 ***********************************************************/
+
 #include "Python.h"
 #include "malloc.h"
-// Perform locking operations on a file.
-static PyObject *msvcrt_locking(PyObject *self, PyObject *args)
+
+// 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)
 {
-       int mode;
-       long nBytes;
-       PyObject *obFile;
-       FILE *pFile;
-       if (!PyArg_ParseTuple(args,"O!il:locking", &obFile, PyFile_Type, &mode, &nBytes))
+       if (!PyArg_ParseTuple(args, ":heapmin"))
                return NULL;
-       if (NULL==(pFile = PyFile_AsFile(obFile)))
-               return NULL;
-       if (0 != _locking(_fileno(pFile), mode, nBytes))
+
+       if (_heapmin() != 0)
                return PyErr_SetFromErrno(PyExc_IOError);
+
        Py_INCREF(Py_None);
        return Py_None;
 }
 
-// Forces the malloc heap to clean itself up, and free unused blocks
-// back to the OS.
-static PyObject *msvcrt_heapmin(PyObject *self, PyObject *args)
+// Perform locking operations on a C runtime file descriptor.
+static PyObject *msvcrt_locking(PyObject *self, PyObject *args)
 {
-       if (!PyArg_ParseTuple(args,":heapmin"))
+       int fd;
+       int mode;
+       long nbytes;
+
+       if (!PyArg_ParseTuple(args, "iil:locking", &fd, &mode, &nbytes))
                return NULL;
-       if (_heapmin()!=0)
-               return PyErr_SetFromErrno(PyExc_MemoryError); // Is this the correct error???
+
+       if (_locking(fd, mode, nbytes) != 0)
+               return PyErr_SetFromErrno(PyExc_IOError);
+
        Py_INCREF(Py_None);
        return Py_None;
 }
 
-/*******
-Left this out for now...
+// 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;
 
-// Convert an OS file handle to a Python file object (yay!).
-// This may only work on NT
+       flags = _setmode(fd, flags);
+       if (flags == -1)
+               return PyErr_SetFromErrno(PyExc_IOError);
+
+       return PyInt_FromLong(flags);
+}
+
+// Convert an OS file handle to a C runtime file descriptor.
 static PyObject *msvcrt_open_osfhandle(PyObject *self, PyObject *args)
 {
-       // Note that we get the underlying handle using the long
-       // "abstract" interface.  This will allow either a native integer
-       // or else a Win32 extension PyHANDLE object, which implements an 
-       // int() converter.
-       PyObject *obHandle;
-       PyObject *obInt;
+       long handle;
        int flags;
+       int fd;
+
+       if (!PyArg_ParseTuple(args, "li:open_osfhandle", &handle, &flags))
+               return PyErr_SetFromErrno(PyExc_IOError);
+
+       fd = _open_osfhandle(handle, flags);
+       if (fd == -1)
+               return PyErr_SetFromErrno(PyExc_IOError);
+
+       return PyInt_FromLong(fd);
+}
+
+// Convert a C runtime file descriptor to an OS file handle.
+static PyObject *msvcrt_get_osfhandle(PyObject *self, PyObject *args)
+{
+       int fd;
        long handle;
-       if (!PyArg_ParseTuple(args,"Oi:open_osfhandle", &obHandle, &flags))
-               return NULL;
 
-       if (NULL==(obInt = PyNumber_Int(obHandle))) {
-               PyErr_Clear();
-               PyErr_SetString(PyExc_TypeError, "The handle param must be an integer, =
-or an object able to be converted to an integer");
+       if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))
                return NULL;
-       }
-       handle = PyInt_AsLong(obInt);
-       Py_DECREF(obInt);
-       rtHandle = _open_osfhandle(handle, flags);
-       if (rtHandle==-1)
+
+       handle = _get_osfhandle(fd);
+       if (handle == -1)
                return PyErr_SetFromErrno(PyExc_IOError);
 
-  what mode?  Should I just return here, and expose _fdopen 
-  and setvbuf?
+       return PyInt_FromLong(handle);
+}
+
+/* Console I/O */
+#include <conio.h>
+
+static PyObject *msvcrt_kbhit(PyObject *self, PyObject *args)
+{
+       int ok;
+
+       if (!PyArg_ParseTuple(args, ":kbhit"))
+               return NULL;
+
+       ok = _kbhit();
+       return PyInt_FromLong(ok);
+}
+
+static PyObject *msvcrt_getch(PyObject *self, PyObject *args)
+{
+       int ch;
+       char s[1];
+
+       if (!PyArg_ParseTuple(args, ":getch"))
+               return NULL;
+
+       ch = _getch();
+       s[0] = ch;
+       return PyString_FromStringAndSize(s, 1);
+}
+
+static PyObject *msvcrt_getche(PyObject *self, PyObject *args)
+{
+       int ch;
+       char s[1];
+
+       if (!PyArg_ParseTuple(args, ":getche"))
+               return NULL;
 
-       f1=_fdopen(fd1, "w");
-       setvbuf(f1, NULL, _IONBF, 0);
-       f=PyFile_FromFile(f1, cmdstring, "w", fclose);
+       ch = _getche();
+       s[0] = ch;
+       return PyString_FromStringAndSize(s, 1);
+}
 
+static PyObject *msvcrt_putch(PyObject *self, PyObject *args)
+{
+       char ch;
+
+       if (!PyArg_ParseTuple(args, "c:putch", &ch))
+               return NULL;
+
+       _putch(ch);
+       Py_INCREF(Py_None);
+       return Py_None;
 }
-*****/
+
+static PyObject *msvcrt_ungetch(PyObject *self, PyObject *args)
+{
+       char ch;
+
+       if (!PyArg_ParseTuple(args, "c:ungetch", &ch))
+               return NULL;
+
+       _ungetch(ch);
+       Py_INCREF(Py_None);
+       return Py_None;
+}
+
 
 /* List of functions exported by this module */
 static struct PyMethodDef msvcrt_functions[] = {
+       {"heapmin",             msvcrt_heapmin, 1},
        {"locking",             msvcrt_locking, 1},
-       {"heapmin",                             msvcrt_heapmin, 1},
+       {"setmode",             msvcrt_setmode, 1},
+       {"open_osfhandle",      msvcrt_open_osfhandle, 1},
+       {"get_osfhandle",       msvcrt_get_osfhandle, 1},
+       {"kbhit",               msvcrt_kbhit, 1},
+       {"getch",               msvcrt_getch, 1},
+       {"getche",              msvcrt_getche, 1},
+       {"putch",               msvcrt_putch, 1},
+       {"ungetch",             msvcrt_ungetch, 1},
        {NULL,                  NULL}
 };