diff --git a/PC/_subprocess.c b/PC/_subprocess.c index 1f73daa64ae..34073c66681 100644 --- a/PC/_subprocess.c +++ b/PC/_subprocess.c @@ -3,16 +3,16 @@ * * Currently, this extension module is only required when using the * subprocess module on Windows, but in the future, stubs for other - * platforms might be added here as well. + * platforms might be added here as well. * * Copyright (c) 2004 by Fredrik Lundh * Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com * Copyright (c) 2004 by Peter Astrand - * + * * By obtaining, using, and/or copying this software and/or its * associated documentation, you agree that you have read, understood, * and will comply with the following terms and conditions: - * + * * Permission to use, copy, modify, and distribute this software and * its associated documentation for any purpose and without fee is * hereby granted, provided that the above copyright notice appears in @@ -21,7 +21,7 @@ * authors not be used in advertising or publicity pertaining to * distribution of the software without specific, written prior * permission. - * + * * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR @@ -29,7 +29,7 @@ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * + * */ /* TODO: handle unicode command lines? */ @@ -46,8 +46,8 @@ the wrapper is used to provide Detach and Close methods */ typedef struct { - PyObject_HEAD - HANDLE handle; + PyObject_HEAD + HANDLE handle; } sp_handle_object; staticforward PyTypeObject sp_handle_type; @@ -55,89 +55,89 @@ staticforward PyTypeObject sp_handle_type; static PyObject* sp_handle_new(HANDLE handle) { - sp_handle_object* self; + sp_handle_object* self; - self = PyObject_NEW(sp_handle_object, &sp_handle_type); - if (self == NULL) - return NULL; + self = PyObject_NEW(sp_handle_object, &sp_handle_type); + if (self == NULL) + return NULL; - self->handle = handle; + self->handle = handle; - return (PyObject*) self; + return (PyObject*) self; } static PyObject* sp_handle_detach(sp_handle_object* self, PyObject* args) { - HANDLE handle; + HANDLE handle; - if (!PyArg_ParseTuple(args, ":Detach")) - return NULL; + if (! PyArg_ParseTuple(args, ":Detach")) + return NULL; - handle = self->handle; + handle = self->handle; - self->handle = NULL; + self->handle = NULL; - /* note: return the current handle, as an integer */ - return PyInt_FromLong((long) handle); + /* note: return the current handle, as an integer */ + return PyInt_FromLong((long) handle); } static PyObject* sp_handle_close(sp_handle_object* self, PyObject* args) { - if (!PyArg_ParseTuple(args, ":Close")) - return NULL; + if (! PyArg_ParseTuple(args, ":Close")) + return NULL; - if (self->handle != INVALID_HANDLE_VALUE) { - CloseHandle(self->handle); - self->handle = INVALID_HANDLE_VALUE; - } - Py_INCREF(Py_None); - return Py_None; + if (self->handle != INVALID_HANDLE_VALUE) { + CloseHandle(self->handle); + self->handle = INVALID_HANDLE_VALUE; + } + Py_INCREF(Py_None); + return Py_None; } static void sp_handle_dealloc(sp_handle_object* self) { - if (self->handle != INVALID_HANDLE_VALUE) - CloseHandle(self->handle); - PyMem_DEL(self); + if (self->handle != INVALID_HANDLE_VALUE) + CloseHandle(self->handle); + PyMem_DEL(self); } static PyMethodDef sp_handle_methods[] = { - {"Detach", (PyCFunction) sp_handle_detach, 1}, - {"Close", (PyCFunction) sp_handle_close, 1}, - {NULL, NULL} + {"Detach", (PyCFunction) sp_handle_detach, 1}, + {"Close", (PyCFunction) sp_handle_close, 1}, + {NULL, NULL} }; -static PyObject* +static PyObject* sp_handle_getattr(sp_handle_object* self, char* name) { - return Py_FindMethod(sp_handle_methods, (PyObject*) self, name); + return Py_FindMethod(sp_handle_methods, (PyObject*) self, name); } static PyObject* sp_handle_as_int(sp_handle_object* self) { - return PyInt_FromLong((long) self->handle); + return PyInt_FromLong((long) self->handle); } static PyNumberMethods sp_handle_as_number; statichere PyTypeObject sp_handle_type = { - PyObject_HEAD_INIT(NULL) - 0, /*ob_size*/ - "_subprocess_handle", sizeof(sp_handle_object), 0, - (destructor) sp_handle_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (getattrfunc) sp_handle_getattr, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - 0, /*tp_repr*/ - &sp_handle_as_number, /*tp_as_number */ - 0, /*tp_as_sequence */ - 0, /*tp_as_mapping */ - 0 /*tp_hash*/ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_subprocess_handle", sizeof(sp_handle_object), 0, + (destructor) sp_handle_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) sp_handle_getattr,/*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + &sp_handle_as_number, /*tp_as_number */ + 0, /*tp_as_sequence */ + 0, /*tp_as_mapping */ + 0 /*tp_hash*/ }; /* -------------------------------------------------------------------- */ @@ -146,91 +146,99 @@ statichere PyTypeObject sp_handle_type = { static PyObject * sp_GetStdHandle(PyObject* self, PyObject* args) { - HANDLE handle; + HANDLE handle; + int std_handle; - int std_handle; - if (!PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle)) - return NULL; + if (! PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle)) + return NULL; - Py_BEGIN_ALLOW_THREADS - handle = GetStdHandle((DWORD) std_handle); - Py_END_ALLOW_THREADS + Py_BEGIN_ALLOW_THREADS + handle = GetStdHandle((DWORD) std_handle); + Py_END_ALLOW_THREADS - if (handle == INVALID_HANDLE_VALUE) - return PyErr_SetFromWindowsErr(GetLastError()); + if (handle == INVALID_HANDLE_VALUE) + return PyErr_SetFromWindowsErr(GetLastError()); - if (!handle) { - Py_INCREF(Py_None); - return Py_None; - } + if (! handle) { + Py_INCREF(Py_None); + return Py_None; + } - /* note: returns integer, not handle object */ - return PyInt_FromLong((long) handle); + /* note: returns integer, not handle object */ + return PyInt_FromLong((long) handle); } static PyObject * sp_GetCurrentProcess(PyObject* self, PyObject* args) { - if (!PyArg_ParseTuple(args, ":GetCurrentProcess")) - return NULL; + if (! PyArg_ParseTuple(args, ":GetCurrentProcess")) + return NULL; - return sp_handle_new(GetCurrentProcess()); + return sp_handle_new(GetCurrentProcess()); } static PyObject * sp_DuplicateHandle(PyObject* self, PyObject* args) { - HANDLE target_handle; - BOOL result; + HANDLE target_handle; + BOOL result; - long source_process_handle; - long source_handle; - long target_process_handle; - int desired_access; - int inherit_handle; - int options = 0; - if (!PyArg_ParseTuple(args, "lllii|i:DuplicateHandle", - &source_process_handle, &source_handle, - &target_process_handle, - &desired_access, &inherit_handle, &options)) - return NULL; + long source_process_handle; + long source_handle; + long target_process_handle; + int desired_access; + int inherit_handle; + int options = 0; - Py_BEGIN_ALLOW_THREADS - result = DuplicateHandle( - (HANDLE) source_process_handle, (HANDLE) source_handle, - (HANDLE) target_process_handle, &target_handle, desired_access, - inherit_handle, options - ); - Py_END_ALLOW_THREADS + if (! PyArg_ParseTuple(args, "lllii|i:DuplicateHandle", + &source_process_handle, + &source_handle, + &target_process_handle, + &desired_access, + &inherit_handle, + &options)) + return NULL; - if (!result) - return PyErr_SetFromWindowsErr(GetLastError()); + Py_BEGIN_ALLOW_THREADS + result = DuplicateHandle( + (HANDLE) source_process_handle, + (HANDLE) source_handle, + (HANDLE) target_process_handle, + &target_handle, + desired_access, + inherit_handle, + options + ); + Py_END_ALLOW_THREADS - return sp_handle_new(target_handle); + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return sp_handle_new(target_handle); } static PyObject * sp_CreatePipe(PyObject* self, PyObject* args) { - HANDLE read_pipe; - HANDLE write_pipe; - BOOL result; + HANDLE read_pipe; + HANDLE write_pipe; + BOOL result; - PyObject* pipe_attributes; /* ignored */ - int size; - if (!PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size)) - return NULL; + PyObject* pipe_attributes; /* ignored */ + int size; - Py_BEGIN_ALLOW_THREADS - result = CreatePipe(&read_pipe, &write_pipe, NULL, size); - Py_END_ALLOW_THREADS + if (! PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size)) + return NULL; - if (!result) - return PyErr_SetFromWindowsErr(GetLastError()); + Py_BEGIN_ALLOW_THREADS + result = CreatePipe(&read_pipe, &write_pipe, NULL, size); + Py_END_ALLOW_THREADS - return Py_BuildValue( - "NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe) - ); + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return Py_BuildValue( + "NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe)); } /* helpers for createprocess */ @@ -238,236 +246,253 @@ sp_CreatePipe(PyObject* self, PyObject* args) static int getint(PyObject* obj, char* name) { - PyObject* value; - value = PyObject_GetAttrString(obj, name); - if (!value) { - PyErr_Clear(); /* FIXME: propagate error? */ - return 0; - } - return (int) PyInt_AsLong(value); + PyObject* value; + + value = PyObject_GetAttrString(obj, name); + if (! value) { + PyErr_Clear(); /* FIXME: propagate error? */ + return 0; + } + return (int) PyInt_AsLong(value); } - + static HANDLE gethandle(PyObject* obj, char* name) { - sp_handle_object* value; - value = (sp_handle_object*) PyObject_GetAttrString(obj, name); - if (!value) { - PyErr_Clear(); /* FIXME: propagate error? */ - return NULL; - } - if (value->ob_type != &sp_handle_type) - return NULL; - return value->handle; + sp_handle_object* value; + + value = (sp_handle_object*) PyObject_GetAttrString(obj, name); + if (! value) { + PyErr_Clear(); /* FIXME: propagate error? */ + return NULL; + } + if (value->ob_type != &sp_handle_type) + return NULL; + return value->handle; } static PyObject* getenvironment(PyObject* environment) { - int i, envsize; - PyObject* out = NULL; - PyObject* keys; - PyObject* values; - char* p; + int i, envsize; + PyObject* out = NULL; + PyObject* keys; + PyObject* values; + char* p; - /* convert environment dictionary to windows enviroment string */ + /* convert environment dictionary to windows enviroment string */ + if (! PyMapping_Check(environment)) { + PyErr_SetString( + PyExc_TypeError, "environment must be dictionary or None"); + return NULL; + } - if (!PyMapping_Check(environment)) { - PyErr_SetString( - PyExc_TypeError, "environment must be dictionary or None" - ); - return NULL; - } - - envsize = PyMapping_Length(environment); + envsize = PyMapping_Length(environment); - keys = PyMapping_Keys(environment); - values = PyMapping_Values(environment); - if (!keys || !values) - goto error; + keys = PyMapping_Keys(environment); + values = PyMapping_Values(environment); + if (!keys || !values) + goto error; - out = PyString_FromStringAndSize(NULL, 2048); - if (!out) - goto error; + out = PyString_FromStringAndSize(NULL, 2048); + if (! out) + goto error; - p = PyString_AS_STRING(out); + p = PyString_AS_STRING(out); - for (i = 0; i < envsize; i++) { - int ksize, vsize, totalsize; - PyObject* key = PyList_GET_ITEM(keys, i); - PyObject* value = PyList_GET_ITEM(values, i); - if (!PyString_Check(key) || !PyString_Check(value)) { - PyErr_SetString( - PyExc_TypeError, "environment can only contain strings" - ); - goto error; - } - ksize = PyString_GET_SIZE(key); - vsize = PyString_GET_SIZE(value); - totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 + vsize + 1 + 1; - if (totalsize > PyString_GET_SIZE(out)) { - int offset = p - PyString_AS_STRING(out); - _PyString_Resize(&out, totalsize + 1024); - p = PyString_AS_STRING(out) + offset; - } - memcpy(p, PyString_AS_STRING(key), ksize); p += ksize; *p++ = '='; - memcpy(p, PyString_AS_STRING(value), vsize); p += vsize; *p++ = '\0'; - } + for (i = 0; i < envsize; i++) { + int ksize, vsize, totalsize; + PyObject* key = PyList_GET_ITEM(keys, i); + PyObject* value = PyList_GET_ITEM(values, i); - /* add trailing null byte */ - *p++ = '\0'; + if (! PyString_Check(key) || ! PyString_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "environment can only contain strings"); + goto error; + } + ksize = PyString_GET_SIZE(key); + vsize = PyString_GET_SIZE(value); + totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 + + vsize + 1 + 1; + if (totalsize > PyString_GET_SIZE(out)) { + int offset = p - PyString_AS_STRING(out); + _PyString_Resize(&out, totalsize + 1024); + p = PyString_AS_STRING(out) + offset; + } + memcpy(p, PyString_AS_STRING(key), ksize); + p += ksize; + *p++ = '='; + memcpy(p, PyString_AS_STRING(value), vsize); + p += vsize; + *p++ = '\0'; + } - _PyString_Resize(&out, p - PyString_AS_STRING(out)); + /* add trailing null byte */ + *p++ = '\0'; + _PyString_Resize(&out, p - PyString_AS_STRING(out)); - /* PyObject_Print(out, stdout, 0); */ + /* PyObject_Print(out, stdout, 0); */ - return out; + return out; -error: - Py_XDECREF(out); - Py_XDECREF(keys); - Py_XDECREF(values); - return NULL; + error: + Py_XDECREF(out); + Py_XDECREF(keys); + Py_XDECREF(values); + return NULL; } static PyObject * sp_CreateProcess(PyObject* self, PyObject* args) { - BOOL result; - PROCESS_INFORMATION pi; - STARTUPINFO si; - PyObject* environment; + BOOL result; + PROCESS_INFORMATION pi; + STARTUPINFO si; + PyObject* environment; - char* application_name; - char* command_line; - PyObject* process_attributes; /* ignored */ - PyObject* thread_attributes; /* ignored */ - int inherit_handles; - int creation_flags; - PyObject* env_mapping; - char* current_directory; - PyObject* startup_info; - if (!PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess", - &application_name, &command_line, - &process_attributes, &thread_attributes, - &inherit_handles, &creation_flags, - &env_mapping, ¤t_directory, &startup_info)) - return NULL; + char* application_name; + char* command_line; + PyObject* process_attributes; /* ignored */ + PyObject* thread_attributes; /* ignored */ + int inherit_handles; + int creation_flags; + PyObject* env_mapping; + char* current_directory; + PyObject* startup_info; - ZeroMemory(&si, sizeof(si)); - si.cb = sizeof(si); + if (! PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess", + &application_name, + &command_line, + &process_attributes, + &thread_attributes, + &inherit_handles, + &creation_flags, + &env_mapping, + ¤t_directory, + &startup_info)) + return NULL; - /* note: we only support a small subset of all SI attributes */ - si.dwFlags = getint(startup_info, "dwFlags"); - si.hStdInput = gethandle(startup_info, "hStdInput"); - si.hStdOutput = gethandle(startup_info, "hStdOutput"); - si.hStdError = gethandle(startup_info, "hStdError"); + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); - if (env_mapping == Py_None) - environment = NULL; - else { - environment = getenvironment(env_mapping); - if (!environment) - return NULL; - } + /* note: we only support a small subset of all SI attributes */ + si.dwFlags = getint(startup_info, "dwFlags"); + si.hStdInput = gethandle(startup_info, "hStdInput"); + si.hStdOutput = gethandle(startup_info, "hStdOutput"); + si.hStdError = gethandle(startup_info, "hStdError"); - Py_BEGIN_ALLOW_THREADS - result = CreateProcess( - application_name, command_line, NULL, NULL, inherit_handles, - creation_flags, environment ? PyString_AS_STRING(environment) : NULL, - current_directory, &si, &pi - ); - Py_END_ALLOW_THREADS + if (env_mapping == Py_None) + environment = NULL; + else { + environment = getenvironment(env_mapping); + if (! environment) + return NULL; + } - Py_XDECREF(environment); + Py_BEGIN_ALLOW_THREADS + result = CreateProcess(application_name, + command_line, + NULL, + NULL, + inherit_handles, + creation_flags, + environment ? PyString_AS_STRING(environment) : NULL, + current_directory, + &si, + &pi); + Py_END_ALLOW_THREADS - if (!result) - return PyErr_SetFromWindowsErr(GetLastError()); + Py_XDECREF(environment); - return Py_BuildValue( - "NNii", sp_handle_new(pi.hProcess), sp_handle_new(pi.hThread), - pi.dwProcessId, pi.dwThreadId - ); + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return Py_BuildValue("NNii", + sp_handle_new(pi.hProcess), + sp_handle_new(pi.hThread), + pi.dwProcessId, + pi.dwThreadId); } static PyObject * sp_GetExitCodeProcess(PyObject* self, PyObject* args) { - DWORD exit_code; - BOOL result; + DWORD exit_code; + BOOL result; - long process; - if (!PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process)) - return NULL; + long process; + if (! PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process)) + return NULL; - result = GetExitCodeProcess((HANDLE) process, &exit_code); + result = GetExitCodeProcess((HANDLE) process, &exit_code); - if (!result) - return PyErr_SetFromWindowsErr(GetLastError()); + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); - return PyInt_FromLong(exit_code); + return PyInt_FromLong(exit_code); } static PyObject * sp_WaitForSingleObject(PyObject* self, PyObject* args) { - DWORD result; + DWORD result; - long handle; - int milliseconds; - if (!PyArg_ParseTuple(args, "li:WaitForSingleObject", - &handle, &milliseconds)) - return NULL; + long handle; + int milliseconds; + if (! PyArg_ParseTuple(args, "li:WaitForSingleObject", + &handle, + &milliseconds)) + return NULL; - Py_BEGIN_ALLOW_THREADS - result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds); - Py_END_ALLOW_THREADS + Py_BEGIN_ALLOW_THREADS + result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds); + Py_END_ALLOW_THREADS - if (result == WAIT_FAILED) - return PyErr_SetFromWindowsErr(GetLastError()); + if (result == WAIT_FAILED) + return PyErr_SetFromWindowsErr(GetLastError()); - return PyInt_FromLong((int) result); + return PyInt_FromLong((int) result); } static PyObject * sp_GetVersion(PyObject* self, PyObject* args) { - if (!PyArg_ParseTuple(args, ":GetVersion")) - return NULL; + if (! PyArg_ParseTuple(args, ":GetVersion")) + return NULL; - return PyInt_FromLong((int) GetVersion()); + return PyInt_FromLong((int) GetVersion()); } static PyObject * sp_GetModuleFileName(PyObject* self, PyObject* args) { - BOOL result; - long module; - TCHAR filename[MAX_PATH]; + BOOL result; + long module; + TCHAR filename[MAX_PATH]; - if (!PyArg_ParseTuple(args, "l:GetModuleFileName", &module)) - return NULL; + if (! PyArg_ParseTuple(args, "l:GetModuleFileName", &module)) + return NULL; - result = GetModuleFileName((HMODULE)module, filename, MAX_PATH); - filename[MAX_PATH-1] = '\0'; + result = GetModuleFileName((HMODULE)module, filename, MAX_PATH); + filename[MAX_PATH-1] = '\0'; - if (!result) - return PyErr_SetFromWindowsErr(GetLastError()); + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); - return PyString_FromString(filename); + return PyString_FromString(filename); } static PyMethodDef sp_functions[] = { - {"GetStdHandle", sp_GetStdHandle, METH_VARARGS}, - {"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS}, - {"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS}, - {"CreatePipe", sp_CreatePipe, METH_VARARGS}, - {"CreateProcess", sp_CreateProcess, METH_VARARGS}, - {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS}, - {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS}, - {"GetVersion", sp_GetVersion, METH_VARARGS}, - {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS}, - {NULL, NULL} + {"GetStdHandle", sp_GetStdHandle, METH_VARARGS}, + {"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS}, + {"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS}, + {"CreatePipe", sp_CreatePipe, METH_VARARGS}, + {"CreateProcess", sp_CreateProcess, METH_VARARGS}, + {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS}, + {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS}, + {"GetVersion", sp_GetVersion, METH_VARARGS}, + {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS}, + {NULL, NULL} }; /* -------------------------------------------------------------------- */ @@ -475,11 +500,11 @@ static PyMethodDef sp_functions[] = { static void defint(PyObject* d, const char* name, int value) { - PyObject* v = PyInt_FromLong((long) value); - if (v) { - PyDict_SetItemString(d, (char*) name, v); - Py_DECREF(v); - } + PyObject* v = PyInt_FromLong((long) value); + if (v) { + PyDict_SetItemString(d, (char*) name, v); + Py_DECREF(v); + } } #if PY_VERSION_HEX >= 0x02030000 @@ -489,23 +514,23 @@ DL_EXPORT(void) #endif init_subprocess() { - PyObject *d; - PyObject *m; + PyObject *d; + PyObject *m; - /* patch up object descriptors */ - sp_handle_type.ob_type = &PyType_Type; - sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int; + /* patch up object descriptors */ + sp_handle_type.ob_type = &PyType_Type; + sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int; - m = Py_InitModule("_subprocess", sp_functions); - d = PyModule_GetDict(m); + m = Py_InitModule("_subprocess", sp_functions); + d = PyModule_GetDict(m); - /* constants */ - defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE); - defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE); - defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE); - defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS); - defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES); - defint(d, "INFINITE", INFINITE); - defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0); - defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE); + /* constants */ + defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE); + defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE); + defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE); + defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS); + defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES); + defint(d, "INFINITE", INFINITE); + defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0); + defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE); }