Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
_subprocess.c File Reference
#include "Python.h"
#include "windows.h"

Go to the source code of this file.

Classes

struct  sp_handle_object

Defines

#define WINDOWS_LEAN_AND_MEAN
#define HANDLE_TO_PYNUM(handle)   PyLong_FromLongLong((long long) handle)
#define PY_HANDLE_PARAM   "L"

Functions

static PyObjectsp_handle_new (HANDLE handle)
static PyObjectsp_handle_detach (sp_handle_object *self, PyObject *args)
static PyObjectsp_handle_close (sp_handle_object *self, PyObject *args)
static void sp_handle_dealloc (sp_handle_object *self)
static PyObjectsp_handle_as_int (sp_handle_object *self)
 PyDoc_STRVAR (GetStdHandle_doc,"GetStdHandle(handle) -> integer\n\ \n\ Return a handle to the specified standard device\n\ (STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).\n\ The integer associated with the handle object is returned.")
static PyObjectsp_GetStdHandle (PyObject *self, PyObject *args)
 PyDoc_STRVAR (GetCurrentProcess_doc,"GetCurrentProcess() -> handle\n\ \n\ Return a handle object for the current process.")
static PyObjectsp_GetCurrentProcess (PyObject *self, PyObject *args)
 PyDoc_STRVAR (DuplicateHandle_doc,"DuplicateHandle(source_proc_handle, source_handle,\n\ target_proc_handle, target_handle, access,\n\ inherit[, options]) -> handle\n\ \n\ Return a duplicate handle object.\n\ \n\ The duplicate handle refers to the same object as the original\n\ handle. Therefore, any changes to the object are reflected\n\ through both handles.")
static PyObjectsp_DuplicateHandle (PyObject *self, PyObject *args)
 PyDoc_STRVAR (CreatePipe_doc,"CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)\n\ \n\ Create an anonymous pipe, and return handles to the read and\n\ write ends of the pipe.\n\ \n\ pipe_attrs is ignored internally and can be None.")
static PyObjectsp_CreatePipe (PyObject *self, PyObject *args)
static int getint (PyObject *obj, char *name)
static HANDLE gethandle (PyObject *obj, char *name)
static PyObjectgetenvironment (PyObject *environment)
 PyDoc_STRVAR (CreateProcess_doc,"CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,\n\ inherit, flags, env_mapping, curdir,\n\ startup_info) -> (proc_handle, thread_handle,\n\ pid, tid)\n\ \n\ Create a new process and its primary thread. The return\n\ value is a tuple of the process handle, thread handle,\n\ process ID, and thread ID.\n\ \n\ proc_attrs and thread_attrs are ignored internally and can be None.")
static PyObjectsp_CreateProcess (PyObject *self, PyObject *args)
 PyDoc_STRVAR (TerminateProcess_doc,"TerminateProcess(handle, exit_code) -> None\n\ \n\ Terminate the specified process and all of its threads.")
static PyObjectsp_TerminateProcess (PyObject *self, PyObject *args)
 PyDoc_STRVAR (GetExitCodeProcess_doc,"GetExitCodeProcess(handle) -> Exit code\n\ \n\ Return the termination status of the specified process.")
static PyObjectsp_GetExitCodeProcess (PyObject *self, PyObject *args)
 PyDoc_STRVAR (WaitForSingleObject_doc,"WaitForSingleObject(handle, timeout) -> result\n\ \n\ Wait until the specified object is in the signaled state or\n\ the time-out interval elapses. The timeout value is specified\n\ in milliseconds.")
static PyObjectsp_WaitForSingleObject (PyObject *self, PyObject *args)
 PyDoc_STRVAR (GetVersion_doc,"GetVersion() -> version\n\ \n\ Return the version number of the current operating system.")
static PyObjectsp_GetVersion (PyObject *self, PyObject *args)
 PyDoc_STRVAR (GetModuleFileName_doc,"GetModuleFileName(module) -> path\n\ \n\ Return the fully-qualified path for the file that contains\n\ the specified module. The module must have been loaded by the\n\ current process.\n\ \n\ The module parameter should be a handle to the loaded module\n\ whose path is being requested. If this parameter is 0, \n\ GetModuleFileName retrieves the path of the executable file\n\ of the current process.")
static PyObjectsp_GetModuleFileName (PyObject *self, PyObject *args)
static void defint (PyObject *d, const char *name, int value)
PyMODINIT_FUNC PyInit__subprocess ()

Variables

static PyTypeObject sp_handle_type
static PyMethodDef sp_handle_methods []
static PyNumberMethods sp_handle_as_number
static PyMethodDef sp_functions []
static struct PyModuleDef

Class Documentation

struct sp_handle_object

Definition at line 48 of file _subprocess.c.

Class Members
PyObject_HEAD HANDLE handle

Define Documentation

#define HANDLE_TO_PYNUM (   handle)    PyLong_FromLongLong((long long) handle)

Definition at line 73 of file _subprocess.c.

#define PY_HANDLE_PARAM   "L"

Definition at line 74 of file _subprocess.c.

Definition at line 40 of file _subprocess.c.


Function Documentation

static void defint ( PyObject d,
const char *  name,
int  value 
) [static]

Definition at line 638 of file _subprocess.c.

{
    PyObject* v = PyLong_FromLong((long) value);
    if (v) {
        PyDict_SetItemString(d, (char*) name, v);
        Py_DECREF(v);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* getenvironment ( PyObject environment) [static]

Definition at line 330 of file _subprocess.c.

{
    int i;
    Py_ssize_t envsize;
    PyObject* out = NULL;
    PyObject* keys;
    PyObject* values;
    Py_UNICODE* p;

    /* convert environment dictionary to windows enviroment string */
    if (! PyMapping_Check(environment)) {
        PyErr_SetString(
            PyExc_TypeError, "environment must be dictionary or None");
        return NULL;
    }

    envsize = PyMapping_Length(environment);

    keys = PyMapping_Keys(environment);
    values = PyMapping_Values(environment);
    if (!keys || !values)
        goto error;

    out = PyUnicode_FromUnicode(NULL, 2048);
    if (! out)
        goto error;

    p = PyUnicode_AS_UNICODE(out);

    for (i = 0; i < envsize; i++) {
        Py_ssize_t ksize, vsize, totalsize;
        PyObject* key = PyList_GET_ITEM(keys, i);
        PyObject* value = PyList_GET_ITEM(values, i);

        if (! PyUnicode_Check(key) || ! PyUnicode_Check(value)) {
            PyErr_SetString(PyExc_TypeError,
                "environment can only contain strings");
            goto error;
        }
        ksize = PyUnicode_GET_SIZE(key);
        vsize = PyUnicode_GET_SIZE(value);
        totalsize = (p - PyUnicode_AS_UNICODE(out)) + ksize + 1 +
                                                     vsize + 1 + 1;
        if (totalsize > PyUnicode_GET_SIZE(out)) {
            Py_ssize_t offset = p - PyUnicode_AS_UNICODE(out);
            PyUnicode_Resize(&out, totalsize + 1024);
            p = PyUnicode_AS_UNICODE(out) + offset;
        }
        Py_UNICODE_COPY(p, PyUnicode_AS_UNICODE(key), ksize);
        p += ksize;
        *p++ = '=';
        Py_UNICODE_COPY(p, PyUnicode_AS_UNICODE(value), vsize);
        p += vsize;
        *p++ = '\0';
    }

    /* add trailing null byte */
    *p++ = '\0';
    PyUnicode_Resize(&out, p - PyUnicode_AS_UNICODE(out));

    /* PyObject_Print(out, stdout, 0); */

    Py_XDECREF(keys);
    Py_XDECREF(values);

    return out;

 error:
    Py_XDECREF(out);
    Py_XDECREF(keys);
    Py_XDECREF(values);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static HANDLE gethandle ( PyObject obj,
char *  name 
) [static]

Definition at line 311 of file _subprocess.c.

{
    sp_handle_object* value;
    HANDLE ret;

    value = (sp_handle_object*) PyObject_GetAttrString(obj, name);
    if (! value) {
        PyErr_Clear(); /* FIXME: propagate error? */
        return NULL;
    }
    if (Py_TYPE(value) != &sp_handle_type)
        ret = NULL;
    else
        ret = value->handle;
    Py_DECREF(value);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int getint ( PyObject obj,
char *  name 
) [static]

Definition at line 295 of file _subprocess.c.

{
    PyObject* value;
    int ret;

    value = PyObject_GetAttrString(obj, name);
    if (! value) {
        PyErr_Clear(); /* FIXME: propagate error? */
        return 0;
    }
    ret = (int) PyLong_AsLong(value);
    Py_DECREF(value);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyDoc_STRVAR ( GetStdHandle_doc  ,
"GetStdHandle(handle) -> integer\n\\n\Return a handle to the specified standard device\n\(STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).\n\The integer associated with the handle object is returned."   
)
PyDoc_STRVAR ( GetCurrentProcess_doc  ,
"GetCurrentProcess() -> handle\n\\n\Return a handle object for the current process."   
)
PyDoc_STRVAR ( DuplicateHandle_doc  ,
"DuplicateHandle(source_proc_handle, source_handle,\n\ target_proc_handle, target_handle, access,\n\ inherit[, options]) -> handle\n\\n\Return a duplicate handle object.\n\\n\The duplicate handle refers to the same object as the original\n\handle.  Therefore,
any changes to the object are reflected\n\through both handles."   
)
PyDoc_STRVAR ( CreatePipe_doc  ,
"CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)\n\\n\Create an anonymous  pipe,
and return handles to the read and\n\write ends of the pipe.\n\\n\pipe_attrs is ignored internally and can be None."   
)
PyDoc_STRVAR ( CreateProcess_doc  ,
"CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,\n\ inherit, flags, env_mapping, curdir,\n\ startup_info) -> (proc_handle, thread_handle,\n\ pid, tid)\n\\n\Create a new process and its primary thread. The return\n\value is a tuple of the process  handle,
thread  handle,
\n\process  ID,
and thread ID.\n\\n\proc_attrs and thread_attrs are ignored internally and can be None."   
)
PyDoc_STRVAR ( TerminateProcess_doc  ,
"TerminateProcess(handle, exit_code) -> None\n\\n\Terminate the specified process and all of its threads."   
)
PyDoc_STRVAR ( GetExitCodeProcess_doc  ,
"GetExitCodeProcess(handle) -> Exit code\n\\n\Return the termination status of the specified process."   
)
PyDoc_STRVAR ( WaitForSingleObject_doc  ,
"WaitForSingleObject(handle, timeout) -> result\n\\n\Wait until the specified object is in the signaled state or\n\the time-out interval elapses. The timeout value is specified\n\in milliseconds."   
)
PyDoc_STRVAR ( GetVersion_doc  ,
"GetVersion() -> version\n\\n\Return the version number of the current operating system."   
)
PyDoc_STRVAR ( GetModuleFileName_doc  ,
"GetModuleFileName(module) -> path\n\\n\Return the fully-qualified path for the file that contains\n\the specified module. The module must have been loaded by the\n\current process.\n\\n\The module parameter should be a handle to the loaded module\n\whose path is being requested. If this parameter is  0,
\n\GetModuleFileName retrieves the path of the executable file\n\of the current process."   
)

Definition at line 660 of file _subprocess.c.

{
    PyObject *d;
    PyObject *m;

    /* patch up object descriptors */
    sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int;
    if (PyType_Ready(&sp_handle_type) < 0)
        return NULL;

    m = PyModule_Create(&_subprocessmodule);
    if (m == NULL)
        return NULL;
    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, "STARTF_USESHOWWINDOW", STARTF_USESHOWWINDOW);
    defint(d, "SW_HIDE", SW_HIDE);
    defint(d, "INFINITE", INFINITE);
    defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0);
    defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE);
    defint(d, "CREATE_NEW_PROCESS_GROUP", CREATE_NEW_PROCESS_GROUP);

    return m;
}

Here is the call graph for this function:

static PyObject* sp_CreatePipe ( PyObject self,
PyObject args 
) [static]

Definition at line 269 of file _subprocess.c.

{
    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;

    Py_BEGIN_ALLOW_THREADS
    result = CreatePipe(&read_pipe, &write_pipe, NULL, size);
    Py_END_ALLOW_THREADS

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    return Py_BuildValue(
        "NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe));
}

Here is the call graph for this function:

static PyObject* sp_CreateProcess ( PyObject self,
PyObject args 
) [static]

Definition at line 417 of file _subprocess.c.

{
    BOOL result;
    PROCESS_INFORMATION pi;
    STARTUPINFOW si;
    PyObject* environment;

    Py_UNICODE* application_name;
    Py_UNICODE* command_line;
    PyObject* process_attributes; /* ignored */
    PyObject* thread_attributes; /* ignored */
    int inherit_handles;
    int creation_flags;
    PyObject* env_mapping;
    Py_UNICODE* 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,
                           &current_directory,
                           &startup_info))
        return NULL;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);

    /* note: we only support a small subset of all SI attributes */
    si.dwFlags = getint(startup_info, "dwFlags");
    si.wShowWindow = getint(startup_info, "wShowWindow");
    si.hStdInput = gethandle(startup_info, "hStdInput");
    si.hStdOutput = gethandle(startup_info, "hStdOutput");
    si.hStdError = gethandle(startup_info, "hStdError");

    if (PyErr_Occurred())
        return NULL;

    if (env_mapping == Py_None)
        environment = NULL;
    else {
        environment = getenvironment(env_mapping);
        if (! environment)
            return NULL;
    }

    Py_BEGIN_ALLOW_THREADS
    result = CreateProcessW(application_name,
                           command_line,
                           NULL,
                           NULL,
                           inherit_handles,
                           creation_flags | CREATE_UNICODE_ENVIRONMENT,
                           environment ? PyUnicode_AS_UNICODE(environment) : NULL,
                           current_directory,
                           &si,
                           &pi);
    Py_END_ALLOW_THREADS

    Py_XDECREF(environment);

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    return Py_BuildValue("NNii",
                         sp_handle_new(pi.hProcess),
                         sp_handle_new(pi.hThread),
                         pi.dwProcessId,
                         pi.dwThreadId);
}

Here is the call graph for this function:

static PyObject* sp_DuplicateHandle ( PyObject self,
PyObject args 
) [static]

Definition at line 219 of file _subprocess.c.

{
    HANDLE target_handle;
    BOOL result;

    HANDLE source_process_handle;
    HANDLE source_handle;
    HANDLE target_process_handle;
    int desired_access;
    int inherit_handle;
    int options = 0;

    if (! PyArg_ParseTuple(args,
                           PY_HANDLE_PARAM PY_HANDLE_PARAM PY_HANDLE_PARAM
                           "ii|i:DuplicateHandle",
                           &source_process_handle,
                           &source_handle,
                           &target_process_handle,
                           &desired_access,
                           &inherit_handle,
                           &options))
        return NULL;

    Py_BEGIN_ALLOW_THREADS
    result = DuplicateHandle(
        source_process_handle,
        source_handle,
        target_process_handle,
        &target_handle,
        desired_access,
        inherit_handle,
        options
    );
    Py_END_ALLOW_THREADS

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    return sp_handle_new(target_handle);
}

Here is the call graph for this function:

static PyObject* sp_GetCurrentProcess ( PyObject self,
PyObject args 
) [static]

Definition at line 199 of file _subprocess.c.

{
    if (! PyArg_ParseTuple(args, ":GetCurrentProcess"))
        return NULL;

    return sp_handle_new(GetCurrentProcess());
}

Here is the call graph for this function:

static PyObject* sp_GetExitCodeProcess ( PyObject self,
PyObject args 
) [static]

Definition at line 523 of file _subprocess.c.

{
    DWORD exit_code;
    BOOL result;

    HANDLE process;
    if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetExitCodeProcess", &process))
        return NULL;

    result = GetExitCodeProcess(process, &exit_code);

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    return PyLong_FromLong(exit_code);
}

Here is the call graph for this function:

static PyObject* sp_GetModuleFileName ( PyObject self,
PyObject args 
) [static]

Definition at line 596 of file _subprocess.c.

{
    BOOL result;
    HMODULE module;
    WCHAR filename[MAX_PATH];

    if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetModuleFileName",
                           &module))
        return NULL;

    result = GetModuleFileNameW(module, filename, MAX_PATH);
    filename[MAX_PATH-1] = '\0';

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    return PyUnicode_FromUnicode(filename, Py_UNICODE_strlen(filename));
}

Here is the call graph for this function:

static PyObject* sp_GetStdHandle ( PyObject self,
PyObject args 
) [static]

Definition at line 169 of file _subprocess.c.

{
    HANDLE handle;
    int std_handle;

    if (! PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle))
        return NULL;

    Py_BEGIN_ALLOW_THREADS
    handle = GetStdHandle((DWORD) std_handle);
    Py_END_ALLOW_THREADS

    if (handle == INVALID_HANDLE_VALUE)
        return PyErr_SetFromWindowsErr(GetLastError());

    if (! handle) {
        Py_INCREF(Py_None);
        return Py_None;
    }

    /* note: returns integer, not handle object */
    return HANDLE_TO_PYNUM(handle);
}

Here is the call graph for this function:

static PyObject* sp_GetVersion ( PyObject self,
PyObject args 
) [static]

Definition at line 575 of file _subprocess.c.

{
    if (! PyArg_ParseTuple(args, ":GetVersion"))
        return NULL;

    return PyLong_FromLong((int) GetVersion());
}

Here is the call graph for this function:

static PyObject* sp_handle_as_int ( sp_handle_object self) [static]

Definition at line 122 of file _subprocess.c.

{
    return HANDLE_TO_PYNUM(self->handle);
}

Here is the caller graph for this function:

static PyObject* sp_handle_close ( sp_handle_object self,
PyObject args 
) [static]

Definition at line 94 of file _subprocess.c.

{
    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;
}

Here is the call graph for this function:

static void sp_handle_dealloc ( sp_handle_object self) [static]

Definition at line 108 of file _subprocess.c.

{
    if (self->handle != INVALID_HANDLE_VALUE)
        CloseHandle(self->handle);
    PyObject_FREE(self);
}
static PyObject* sp_handle_detach ( sp_handle_object self,
PyObject args 
) [static]

Definition at line 78 of file _subprocess.c.

{
    HANDLE handle;

    if (! PyArg_ParseTuple(args, ":Detach"))
        return NULL;

    handle = self->handle;

    self->handle = INVALID_HANDLE_VALUE;

    /* note: return the current handle, as an integer */
    return HANDLE_TO_PYNUM(handle);
}

Here is the call graph for this function:

static PyObject* sp_handle_new ( HANDLE  handle) [static]

Definition at line 56 of file _subprocess.c.

{
    sp_handle_object* self;

    self = PyObject_NEW(sp_handle_object, &sp_handle_type);
    if (self == NULL)
        return NULL;

    self->handle = handle;

    return (PyObject*) self;
}

Here is the caller graph for this function:

static PyObject* sp_TerminateProcess ( PyObject self,
PyObject args 
) [static]

Definition at line 498 of file _subprocess.c.

{
    BOOL result;

    HANDLE process;
    int exit_code;
    if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:TerminateProcess",
                           &process, &exit_code))
        return NULL;

    result = TerminateProcess(process, exit_code);

    if (! result)
        return PyErr_SetFromWindowsErr(GetLastError());

    Py_INCREF(Py_None);
    return Py_None;
}

Here is the call graph for this function:

static PyObject* sp_WaitForSingleObject ( PyObject self,
PyObject args 
) [static]

Definition at line 548 of file _subprocess.c.

{
    DWORD result;

    HANDLE handle;
    int milliseconds;
    if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:WaitForSingleObject",
                                 &handle,
                                 &milliseconds))
        return NULL;

    Py_BEGIN_ALLOW_THREADS
    result = WaitForSingleObject(handle, (DWORD) milliseconds);
    Py_END_ALLOW_THREADS

    if (result == WAIT_FAILED)
        return PyErr_SetFromWindowsErr(GetLastError());

    return PyLong_FromLong((int) result);
}

Here is the call graph for this function:


Variable Documentation

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "_subprocess",
    NULL,
    -1,
    sp_functions,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 647 of file _subprocess.c.

Initial value:
 {
    {"GetStdHandle", sp_GetStdHandle, METH_VARARGS, GetStdHandle_doc},
    {"GetCurrentProcess", sp_GetCurrentProcess,         METH_VARARGS,
                                              GetCurrentProcess_doc},
    {"DuplicateHandle",         sp_DuplicateHandle,     METH_VARARGS,
                                            DuplicateHandle_doc},
    {"CreatePipe", sp_CreatePipe, METH_VARARGS, CreatePipe_doc},
    {"CreateProcess", sp_CreateProcess, METH_VARARGS, CreateProcess_doc},
    {"TerminateProcess", sp_TerminateProcess, METH_VARARGS,
                                             TerminateProcess_doc},
    {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS,
                                               GetExitCodeProcess_doc},
    {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS,
                                                    WaitForSingleObject_doc},
    {"GetVersion", sp_GetVersion, METH_VARARGS, GetVersion_doc},
    {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS,
                                              GetModuleFileName_doc},
    {NULL, NULL}
}

Definition at line 615 of file _subprocess.c.

Definition at line 127 of file _subprocess.c.

Initial value:

Definition at line 115 of file _subprocess.c.

static PyTypeObject sp_handle_type [static]
Initial value:
 {
    PyVarObject_HEAD_INIT(NULL, 0)
    "_subprocess_handle", sizeof(sp_handle_object), 0,
    (destructor) sp_handle_dealloc, 
    0, 
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    &sp_handle_as_number,               
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    Py_TPFLAGS_DEFAULT,                 
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    sp_handle_methods,                  
}

Definition at line 53 of file _subprocess.c.