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 #ifdef _MSC_VER

    26 #if _MSC_VER >= 1500

    27 #include <crtassem.h>

    28 #endif

    29 #endif

    30 

    31 // Force the malloc heap to clean itself up, and free unused blocks

    32 // back to the OS.  (According to the docs, only works on NT.)

    33 static PyObject *

    34 msvcrt_heapmin(PyObject *self, PyObject *args)

    35 {

    36 	if (!PyArg_ParseTuple(args, ":heapmin"))

    37 		return NULL;

    38 

    39 	if (_heapmin() != 0)

    40 		return PyErr_SetFromErrno(PyExc_IOError);

    41 

    42 	Py_INCREF(Py_None);

    43 	return Py_None;

    44 }

    45 

    46 // Perform locking operations on a C runtime file descriptor.

    47 static PyObject *

    48 msvcrt_locking(PyObject *self, PyObject *args)

    49 {

    50 	int fd;

    51 	int mode;

    52 	long nbytes;

    53 	int err;

    54 

    55 	if (!PyArg_ParseTuple(args, "iil:locking", &fd, &mode, &nbytes))

    56 		return NULL;

    57 

    58 	Py_BEGIN_ALLOW_THREADS

    59 	err = _locking(fd, mode, nbytes);

    60 	Py_END_ALLOW_THREADS

    61 	if (err != 0)

    62 		return PyErr_SetFromErrno(PyExc_IOError);

    63 

    64 	Py_INCREF(Py_None);

    65 	return Py_None;

    66 }

    67 

    68 // Set the file translation mode for a C runtime file descriptor.

    69 static PyObject *

    70 msvcrt_setmode(PyObject *self, PyObject *args)

    71 {

    72 	int fd;

    73 	int flags;

    74 	if (!PyArg_ParseTuple(args,"ii:setmode", &fd, &flags))

    75 		return NULL;

    76 

    77 	flags = _setmode(fd, flags);

    78 	if (flags == -1)

    79 		return PyErr_SetFromErrno(PyExc_IOError);

    80 

    81 	return PyInt_FromLong(flags);

    82 }

    83 

    84 // Convert an OS file handle to a C runtime file descriptor.

    85 static PyObject *

    86 msvcrt_open_osfhandle(PyObject *self, PyObject *args)

    87 {

    88 	long handle;

    89 	int flags;

    90 	int fd;

    91 

    92 	if (!PyArg_ParseTuple(args, "li:open_osfhandle", &handle, &flags))

    93 		return NULL;

    94 

    95 	fd = _open_osfhandle(handle, flags);

    96 	if (fd == -1)

    97 		return PyErr_SetFromErrno(PyExc_IOError);

    98 

    99 	return PyInt_FromLong(fd);

   100 }

   101 

   102 // Convert a C runtime file descriptor to an OS file handle.

   103 static PyObject *

   104 msvcrt_get_osfhandle(PyObject *self, PyObject *args)

   105 {

   106 	int fd;

   107 	Py_intptr_t handle;

   108 

   109 	if (!PyArg_ParseTuple(args,"i:get_osfhandle", &fd))

   110 		return NULL;

   111 

   112 	handle = _get_osfhandle(fd);

   113 	if (handle == -1)

   114 		return PyErr_SetFromErrno(PyExc_IOError);

   115 

   116 	/* technically 'handle' is not a pointer, but a integer as

   117 	   large as a pointer, Python's *VoidPtr interface is the

   118 	   most appropriate here */

   119 	return PyLong_FromVoidPtr((void*)handle);

   120 }

   121 

   122 /* Console I/O */

   123 

   124 static PyObject *

   125 msvcrt_kbhit(PyObject *self, PyObject *args)

   126 {

   127 	int ok;

   128 

   129 	if (!PyArg_ParseTuple(args, ":kbhit"))

   130 		return NULL;

   131 

   132 	ok = _kbhit();

   133 	return PyInt_FromLong(ok);

   134 }

   135 

   136 static PyObject *

   137 msvcrt_getch(PyObject *self, PyObject *args)

   138 {

   139 	int ch;

   140 	char s[1];

   141 

   142 	if (!PyArg_ParseTuple(args, ":getch"))

   143 		return NULL;

   144 

   145 	Py_BEGIN_ALLOW_THREADS

   146 	ch = _getch();

   147 	Py_END_ALLOW_THREADS

   148 	s[0] = ch;

   149 	return PyString_FromStringAndSize(s, 1);

   150 }

   151 

   152 #ifdef _WCONIO_DEFINED

   153 static PyObject *

   154 msvcrt_getwch(PyObject *self, PyObject *args)

   155 {

   156 	Py_UNICODE ch;

   157 	Py_UNICODE u[1];

   158 

   159 	if (!PyArg_ParseTuple(args, ":getwch"))

   160 		return NULL;

   161 

   162 	Py_BEGIN_ALLOW_THREADS

   163 	ch = _getwch();

   164 	Py_END_ALLOW_THREADS

   165 	u[0] = ch;

   166 	return PyUnicode_FromUnicode(u, 1);

   167 }

   168 #endif

   169 

   170 static PyObject *

   171 msvcrt_getche(PyObject *self, PyObject *args)

   172 {

   173 	int ch;

   174 	char s[1];

   175 

   176 	if (!PyArg_ParseTuple(args, ":getche"))

   177 		return NULL;

   178 

   179 	Py_BEGIN_ALLOW_THREADS

   180 	ch = _getche();

   181 	Py_END_ALLOW_THREADS

   182 	s[0] = ch;

   183 	return PyString_FromStringAndSize(s, 1);

   184 }

   185 

   186 #ifdef _WCONIO_DEFINED

   187 static PyObject *

   188 msvcrt_getwche(PyObject *self, PyObject *args)

   189 {

   190 	Py_UNICODE ch;

   191 	Py_UNICODE s[1];

   192 

   193 	if (!PyArg_ParseTuple(args, ":getwche"))

   194 		return NULL;

   195 

   196 	Py_BEGIN_ALLOW_THREADS

   197 	ch = _getwche();

   198 	Py_END_ALLOW_THREADS

   199 	s[0] = ch;

   200 	return PyUnicode_FromUnicode(s, 1);

   201 }

   202 #endif

   203 

   204 static PyObject *

   205 msvcrt_putch(PyObject *self, PyObject *args)

   206 {

   207 	char ch;

   208 

   209 	if (!PyArg_ParseTuple(args, "c:putch", &ch))

   210 		return NULL;

   211 

   212 	_putch(ch);

   213 	Py_INCREF(Py_None);

   214 	return Py_None;

   215 }

   216 

   217 #ifdef _WCONIO_DEFINED

   218 static PyObject *

   219 msvcrt_putwch(PyObject *self, PyObject *args)

   220 {

   221 	Py_UNICODE *ch;

   222 	int size;

   223 

   224 	if (!PyArg_ParseTuple(args, "u#:putwch", &ch, &size))

   225 		return NULL;

   226 

   227 	if (size == 0) {

   228 		PyErr_SetString(PyExc_ValueError,

   229 			"Expected unicode string of length 1");

   230 		return NULL;

   231 	}

   232 	_putwch(*ch);

   233 	Py_RETURN_NONE;

   234 

   235 }

   236 #endif

   237 

   238 static PyObject *

   239 msvcrt_ungetch(PyObject *self, PyObject *args)

   240 {

   241 	char ch;

   242 

   243 	if (!PyArg_ParseTuple(args, "c:ungetch", &ch))

   244 		return NULL;

   245 

   246 	if (_ungetch(ch) == EOF)

   247 		return PyErr_SetFromErrno(PyExc_IOError);

   248 	Py_INCREF(Py_None);

   249 	return Py_None;

   250 }

   251 

   252 #ifdef _WCONIO_DEFINED

   253 static PyObject *

   254 msvcrt_ungetwch(PyObject *self, PyObject *args)

   255 {

   256 	Py_UNICODE ch;

   257 

   258 	if (!PyArg_ParseTuple(args, "u:ungetwch", &ch))

   259 		return NULL;

   260 

   261 	if (_ungetch(ch) == EOF)

   262 		return PyErr_SetFromErrno(PyExc_IOError);

   263 	Py_INCREF(Py_None);

   264 	return Py_None;

   265 }

   266 #endif

   267 

   268 static void

   269 insertint(PyObject *d, char *name, int value)

   270 {

   271 	PyObject *v = PyInt_FromLong((long) value);

   272 	if (v == NULL) {

   273 		/* Don't bother reporting this error */

   274 		PyErr_Clear();

   275 	}

   276 	else {

   277 		PyDict_SetItemString(d, name, v);

   278 		Py_DECREF(v);

   279 	}

   280 }

   281 

   282 

   283 /* List of functions exported by this module */

   284 static struct PyMethodDef msvcrt_functions[] = {

   285 	{"heapmin",		msvcrt_heapmin, METH_VARARGS},

   286 	{"locking",             msvcrt_locking, METH_VARARGS},

   287 	{"setmode",		msvcrt_setmode, METH_VARARGS},

   288 	{"open_osfhandle",	msvcrt_open_osfhandle, METH_VARARGS},

   289 	{"get_osfhandle",	msvcrt_get_osfhandle, METH_VARARGS},

   290 	{"kbhit",		msvcrt_kbhit, METH_VARARGS},

   291 	{"getch",		msvcrt_getch, METH_VARARGS},

   292 	{"getche",		msvcrt_getche, METH_VARARGS},

   293 	{"putch",		msvcrt_putch, METH_VARARGS},

   294 	{"ungetch",		msvcrt_ungetch, METH_VARARGS},

   295 #ifdef _WCONIO_DEFINED

   296 	{"getwch",		msvcrt_getwch, METH_VARARGS},

   297 	{"getwche",		msvcrt_getwche, METH_VARARGS},

   298 	{"putwch",		msvcrt_putwch, METH_VARARGS},

   299 	{"ungetwch",		msvcrt_ungetwch, METH_VARARGS},

   300 #endif

   301 	{NULL,			NULL}

   302 };

   303 

   304 PyMODINIT_FUNC

   305 initmsvcrt(void)

   306 {

   307 	int st;

   308 	PyObject *d;

   309 	PyObject *m = Py_InitModule("msvcrt", msvcrt_functions);

   310 	if (m == NULL)

   311 		return;

   312 	d = PyModule_GetDict(m);

   313 

   314 	/* constants for the locking() function's mode argument */

   315 	insertint(d, "LK_LOCK", _LK_LOCK);

   316 	insertint(d, "LK_NBLCK", _LK_NBLCK);

   317 	insertint(d, "LK_NBRLCK", _LK_NBRLCK);

   318 	insertint(d, "LK_RLCK", _LK_RLCK);

   319 	insertint(d, "LK_UNLCK", _LK_UNLCK);

   320 

   321 	/* constants for the crt versions */

   322 #ifdef _VC_ASSEMBLY_PUBLICKEYTOKEN

   323 	st = PyModule_AddStringConstant(m, "VC_ASSEMBLY_PUBLICKEYTOKEN",

   324 					_VC_ASSEMBLY_PUBLICKEYTOKEN);

   325 	if (st < 0)return;

   326 #endif

   327 #ifdef _CRT_ASSEMBLY_VERSION

   328 	st = PyModule_AddStringConstant(m, "CRT_ASSEMBLY_VERSION",

   329 					_CRT_ASSEMBLY_VERSION);

   330 	if (st < 0)return;

   331 #endif

   332 #ifdef __LIBRARIES_ASSEMBLY_NAME_PREFIX

   333 	st = PyModule_AddStringConstant(m, "LIBRARIES_ASSEMBLY_NAME_PREFIX",

   334 					__LIBRARIES_ASSEMBLY_NAME_PREFIX);

   335 	if (st < 0)return;

   336 #endif

   337 }