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 #include <crtdbg.h>
  25 #include <windows.h>
  26
  27 #ifdef _MSC_VER
  28 #if _MSC_VER >= 1500 && _MSC_VER < 1600
  29 #include <crtassem.h>
  30 #endif
  31 #endif
  32
  33 // Force the malloc heap to clean itself up, and free unused blocks
  34 // back to the OS.  (According to the docs, only works on NT.)
  35 static PyObject *
  36 msvcrt_heapmin(PyObject *self, PyObject *args)
  37 {
  38         if (!PyArg_ParseTuple(args, ":heapmin"))
  39                 return NULL;
  40
  41         if (_heapmin() != 0)
  42                 return PyErr_SetFromErrno(PyExc_IOError);
  43
  44         Py_INCREF(Py_None);
  45         return Py_None;
  46 }
  47
  48 PyDoc_STRVAR(heapmin_doc,
  49 "heapmin() -> None\n\
  50 \n\
  51 Force the malloc() heap to clean itself up and return unused blocks\n\
  52 to the operating system. On failure, this raises IOError.");
  53
  54 // Perform locking operations on a C runtime file descriptor.
  55 static PyObject *
  56 msvcrt_locking(PyObject *self, PyObject *args)
  57 {
  58         int fd;
  59         int mode;
  60         long nbytes;
  61         int err;
  62
  63         if (!PyArg_ParseTuple(args, "iil:locking", &fd, &mode, &nbytes))
  64                 return NULL;
  65
  66         Py_BEGIN_ALLOW_THREADS
  67         err = _locking(fd, mode, nbytes);
  68         Py_END_ALLOW_THREADS
  69         if (err != 0)
  70                 return PyErr_SetFromErrno(PyExc_IOError);
  71
  72         Py_INCREF(Py_None);
  73         return Py_None;
  74 }
  75
  76 PyDoc_STRVAR(locking_doc,
  77 "locking(fd, mode, nbytes) -> None\n\
  78 \n\
  79 Lock part of a file based on file descriptor fd from the C runtime.\n\
  80 Raises IOError on failure. The locked region of the file extends from\n\
  81 the current file position for nbytes bytes, and may continue beyond\n\
  82 the end of the file. mode must be one of the LK_* constants listed\n\
  83 below. Multiple regions in a file may be locked at the same time, but\n\
  84 may not overlap. Adjacent regions are not merged; they must be unlocked\n\
  85 individually.");
  86
  87 // Set the file translation mode for a C runtime file descriptor.
  88 static PyObject *
  89 msvcrt_setmode(PyObject *self, PyObject *args)
  90 {
  91         int fd;
  92         int flags;
  93         if (!PyArg_ParseTuple(args,"ii:setmode", &fd, &flags))
  94                 return NULL;
  95
  96         flags = _setmode(fd, flags);
  97         if (flags == -1)
  98                 return PyErr_SetFromErrno(PyExc_IOError);
  99
 100         return PyLong_FromLong(flags);
 101 }
 102
 103 PyDoc_STRVAR(setmode_doc,
 104 "setmode(fd, mode) -> Previous mode\n\
 105 \n\
 106 Set the line-end translation mode for the file descriptor fd. To set\n\
 107 it to text mode, flags should be os.O_TEXT; for binary, it should be\n\
 108 os.O_BINARY.");
 109
 110 // Convert an OS file handle to a C runtime file descriptor.
 111 static PyObject *
 112 msvcrt_open_osfhandle(PyObject *self, PyObject *args)
 113 {
 114         long handle;
 115         int flags;
 116         int fd;
 117
 118         if (!PyArg_ParseTuple(args, "li:open_osfhandle", &handle, &flags))
 119                 return NULL;
 120
 121         fd = _open_osfhandle(handle, flags);
 122         if (fd == -1)
 123                 return PyErr_SetFromErrno(PyExc_IOError);
 124
 125         return PyLong_FromLong(fd);
 126 }
 127
 128 PyDoc_STRVAR(open_osfhandle_doc,
 129 "open_osfhandle(handle, flags) -> file descriptor\n\
 130 \n\
 131 Create a C runtime file descriptor from the file handle handle. The\n\
 132 flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,\n\
 133 and os.O_TEXT. The returned file descriptor may be used as a parameter\n\
 134 to os.fdopen() to create a file object.");
 135
 136 // Convert a C runtime file descriptor to an OS file handle.
 137 static PyObject *
 138 msvcrt_get_osfhandle(PyObject *self, PyObject *args)
 139 {
 140         int fd;
 141         Py_intptr_t handle;
 142
 143         if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))
 144                 return NULL;
 145
 146         handle = _get_osfhandle(fd);
 147         if (handle == -1)
 148                 return PyErr_SetFromErrno(PyExc_IOError);
 149
 150         /* technically 'handle' is not a pointer, but a integer as
 151            large as a pointer, Python's *VoidPtr interface is the
 152            most appropriate here */
 153         return PyLong_FromVoidPtr((void*)handle);
 154 }
 155
 156 PyDoc_STRVAR(get_osfhandle_doc,
 157 "get_osfhandle(fd) -> file handle\n\
 158 \n\
 159 Return the file handle for the file descriptor fd. Raises IOError\n\
 160 if fd is not recognized.");
 161
 162 /* Console I/O */
 163
 164 static PyObject *
 165 msvcrt_kbhit(PyObject *self, PyObject *args)
 166 {
 167         int ok;
 168
 169         if (!PyArg_ParseTuple(args, ":kbhit"))
 170                 return NULL;
 171
 172         ok = _kbhit();
 173         return PyLong_FromLong(ok);
 174 }
 175
 176 PyDoc_STRVAR(kbhit_doc,
 177 "kbhit() -> bool\n\
 178 \n\
 179 Return true if a keypress is waiting to be read.");
 180
 181 static PyObject *
 182 msvcrt_getch(PyObject *self, PyObject *args)
 183 {
 184         int ch;
 185         char s[1];
 186
 187         if (!PyArg_ParseTuple(args, ":getch"))
 188                 return NULL;
 189
 190         Py_BEGIN_ALLOW_THREADS
 191         ch = _getch();
 192         Py_END_ALLOW_THREADS
 193         s[0] = ch;
 194         return PyBytes_FromStringAndSize(s, 1);
 195 }
 196
 197 PyDoc_STRVAR(getch_doc,
 198 "getch() -> key character\n\
 199 \n\
 200 Read a keypress and return the resulting character. Nothing is echoed to\n\
 201 the console. This call will block if a keypress is not already\n\
 202 available, but will not wait for Enter to be pressed. If the pressed key\n\
 203 was a special function key, this will return '\\000' or '\\xe0'; the next\n\
 204 call will return the keycode. The Control-C keypress cannot be read with\n\
 205 this function.");
 206
 207 #ifdef _WCONIO_DEFINED
 208 static PyObject *
 209 msvcrt_getwch(PyObject *self, PyObject *args)
 210 {
 211         Py_UNICODE ch;
 212         Py_UNICODE u[1];
 213
 214         if (!PyArg_ParseTuple(args, ":getwch"))
 215                 return NULL;
 216
 217         Py_BEGIN_ALLOW_THREADS
 218         ch = _getwch();
 219         Py_END_ALLOW_THREADS
 220         u[0] = ch;
 221         return PyUnicode_FromUnicode(u, 1);
 222 }
 223
 224 PyDoc_STRVAR(getwch_doc,
 225 "getwch() -> Unicode key character\n\
 226 \n\
 227 Wide char variant of getch(), returning a Unicode value.");
 228 #endif
 229
 230 static PyObject *
 231 msvcrt_getche(PyObject *self, PyObject *args)
 232 {
 233         int ch;
 234         char s[1];
 235
 236         if (!PyArg_ParseTuple(args, ":getche"))
 237                 return NULL;
 238
 239         Py_BEGIN_ALLOW_THREADS
 240         ch = _getche();
 241         Py_END_ALLOW_THREADS
 242         s[0] = ch;
 243         return PyBytes_FromStringAndSize(s, 1);
 244 }
 245
 246 PyDoc_STRVAR(getche_doc,
 247 "getche() -> key character\n\
 248 \n\
 249 Similar to getch(), but the keypress will be echoed if it represents\n\
 250 a printable character.");
 251
 252 #ifdef _WCONIO_DEFINED
 253 static PyObject *
 254 msvcrt_getwche(PyObject *self, PyObject *args)
 255 {
 256         Py_UNICODE ch;
 257         Py_UNICODE s[1];
 258
 259         if (!PyArg_ParseTuple(args, ":getwche"))
 260                 return NULL;
 261
 262         Py_BEGIN_ALLOW_THREADS
 263         ch = _getwche();
 264         Py_END_ALLOW_THREADS
 265         s[0] = ch;
 266         return PyUnicode_FromUnicode(s, 1);
 267 }
 268
 269 PyDoc_STRVAR(getwche_doc,
 270 "getwche() -> Unicode key character\n\
 271 \n\
 272 Wide char variant of getche(), returning a Unicode value.");
 273 #endif
 274
 275 static PyObject *
 276 msvcrt_putch(PyObject *self, PyObject *args)
 277 {
 278         char ch;
 279
 280         if (!PyArg_ParseTuple(args, "c:putch", &ch))
 281                 return NULL;
 282
 283         _putch(ch);
 284         Py_INCREF(Py_None);
 285         return Py_None;
 286 }
 287
 288 PyDoc_STRVAR(putch_doc,
 289 "putch(char) -> None\n\
 290 \n\
 291 Print the character char to the console without buffering.");
 292
 293 #ifdef _WCONIO_DEFINED
 294 static PyObject *
 295 msvcrt_putwch(PyObject *self, PyObject *args)
 296 {
 297         int ch;
 298
 299         if (!PyArg_ParseTuple(args, "C:putwch", &ch))
 300                 return NULL;
 301
 302         _putwch(ch);
 303         Py_RETURN_NONE;
 304
 305 }
 306
 307 PyDoc_STRVAR(putwch_doc,
 308 "putwch(unicode_char) -> None\n\
 309 \n\
 310 Wide char variant of putch(), accepting a Unicode value.");
 311 #endif
 312
 313 static PyObject *
 314 msvcrt_ungetch(PyObject *self, PyObject *args)
 315 {
 316         char ch;
 317
 318         if (!PyArg_ParseTuple(args, "c:ungetch", &ch))
 319                 return NULL;
 320
 321         if (_ungetch(ch) == EOF)
 322                 return PyErr_SetFromErrno(PyExc_IOError);
 323         Py_INCREF(Py_None);
 324         return Py_None;
 325 }
 326
 327 PyDoc_STRVAR(ungetch_doc,
 328 "ungetch(char) -> None\n\
 329 \n\
 330 Cause the character char to be \"pushed back\" into the console buffer;\n\
 331 it will be the next character read by getch() or getche().");
 332
 333 #ifdef _WCONIO_DEFINED
 334 static PyObject *
 335 msvcrt_ungetwch(PyObject *self, PyObject *args)
 336 {
 337         int ch;
 338
 339         if (!PyArg_ParseTuple(args, "C:ungetwch", &ch))
 340                 return NULL;
 341
 342         if (_ungetwch(ch) == WEOF)
 343                 return PyErr_SetFromErrno(PyExc_IOError);
 344         Py_INCREF(Py_None);
 345         return Py_None;
 346 }
 347
 348 PyDoc_STRVAR(ungetwch_doc,
 349 "ungetwch(unicode_char) -> None\n\
 350 \n\
 351 Wide char variant of ungetch(), accepting a Unicode value.");
 352 #endif
 353
 354 static void
 355 insertint(PyObject *d, char *name, int value)
 356 {
 357         PyObject *v = PyLong_FromLong((long) value);
 358         if (v == NULL) {
 359                 /* Don't bother reporting this error */
 360                 PyErr_Clear();
 361         }
 362         else {
 363                 PyDict_SetItemString(d, name, v);
 364                 Py_DECREF(v);
 365         }
 366 }
 367
 368 #ifdef _DEBUG
 369
 370 static PyObject*
 371 msvcrt_setreportfile(PyObject *self, PyObject *args)
 372 {
 373         int type, file;
 374         _HFILE res;
 375
 376         if (!PyArg_ParseTuple(args, "ii", &type, &file))
 377                 return NULL;
 378         res = _CrtSetReportFile(type, (_HFILE)file);
 379         return PyLong_FromLong((long)res);
 380         Py_INCREF(Py_None);
 381         return Py_None;
 382 }
 383
 384 static PyObject*
 385 msvcrt_setreportmode(PyObject *self, PyObject *args)
 386 {
 387         int type, mode;
 388         int res;
 389
 390         if (!PyArg_ParseTuple(args, "ii", &type, &mode))
 391                 return NULL;
 392         res = _CrtSetReportMode(type, mode);
 393         if (res == -1)
 394             return PyErr_SetFromErrno(PyExc_IOError);
 395         return PyLong_FromLong(res);
 396 }
 397
 398 static PyObject*
 399 msvcrt_seterrormode(PyObject *self, PyObject *args)
 400 {
 401         int mode, res;
 402
 403         if (!PyArg_ParseTuple(args, "i", &mode))
 404                 return NULL;
 405         res = _set_error_mode(mode);
 406         return PyLong_FromLong(res);
 407 }
 408
 409 #endif
 410
 411 static PyObject*
 412 seterrormode(PyObject *self, PyObject *args)
 413 {
 414         unsigned int mode, res;
 415
 416         if (!PyArg_ParseTuple(args, "I", &mode))
 417                 return NULL;
 418         res = SetErrorMode(mode);
 419         return PyLong_FromUnsignedLong(res);
 420 }
 421
 422
 423 /* List of functions exported by this module */
 424 static struct PyMethodDef msvcrt_functions[] = {
 425         {"heapmin",             msvcrt_heapmin, METH_VARARGS, heapmin_doc},
 426         {"locking",             msvcrt_locking, METH_VARARGS, locking_doc},
 427         {"setmode",             msvcrt_setmode, METH_VARARGS, setmode_doc},
 428         {"open_osfhandle",      msvcrt_open_osfhandle, METH_VARARGS, open_osfhandle_doc},
 429         {"get_osfhandle",       msvcrt_get_osfhandle, METH_VARARGS, get_osfhandle_doc},
 430         {"kbhit",               msvcrt_kbhit, METH_VARARGS, kbhit_doc},
 431         {"getch",               msvcrt_getch, METH_VARARGS, getch_doc},
 432         {"getche",              msvcrt_getche, METH_VARARGS, getche_doc},
 433         {"putch",               msvcrt_putch, METH_VARARGS, putch_doc},
 434         {"ungetch",             msvcrt_ungetch, METH_VARARGS, ungetch_doc},
 435         {"SetErrorMode",        seterrormode, METH_VARARGS},
 436 #ifdef _DEBUG
 437         {"CrtSetReportFile",    msvcrt_setreportfile, METH_VARARGS},
 438         {"CrtSetReportMode",    msvcrt_setreportmode, METH_VARARGS},
 439         {"set_error_mode",      msvcrt_seterrormode, METH_VARARGS},
 440 #endif
 441 #ifdef _WCONIO_DEFINED
 442         {"getwch",              msvcrt_getwch, METH_VARARGS, getwch_doc},
 443         {"getwche",             msvcrt_getwche, METH_VARARGS, getwche_doc},
 444         {"putwch",              msvcrt_putwch, METH_VARARGS, putwch_doc},
 445         {"ungetwch",            msvcrt_ungetwch, METH_VARARGS, ungetwch_doc},
 446 #endif
 447         {NULL,                  NULL}
 448 };
 449
 450
 451 static struct PyModuleDef msvcrtmodule = {
 452         PyModuleDef_HEAD_INIT,
 453         "msvcrt",
 454         NULL,
 455         -1,
 456         msvcrt_functions,
 457         NULL,
 458         NULL,
 459         NULL,
 460         NULL
 461 };
 462
 463 PyMODINIT_FUNC
 464 PyInit_msvcrt(void)
 465 {
 466         int st;
 467         PyObject *d;
 468         PyObject *m = PyModule_Create(&msvcrtmodule);
 469         if (m == NULL)
 470                 return NULL;
 471         d = PyModule_GetDict(m);
 472
 473         /* constants for the locking() function's mode argument */
 474         insertint(d, "LK_LOCK", _LK_LOCK);
 475         insertint(d, "LK_NBLCK", _LK_NBLCK);
 476         insertint(d, "LK_NBRLCK", _LK_NBRLCK);
 477         insertint(d, "LK_RLCK", _LK_RLCK);
 478         insertint(d, "LK_UNLCK", _LK_UNLCK);
 479         insertint(d, "SEM_FAILCRITICALERRORS", SEM_FAILCRITICALERRORS);
 480         insertint(d, "SEM_NOALIGNMENTFAULTEXCEPT", SEM_NOALIGNMENTFAULTEXCEPT);
 481         insertint(d, "SEM_NOGPFAULTERRORBOX", SEM_NOGPFAULTERRORBOX);
 482         insertint(d, "SEM_NOOPENFILEERRORBOX", SEM_NOOPENFILEERRORBOX);
 483 #ifdef _DEBUG
 484         insertint(d, "CRT_WARN", _CRT_WARN);
 485         insertint(d, "CRT_ERROR", _CRT_ERROR);
 486         insertint(d, "CRT_ASSERT", _CRT_ASSERT);
 487         insertint(d, "CRTDBG_MODE_DEBUG", _CRTDBG_MODE_DEBUG);
 488         insertint(d, "CRTDBG_MODE_FILE", _CRTDBG_MODE_FILE);
 489         insertint(d, "CRTDBG_MODE_WNDW", _CRTDBG_MODE_WNDW);
 490         insertint(d, "CRTDBG_REPORT_MODE", _CRTDBG_REPORT_MODE);
 491         insertint(d, "CRTDBG_FILE_STDERR", (int)_CRTDBG_FILE_STDERR);
 492         insertint(d, "CRTDBG_FILE_STDOUT", (int)_CRTDBG_FILE_STDOUT);
 493         insertint(d, "CRTDBG_REPORT_FILE", (int)_CRTDBG_REPORT_FILE);
 494 #endif
 495
 496         /* constants for the crt versions */
 497 #ifdef _VC_ASSEMBLY_PUBLICKEYTOKEN
 498         st = PyModule_AddStringConstant(m, "VC_ASSEMBLY_PUBLICKEYTOKEN",
 499                                         _VC_ASSEMBLY_PUBLICKEYTOKEN);
 500         if (st < 0) return NULL;
 501 #endif
 502 #ifdef _CRT_ASSEMBLY_VERSION
 503         st = PyModule_AddStringConstant(m, "CRT_ASSEMBLY_VERSION",
 504                                         _CRT_ASSEMBLY_VERSION);
 505         if (st < 0) return NULL;
 506 #endif
 507 #ifdef __LIBRARIES_ASSEMBLY_NAME_PREFIX
 508         st = PyModule_AddStringConstant(m, "LIBRARIES_ASSEMBLY_NAME_PREFIX",
 509                                         __LIBRARIES_ASSEMBLY_NAME_PREFIX);
 510         if (st < 0) return NULL;
 511 #endif
 512
 513         return m;
 514 }