PC/msvcrtmodule.c

   1 /*********************************************************
   2
   3         msvcrtmodule.c
   4
   5         A Python interface to the Microsoft Visual C Runtime
   6         Library, providing access to those non-portable, but
   7         still useful routines.
   8
   9         Only ever compiled with an MS compiler, so no attempt
  10         has been made to avoid MS language extensions, etc...
  11
  12         This may only work on NT or 95...
  13
  14         Author: Mark Hammond and Guido van Rossum.
  15         Maintenance: Guido van Rossum.
  16
  17 ***********************************************************/
  18
  19 #include "Python.h"
  20 #include "malloc.h"
  21 #include <io.h>
  22 #include <conio.h>
  23 #include <sys/locking.h>
  24
  25 // Force the malloc heap to clean itself up, and free unused blocks
  26 // back to the OS.  (According to the docs, only works on NT.)
  27 static PyObject *
  28 msvcrt_heapmin(PyObject *self, PyObject *args)
  29 {
  30         if (!PyArg_ParseTuple(args, ":heapmin"))
  31                 return NULL;
  32
  33         if (_heapmin() != 0)
  34                 return PyErr_SetFromErrno(PyExc_IOError);
  35
  36         Py_INCREF(Py_None);
  37         return Py_None;
  38 }
  39
  40 // Perform locking operations on a C runtime file descriptor.
  41 static PyObject *
  42 msvcrt_locking(PyObject *self, PyObject *args)
  43 {
  44         int fd;
  45         int mode;
  46         long nbytes;
  47         int err;
  48
  49         if (!PyArg_ParseTuple(args, "iil:locking", &fd, &mode, &nbytes))
  50                 return NULL;
  51
  52         Py_BEGIN_ALLOW_THREADS
  53         err = _locking(fd, mode, nbytes);
  54         Py_END_ALLOW_THREADS
  55         if (err != 0)
  56                 return PyErr_SetFromErrno(PyExc_IOError);
  57
  58         Py_INCREF(Py_None);
  59         return Py_None;
  60 }
  61
  62 // Set the file translation mode for a C runtime file descriptor.
  63 static PyObject *
  64 msvcrt_setmode(PyObject *self, PyObject *args)
  65 {
  66         int fd;
  67         int flags;
  68         if (!PyArg_ParseTuple(args,"ii:setmode", &fd, &flags))
  69                 return NULL;
  70
  71         flags = _setmode(fd, flags);
  72         if (flags == -1)
  73                 return PyErr_SetFromErrno(PyExc_IOError);
  74
  75         return PyInt_FromLong(flags);
  76 }
  77
  78 // Convert an OS file handle to a C runtime file descriptor.
  79 static PyObject *
  80 msvcrt_open_osfhandle(PyObject *self, PyObject *args)
  81 {
  82         long handle;
  83         int flags;
  84         int fd;
  85
  86         if (!PyArg_ParseTuple(args, "li:open_osfhandle", &handle, &flags))
  87                 return NULL;
  88
  89         fd = _open_osfhandle(handle, flags);
  90         if (fd == -1)
  91                 return PyErr_SetFromErrno(PyExc_IOError);
  92
  93         return PyInt_FromLong(fd);
  94 }
  95
  96 // Convert a C runtime file descriptor to an OS file handle.
  97 static PyObject *
  98 msvcrt_get_osfhandle(PyObject *self, PyObject *args)
  99 {
 100         int fd;
 101         Py_intptr_t handle;
 102
 103         if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))
 104                 return NULL;
 105
 106         handle = _get_osfhandle(fd);
 107         if (handle == -1)
 108                 return PyErr_SetFromErrno(PyExc_IOError);
 109
 110         /* technically 'handle' is not a pointer, but a integer as
 111            large as a pointer, Python's *VoidPtr interface is the
 112            most appropriate here */
 113         return PyLong_FromVoidPtr((void*)handle);
 114 }
 115
 116 /* Console I/O */
 117
 118 static PyObject *
 119 msvcrt_kbhit(PyObject *self, PyObject *args)
 120 {
 121         int ok;
 122
 123         if (!PyArg_ParseTuple(args, ":kbhit"))
 124                 return NULL;
 125
 126         ok = _kbhit();
 127         return PyInt_FromLong(ok);
 128 }
 129
 130 static PyObject *
 131 msvcrt_getch(PyObject *self, PyObject *args)
 132 {
 133         int ch;
 134         char s[1];
 135
 136         if (!PyArg_ParseTuple(args, ":getch"))
 137                 return NULL;
 138
 139         Py_BEGIN_ALLOW_THREADS
 140         ch = _getch();
 141         Py_END_ALLOW_THREADS
 142         s[0] = ch;
 143         return PyString_FromStringAndSize(s, 1);
 144 }
 145
 146 #ifdef _WCONIO_DEFINED
 147 static PyObject *
 148 msvcrt_getwch(PyObject *self, PyObject *args)
 149 {
 150         Py_UNICODE ch;
 151         Py_UNICODE u[1];
 152
 153         if (!PyArg_ParseTuple(args, ":getwch"))
 154                 return NULL;
 155
 156         Py_BEGIN_ALLOW_THREADS
 157         ch = _getwch();
 158         Py_END_ALLOW_THREADS
 159         u[0] = ch;
 160         return PyUnicode_FromUnicode(u, 1);
 161 }
 162 #endif
 163
 164 static PyObject *
 165 msvcrt_getche(PyObject *self, PyObject *args)
 166 {
 167         int ch;
 168         char s[1];
 169
 170         if (!PyArg_ParseTuple(args, ":getche"))
 171                 return NULL;
 172
 173         Py_BEGIN_ALLOW_THREADS
 174         ch = _getche();
 175         Py_END_ALLOW_THREADS
 176         s[0] = ch;
 177         return PyString_FromStringAndSize(s, 1);
 178 }
 179
 180 #ifdef _WCONIO_DEFINED
 181 static PyObject *
 182 msvcrt_getwche(PyObject *self, PyObject *args)
 183 {
 184         Py_UNICODE ch;
 185         Py_UNICODE s[1];
 186
 187         if (!PyArg_ParseTuple(args, ":getwche"))
 188                 return NULL;
 189
 190         Py_BEGIN_ALLOW_THREADS
 191         ch = _getwche();
 192         Py_END_ALLOW_THREADS
 193         s[0] = ch;
 194         return PyUnicode_FromUnicode(s, 1);
 195 }
 196 #endif
 197
 198 static PyObject *
 199 msvcrt_putch(PyObject *self, PyObject *args)
 200 {
 201         char ch;
 202
 203         if (!PyArg_ParseTuple(args, "c:putch", &ch))
 204                 return NULL;
 205
 206         _putch(ch);
 207         Py_INCREF(Py_None);
 208         return Py_None;
 209 }
 210
 211 #ifdef _WCONIO_DEFINED
 212 static PyObject *
 213 msvcrt_putwch(PyObject *self, PyObject *args)
 214 {
 215         Py_UNICODE *ch;
 216         int size;
 217
 218         if (!PyArg_ParseTuple(args, "u#:putwch", &ch, &size))
 219                 return NULL;
 220
 221         if (size == 0) {
 222                 PyErr_SetString(PyExc_ValueError,
 223                         "Expected unicode string of length 1");
 224                 return NULL;
 225         }
 226         _putwch(*ch);
 227         Py_RETURN_NONE;
 228
 229 }
 230 #endif
 231
 232 static PyObject *
 233 msvcrt_ungetch(PyObject *self, PyObject *args)
 234 {
 235         char ch;
 236
 237         if (!PyArg_ParseTuple(args, "c:ungetch", &ch))
 238                 return NULL;
 239
 240         if (_ungetch(ch) == EOF)
 241                 return PyErr_SetFromErrno(PyExc_IOError);
 242         Py_INCREF(Py_None);
 243         return Py_None;
 244 }
 245
 246 #ifdef _WCONIO_DEFINED
 247 static PyObject *
 248 msvcrt_ungetwch(PyObject *self, PyObject *args)
 249 {
 250         Py_UNICODE ch;
 251
 252         if (!PyArg_ParseTuple(args, "u:ungetwch", &ch))
 253                 return NULL;
 254
 255         if (_ungetch(ch) == EOF)
 256                 return PyErr_SetFromErrno(PyExc_IOError);
 257         Py_INCREF(Py_None);
 258         return Py_None;
 259 }
 260 #endif
 261
 262 static void
 263 insertint(PyObject *d, char *name, int value)
 264 {
 265         PyObject *v = PyInt_FromLong((long) value);
 266         if (v == NULL) {
 267                 /* Don't bother reporting this error */
 268                 PyErr_Clear();
 269         }
 270         else {
 271                 PyDict_SetItemString(d, name, v);
 272                 Py_DECREF(v);
 273         }
 274 }
 275
 276
 277 /* List of functions exported by this module */
 278 static struct PyMethodDef msvcrt_functions[] = {
 279         {"heapmin",             msvcrt_heapmin, METH_VARARGS},
 280         {"locking",             msvcrt_locking, METH_VARARGS},
 281         {"setmode",             msvcrt_setmode, METH_VARARGS},
 282         {"open_osfhandle",      msvcrt_open_osfhandle, METH_VARARGS},
 283         {"get_osfhandle",       msvcrt_get_osfhandle, METH_VARARGS},
 284         {"kbhit",               msvcrt_kbhit, METH_VARARGS},
 285         {"getch",               msvcrt_getch, METH_VARARGS},
 286         {"getche",              msvcrt_getche, METH_VARARGS},
 287         {"putch",               msvcrt_putch, METH_VARARGS},
 288         {"ungetch",             msvcrt_ungetch, METH_VARARGS},
 289 #ifdef _WCONIO_DEFINED
 290         {"getwch",              msvcrt_getwch, METH_VARARGS},
 291         {"getwche",             msvcrt_getwche, METH_VARARGS},
 292         {"putwch",              msvcrt_putwch, METH_VARARGS},
 293         {"ungetwch",            msvcrt_ungetwch, METH_VARARGS},
 294 #endif
 295         {NULL,                  NULL}
 296 };
 297
 298 PyMODINIT_FUNC
 299 initmsvcrt(void)
 300 {
 301         PyObject *d;
 302         PyObject *m = Py_InitModule("msvcrt", msvcrt_functions);
 303         if (m == NULL)
 304                 return;
 305         d = PyModule_GetDict(m);
 306
 307         /* constants for the locking() function's mode argument */
 308         insertint(d, "LK_LOCK", _LK_LOCK);
 309         insertint(d, "LK_NBLCK", _LK_NBLCK);
 310         insertint(d, "LK_NBRLCK", _LK_NBRLCK);
 311         insertint(d, "LK_RLCK", _LK_RLCK);
 312         insertint(d, "LK_UNLCK", _LK_UNLCK);
 313 }