/* * History: First version dated from 3/97, derived from my SCMLIB version * for win16. */ /* * Related Work: * - calldll http://www.nightmare.com/software.html * - libffi http://sourceware.cygnus.com/libffi/ * - ffcall http://clisp.cons.org/~haible/packages-ffcall.html * and, of course, Don Beaudry's MESS package, but this is more ctypes * related. */ /* How are functions called, and how are parameters converted to C ? 1. _ctypes.c::PyCFuncPtr_call receives an argument tuple 'inargs' and a keyword dictionary 'kwds'. 2. After several checks, _build_callargs() is called which returns another tuple 'callargs'. This may be the same tuple as 'inargs', a slice of 'inargs', or a completely fresh tuple, depending on several things (is it a COM method?, are 'paramflags' available?). 3. _build_callargs also calculates bitarrays containing indexes into the callargs tuple, specifying how to build the return value(s) of the function. 4. _ctypes_callproc is then called with the 'callargs' tuple. _ctypes_callproc first allocates two arrays. The first is an array of 'struct argument' items, the second array has 'void *' entries. 5. If 'converters' are present (converters is a sequence of argtypes' from_param methods), for each item in 'callargs' converter is called and the result passed to ConvParam. If 'converters' are not present, each argument is directly passed to ConvParm. 6. For each arg, ConvParam stores the contained C data (or a pointer to it, for structures) into the 'struct argument' array. 7. Finally, a loop fills the 'void *' array so that each item points to the data contained in or pointed to by the 'struct argument' array. 8. The 'void *' argument array is what _call_function_pointer expects. _call_function_pointer then has very little to do - only some libffi specific stuff, then it calls ffi_call. So, there are 4 data structures holding processed arguments: - the inargs tuple (in PyCFuncPtr_call) - the callargs tuple (in PyCFuncPtr_call) - the 'struct arguments' array - the 'void *' array */ /*[clinic input] module _ctypes [clinic start generated code]*/ /*[clinic end generated code: output=da39a3ee5e6b4b0d input=476a19c49b31a75c]*/ #ifndef Py_BUILD_CORE_BUILTIN #define Py_BUILD_CORE_MODULE … #endif #include "Python.h" #include <stdbool.h> #ifdef MS_WIN32 #include <windows.h> #include <tchar.h> #else #include <dlfcn.h> #endif #ifdef __APPLE__ #include <mach-o/dyld.h> #endif #ifdef MS_WIN32 #include <malloc.h> #endif #include <ffi.h> #include "ctypes.h" #ifdef HAVE_ALLOCA_H /* AIX needs alloca.h for alloca() */ #include <alloca.h> #endif #ifdef _Py_MEMORY_SANITIZER #include <sanitizer/msan_interface.h> #endif #if defined(_DEBUG) || defined(__MINGW32__) /* Don't use structured exception handling on Windows if this is defined. MingW, AFAIK, doesn't support it. */ #define DONT_USE_SEH #endif #include "pycore_runtime.h" // _PyRuntime #include "pycore_global_objects.h"// _Py_ID() #include "pycore_traceback.h" // _PyTraceback_Add() #if defined(Py_HAVE_C_COMPLEX) && defined(Py_FFI_SUPPORT_C_COMPLEX) #include "../_complex.h" // complex #endif #include "clinic/callproc.c.h" #define CTYPES_CAPSULE_NAME_PYMEM … static void pymem_destructor(PyObject *ptr) { … } /* ctypes maintains thread-local storage that has space for two error numbers: private copies of the system 'errno' value and, on Windows, the system error code accessed by the GetLastError() and SetLastError() api functions. Foreign functions created with CDLL(..., use_errno=True), when called, swap the system 'errno' value with the private copy just before the actual function call, and swapped again immediately afterwards. The 'use_errno' parameter defaults to False, in this case 'ctypes_errno' is not touched. On Windows, foreign functions created with CDLL(..., use_last_error=True) or WinDLL(..., use_last_error=True) swap the system LastError value with the ctypes private copy. The values are also swapped immediately before and after ctypes callback functions are called, if the callbacks are constructed using the new optional use_errno parameter set to True: CFUNCTYPE(..., use_errno=TRUE) or WINFUNCTYPE(..., use_errno=True). New ctypes functions are provided to access the ctypes private copies from Python: - ctypes.set_errno(value) and ctypes.set_last_error(value) store 'value' in the private copy and returns the previous value. - ctypes.get_errno() and ctypes.get_last_error() returns the current ctypes private copies value. */ /* This function creates and returns a thread-local Python object that has space to store two integer error numbers; once created the Python object is kept alive in the thread state dictionary as long as the thread itself. */ PyObject * _ctypes_get_errobj(ctypes_state *st, int **pspace) { … } static PyObject * get_error_internal(PyObject *self, PyObject *args, int index) { … } static PyObject * set_error_internal(PyObject *self, PyObject *args, int index) { … } static PyObject * get_errno(PyObject *self, PyObject *args) { … } static PyObject * set_errno(PyObject *self, PyObject *args) { … } #ifdef MS_WIN32 static PyObject * get_last_error(PyObject *self, PyObject *args) { if (PySys_Audit("ctypes.get_last_error", NULL) < 0) { return NULL; } return get_error_internal(self, args, 1); } static PyObject * set_last_error(PyObject *self, PyObject *args) { if (PySys_Audit("ctypes.set_last_error", "O", args) < 0) { return NULL; } return set_error_internal(self, args, 1); } static WCHAR *FormatError(DWORD code) { WCHAR *lpMsgBuf; DWORD n; n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */ (LPWSTR) &lpMsgBuf, 0, NULL); if (n) { while (iswspace(lpMsgBuf[n-1])) --n; lpMsgBuf[n] = L'\0'; /* rstrip() */ } return lpMsgBuf; } #ifndef DONT_USE_SEH static void SetException(DWORD code, EXCEPTION_RECORD *pr) { if (PySys_Audit("ctypes.set_exception", "I", code) < 0) { /* An exception was set by the audit hook */ return; } /* The 'code' is a normal win32 error code so it could be handled by PyErr_SetFromWindowsErr(). However, for some errors, we have additional information not included in the error code. We handle those here and delegate all others to the generic function. */ switch (code) { case EXCEPTION_ACCESS_VIOLATION: /* The thread attempted to read from or write to a virtual address for which it does not have the appropriate access. */ if (pr->ExceptionInformation[0] == 0) PyErr_Format(PyExc_OSError, "exception: access violation reading %p", pr->ExceptionInformation[1]); else PyErr_Format(PyExc_OSError, "exception: access violation writing %p", pr->ExceptionInformation[1]); break; case EXCEPTION_BREAKPOINT: /* A breakpoint was encountered. */ PyErr_SetString(PyExc_OSError, "exception: breakpoint encountered"); break; case EXCEPTION_DATATYPE_MISALIGNMENT: /* The thread attempted to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit values must be aligned on 2-byte boundaries, 32-bit values on 4-byte boundaries, and so on. */ PyErr_SetString(PyExc_OSError, "exception: datatype misalignment"); break; case EXCEPTION_SINGLE_STEP: /* A trace trap or other single-instruction mechanism signaled that one instruction has been executed. */ PyErr_SetString(PyExc_OSError, "exception: single step"); break; case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: /* The thread attempted to access an array element that is out of bounds, and the underlying hardware supports bounds checking. */ PyErr_SetString(PyExc_OSError, "exception: array bounds exceeded"); break; case EXCEPTION_FLT_DENORMAL_OPERAND: /* One of the operands in a floating-point operation is denormal. A denormal value is one that is too small to represent as a standard floating-point value. */ PyErr_SetString(PyExc_OSError, "exception: floating-point operand denormal"); break; case EXCEPTION_FLT_DIVIDE_BY_ZERO: /* The thread attempted to divide a floating-point value by a floating-point divisor of zero. */ PyErr_SetString(PyExc_OSError, "exception: float divide by zero"); break; case EXCEPTION_FLT_INEXACT_RESULT: /* The result of a floating-point operation cannot be represented exactly as a decimal fraction. */ PyErr_SetString(PyExc_OSError, "exception: float inexact"); break; case EXCEPTION_FLT_INVALID_OPERATION: /* This exception represents any floating-point exception not included in this list. */ PyErr_SetString(PyExc_OSError, "exception: float invalid operation"); break; case EXCEPTION_FLT_OVERFLOW: /* The exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type. */ PyErr_SetString(PyExc_OSError, "exception: float overflow"); break; case EXCEPTION_FLT_STACK_CHECK: /* The stack overflowed or underflowed as the result of a floating-point operation. */ PyErr_SetString(PyExc_OSError, "exception: stack over/underflow"); break; case EXCEPTION_STACK_OVERFLOW: /* The stack overflowed or underflowed as the result of a floating-point operation. */ PyErr_SetString(PyExc_OSError, "exception: stack overflow"); break; case EXCEPTION_FLT_UNDERFLOW: /* The exponent of a floating-point operation is less than the magnitude allowed by the corresponding type. */ PyErr_SetString(PyExc_OSError, "exception: float underflow"); break; case EXCEPTION_INT_DIVIDE_BY_ZERO: /* The thread attempted to divide an integer value by an integer divisor of zero. */ PyErr_SetString(PyExc_OSError, "exception: integer divide by zero"); break; case EXCEPTION_INT_OVERFLOW: /* The result of an integer operation caused a carry out of the most significant bit of the result. */ PyErr_SetString(PyExc_OSError, "exception: integer overflow"); break; case EXCEPTION_PRIV_INSTRUCTION: /* The thread attempted to execute an instruction whose operation is not allowed in the current machine mode. */ PyErr_SetString(PyExc_OSError, "exception: privileged instruction"); break; case EXCEPTION_NONCONTINUABLE_EXCEPTION: /* The thread attempted to continue execution after a noncontinuable exception occurred. */ PyErr_SetString(PyExc_OSError, "exception: nocontinuable"); break; default: PyErr_SetFromWindowsErr(code); break; } } static DWORD HandleException(EXCEPTION_POINTERS *ptrs, DWORD *pdw, EXCEPTION_RECORD *record) { *pdw = ptrs->ExceptionRecord->ExceptionCode; *record = *ptrs->ExceptionRecord; /* We don't want to catch breakpoint exceptions, they are used to attach * a debugger to the process. */ if (*pdw == EXCEPTION_BREAKPOINT) return EXCEPTION_CONTINUE_SEARCH; return EXCEPTION_EXECUTE_HANDLER; } #endif static PyObject * check_hresult(PyObject *self, PyObject *args) { HRESULT hr; if (!PyArg_ParseTuple(args, "i", &hr)) return NULL; if (FAILED(hr)) return PyErr_SetFromWindowsErr(hr); return PyLong_FromLong(hr); } #endif /**************************************************************/ PyCArgObject * PyCArgObject_new(ctypes_state *st) { … } static int PyCArg_traverse(PyCArgObject *self, visitproc visit, void *arg) { … } static int PyCArg_clear(PyCArgObject *self) { … } static void PyCArg_dealloc(PyCArgObject *self) { … } static int is_literal_char(unsigned char c) { … } static PyObject * PyCArg_repr(PyCArgObject *self) { … } static PyMemberDef PyCArgType_members[] = …; static PyType_Slot carg_slots[] = …; PyType_Spec carg_spec = …; /****************************************************************/ /* * Convert a PyObject * into a parameter suitable to pass to an * C function call. * * 1. Python integers are converted to C int and passed by value. * Py_None is converted to a C NULL pointer. * * 2. 3-tuples are expected to have a format character in the first * item, which must be 'i', 'f', 'd', 'q', or 'P'. * The second item will have to be an integer, float, double, long long * or integer (denoting an address void *), will be converted to the * corresponding C data type and passed by value. * * 3. Other Python objects are tested for an '_as_parameter_' attribute. * The value of this attribute must be an integer which will be passed * by value, or a 2-tuple or 3-tuple which will be used according * to point 2 above. The third item (if any), is ignored. It is normally * used to keep the object alive where this parameter refers to. * XXX This convention is dangerous - you can construct arbitrary tuples * in Python and pass them. Would it be safer to use a custom container * datatype instead of a tuple? * * 4. Other Python objects cannot be passed as parameters - an exception is raised. * * 5. ConvParam will store the converted result in a struct containing format * and value. */ result; struct argument { … }; /* * Convert a single Python object into a PyCArgObject and return it. */ static int ConvParam(ctypes_state *st, PyObject *obj, Py_ssize_t index, struct argument *pa) { … } #if defined(MS_WIN32) && !defined(_WIN32_WCE) /* Per: https://msdn.microsoft.com/en-us/library/7572ztz4.aspx To be returned by value in RAX, user-defined types must have a length of 1, 2, 4, 8, 16, 32, or 64 bits */ int can_return_struct_as_int(size_t s) { return s == 1 || s == 2 || s == 4; } int can_return_struct_as_sint64(size_t s) { #ifdef _M_ARM // 8 byte structs cannot be returned in a register on ARM32 return 0; #else return s == 8; #endif } #endif // returns NULL with exception set on error ffi_type *_ctypes_get_ffi_type(ctypes_state *st, PyObject *obj) { … } /* * libffi uses: * * ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi, * unsigned int nargs, * ffi_type *rtype, * ffi_type **atypes); * * and then * * void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues); */ static int _call_function_pointer(ctypes_state *st, int flags, PPROC pProc, void **avalues, ffi_type **atypes, ffi_type *restype, void *resmem, int argcount, int argtypecount) { … } /* * Convert the C value in result into a Python object, depending on restype. * * - If restype is NULL, return a Python integer. * - If restype is None, return None. * - If restype is a simple ctypes type (c_int, c_void_p), call the type's getfunc, * pass the result to checker and return the result. * - If restype is another ctypes type, return an instance of that. * - Otherwise, call restype and return the result. */ static PyObject *GetResult(ctypes_state *st, PyObject *restype, void *result, PyObject *checker) { … } /* * Raise a new exception 'exc_class', adding additional text to the original * exception string. */ void _ctypes_extend_error(PyObject *exc_class, const char *fmt, ...) { … } #ifdef MS_WIN32 static PyObject * GetComError(ctypes_state *st, HRESULT errcode, GUID *riid, IUnknown *pIunk) { HRESULT hr; ISupportErrorInfo *psei = NULL; IErrorInfo *pei = NULL; BSTR descr=NULL, helpfile=NULL, source=NULL; GUID guid; DWORD helpcontext=0; LPOLESTR progid; PyObject *obj; LPOLESTR text; /* We absolutely have to release the GIL during COM method calls, otherwise we may get a deadlock! */ Py_BEGIN_ALLOW_THREADS hr = pIunk->lpVtbl->QueryInterface(pIunk, &IID_ISupportErrorInfo, (void **)&psei); if (FAILED(hr)) goto failed; hr = psei->lpVtbl->InterfaceSupportsErrorInfo(psei, riid); psei->lpVtbl->Release(psei); if (FAILED(hr)) goto failed; hr = GetErrorInfo(0, &pei); if (hr != S_OK) goto failed; pei->lpVtbl->GetDescription(pei, &descr); pei->lpVtbl->GetGUID(pei, &guid); pei->lpVtbl->GetHelpContext(pei, &helpcontext); pei->lpVtbl->GetHelpFile(pei, &helpfile); pei->lpVtbl->GetSource(pei, &source); pei->lpVtbl->Release(pei); failed: Py_END_ALLOW_THREADS progid = NULL; ProgIDFromCLSID(&guid, &progid); text = FormatError(errcode); obj = Py_BuildValue( "iu(uuuiu)", errcode, text, descr, source, helpfile, helpcontext, progid); if (obj) { PyErr_SetObject((PyObject *)st->PyComError_Type, obj); Py_DECREF(obj); } LocalFree(text); if (descr) SysFreeString(descr); if (helpfile) SysFreeString(helpfile); if (source) SysFreeString(source); return NULL; } #endif #if (defined(__x86_64__) && (defined(__MINGW64__) || defined(__CYGWIN__))) || \ defined(__aarch64__) || defined(__riscv) #define CTYPES_PASS_BY_REF_HACK #define POW2 … #define IS_PASS_BY_REF … #endif /* * Requirements, must be ensured by the caller: * - argtuple is tuple of arguments * - argtypes is either NULL, or a tuple of the same size as argtuple * * - XXX various requirements for restype, not yet collected */ PyObject *_ctypes_callproc(ctypes_state *st, PPROC pProc, PyObject *argtuple, #ifdef MS_WIN32 IUnknown *pIunk, GUID *iid, #endif int flags, PyObject *argtypes, /* misleading name: This is a tuple of methods, not types: the .from_param class methods of the types */ PyObject *restype, PyObject *checker) { … } static int _parse_voidp(PyObject *obj, void **address) { … } #ifdef MS_WIN32 PyDoc_STRVAR(format_error_doc, "FormatError([integer]) -> string\n\ \n\ Convert a win32 error code into a string. If the error code is not\n\ given, the return value of a call to GetLastError() is used.\n"); static PyObject *format_error(PyObject *self, PyObject *args) { PyObject *result; wchar_t *lpMsgBuf; DWORD code = 0; if (!PyArg_ParseTuple(args, "|i:FormatError", &code)) return NULL; if (code == 0) code = GetLastError(); lpMsgBuf = FormatError(code); if (lpMsgBuf) { result = PyUnicode_FromWideChar(lpMsgBuf, wcslen(lpMsgBuf)); LocalFree(lpMsgBuf); } else { result = PyUnicode_FromString("<no description>"); } return result; } PyDoc_STRVAR(load_library_doc, "LoadLibrary(name, load_flags) -> handle\n\ \n\ Load an executable (usually a DLL), and return a handle to it.\n\ The handle may be used to locate exported functions in this\n\ module. load_flags are as defined for LoadLibraryEx in the\n\ Windows API.\n"); static PyObject *load_library(PyObject *self, PyObject *args) { PyObject *nameobj; int load_flags = 0; HMODULE hMod; DWORD err; if (!PyArg_ParseTuple(args, "U|i:LoadLibrary", &nameobj, &load_flags)) return NULL; if (PySys_Audit("ctypes.dlopen", "O", nameobj) < 0) { return NULL; } WCHAR *name = PyUnicode_AsWideCharString(nameobj, NULL); if (!name) return NULL; Py_BEGIN_ALLOW_THREADS /* bpo-36085: Limit DLL search directories to avoid pre-loading * attacks and enable use of the AddDllDirectory function. */ hMod = LoadLibraryExW(name, NULL, (DWORD)load_flags); err = hMod ? 0 : GetLastError(); Py_END_ALLOW_THREADS PyMem_Free(name); if (err == ERROR_MOD_NOT_FOUND) { PyErr_Format(PyExc_FileNotFoundError, ("Could not find module '%.500S' (or one of its " "dependencies). Try using the full path with " "constructor syntax."), nameobj); return NULL; } else if (err) { return PyErr_SetFromWindowsErr(err); } #ifdef _WIN64 return PyLong_FromVoidPtr(hMod); #else return PyLong_FromLong((int)hMod); #endif } PyDoc_STRVAR(free_library_doc, "FreeLibrary(handle) -> void\n\ \n\ Free the handle of an executable previously loaded by LoadLibrary.\n"); static PyObject *free_library(PyObject *self, PyObject *args) { void *hMod; BOOL result; DWORD err; if (!PyArg_ParseTuple(args, "O&:FreeLibrary", &_parse_voidp, &hMod)) return NULL; Py_BEGIN_ALLOW_THREADS result = FreeLibrary((HMODULE)hMod); err = result ? 0 : GetLastError(); Py_END_ALLOW_THREADS if (!result) { return PyErr_SetFromWindowsErr(err); } Py_RETURN_NONE; } PyDoc_STRVAR(copy_com_pointer_doc, "CopyComPointer(src, dst) -> HRESULT value\n"); static PyObject * copy_com_pointer(PyObject *self, PyObject *args) { PyObject *p1, *p2, *r = NULL; struct argument a, b; IUnknown *src, **pdst; if (!PyArg_ParseTuple(args, "OO:CopyComPointer", &p1, &p2)) return NULL; a.keep = b.keep = NULL; ctypes_state *st = get_module_state(self); if (ConvParam(st, p1, 0, &a) < 0 || ConvParam(st, p2, 1, &b) < 0) { goto done; } src = (IUnknown *)a.value.p; pdst = (IUnknown **)b.value.p; if (pdst == NULL) r = PyLong_FromLong(E_POINTER); else { if (src) src->lpVtbl->AddRef(src); *pdst = src; r = PyLong_FromLong(S_OK); } done: Py_XDECREF(a.keep); Py_XDECREF(b.keep); return r; } #else #ifdef __APPLE__ #ifdef HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH # ifdef HAVE_BUILTIN_AVAILABLE #define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME … # else #define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME … # endif #else // Support the deprecated case of compiling on an older macOS version static void *libsystem_b_handle; static bool (*_dyld_shared_cache_contains_path)(const char *path); __attribute__((constructor)) void load_dyld_shared_cache_contains_path(void) { libsystem_b_handle = dlopen("/usr/lib/libSystem.B.dylib", RTLD_LAZY); if (libsystem_b_handle != NULL) { _dyld_shared_cache_contains_path = dlsym(libsystem_b_handle, "_dyld_shared_cache_contains_path"); } } __attribute__((destructor)) void unload_dyld_shared_cache_contains_path(void) { if (libsystem_b_handle != NULL) { dlclose(libsystem_b_handle); } } #define HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME … #endif static PyObject *py_dyld_shared_cache_contains_path(PyObject *self, PyObject *args) { PyObject *name, *name2; char *name_str; if (HAVE_DYLD_SHARED_CACHE_CONTAINS_PATH_RUNTIME) { int r; if (!PyArg_ParseTuple(args, "O", &name)) return NULL; if (name == Py_None) Py_RETURN_FALSE; if (PyUnicode_FSConverter(name, &name2) == 0) return NULL; name_str = PyBytes_AS_STRING(name2); r = _dyld_shared_cache_contains_path(name_str); Py_DECREF(name2); if (r) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } else { PyErr_SetString(PyExc_NotImplementedError, "_dyld_shared_cache_contains_path symbol is missing"); return NULL; } } #endif static PyObject *py_dl_open(PyObject *self, PyObject *args) { … } static PyObject *py_dl_close(PyObject *self, PyObject *args) { … } static PyObject *py_dl_sym(PyObject *self, PyObject *args) { … } #endif /* * Only for debugging so far: So that we can call CFunction instances * * XXX Needs to accept more arguments: flags, argtypes, restype */ static PyObject * call_function(PyObject *self, PyObject *args) { … } /* * Only for debugging so far: So that we can call CFunction instances * * XXX Needs to accept more arguments: flags, argtypes, restype */ static PyObject * call_cdeclfunction(PyObject *self, PyObject *args) { … } /***************************************************************** * functions */ PyDoc_STRVAR(sizeof_doc, "sizeof(C type) -> integer\n" "sizeof(C instance) -> integer\n" "Return the size in bytes of a C instance"); static PyObject * sizeof_func(PyObject *self, PyObject *obj) { … } PyDoc_STRVAR(alignment_doc, "alignment(C type) -> integer\n" "alignment(C instance) -> integer\n" "Return the alignment requirements of a C instance"); static PyObject * align_func(PyObject *self, PyObject *obj) { … } PyDoc_STRVAR(byref_doc, "byref(C instance[, offset=0]) -> byref-object\n" "Return a pointer lookalike to a C instance, only usable\n" "as function argument"); /* * We must return something which can be converted to a parameter, * but still has a reference to self. */ static PyObject * byref(PyObject *self, PyObject *args) { … } PyDoc_STRVAR(addressof_doc, "addressof(C instance) -> integer\n" "Return the address of the C instance internal buffer"); static PyObject * addressof(PyObject *self, PyObject *obj) { … } static int converter(PyObject *obj, void **address) { … } static PyObject * My_PyObj_FromPtr(PyObject *self, PyObject *args) { … } static PyObject * My_Py_INCREF(PyObject *self, PyObject *arg) { … } static PyObject * My_Py_DECREF(PyObject *self, PyObject *arg) { … } static PyObject * resize(PyObject *self, PyObject *args) { … } static PyObject * unpickle(PyObject *self, PyObject *args) { … } /*[clinic input] _ctypes.POINTER as create_pointer_type type as cls: object A ctypes type. / Create and return a new ctypes pointer type. Pointer types are cached and reused internally, so calling this function repeatedly is cheap. [clinic start generated code]*/ static PyObject * create_pointer_type(PyObject *module, PyObject *cls) /*[clinic end generated code: output=98c3547ab6f4f40b input=3b81cff5ff9b9d5b]*/ { … } /*[clinic input] _ctypes.pointer as create_pointer_inst obj as arg: object / Create a new pointer instance, pointing to 'obj'. The returned object is of the type POINTER(type(obj)). Note that if you just want to pass a pointer to an object to a foreign function call, you should use byref(obj) which is much faster. [clinic start generated code]*/ static PyObject * create_pointer_inst(PyObject *module, PyObject *arg) /*[clinic end generated code: output=3b543bc9f0de2180 input=713685fdb4d9bc27]*/ { … } static PyObject * buffer_info(PyObject *self, PyObject *arg) { … } PyMethodDef _ctypes_module_methods[] = …; /* Local Variables: compile-command: "cd .. && python setup.py -q build -g && python setup.py -q build install --home ~" End: */
Codebase Browser
cpython