mirrors
/
cpython
mirror of https://github.com/python/cpython.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Issue #3102: All global symbols that the _ctypes extension defines are 

now prefixed with 'Py' or '_ctypes'.
This commit is contained in:
Thomas Heller 2009-04-24 20:31:47 +00:00
parent ec21ccde12
commit 5c6af808f7
8 changed files with 527 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Misc/NEWS
View File

@ -244,6 +244,9 @@ Core and Builtins
Library
-------
- Issue #3102: All global symbols that the _ctypes extension defines
are now prefixed with 'Py' or '_ctypes'.
- Issue #5041: ctypes does now allow pickling wide character.
- Issue #5812: For the two-argument form of the Fraction constructor,

671
Modules/_ctypes/_ctypes.c
View File

File diff suppressed because it is too large Load Diff

26
Modules/_ctypes/callbacks.c
View File

@ -22,7 +22,7 @@ CThunkObject_dealloc(PyObject *_self)
Py_XDECREF(self->callable);
Py_XDECREF(self->restype);
if (self->pcl)
FreeClosure(self->pcl);
_ctypes_free_closure(self->pcl);
PyObject_Del(self);
}
@ -46,7 +46,7 @@ CThunkObject_clear(PyObject *_self)
return 0;
}
PyTypeObject CThunk_Type = {
PyTypeObject PyCThunk_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_ctypes.CThunkObject",
sizeof(CThunkObject), /* tp_basicsize */
@ -97,7 +97,7 @@ PrintError(char *msg, ...)
/* after code that pyrex generates */
void _AddTraceback(char *funcname, char *filename, int lineno)
void _ctypes_add_traceback(char *funcname, char *filename, int lineno)
{
PyObject *py_srcfile = 0;
PyObject *py_funcname = 0;
@ -227,7 +227,7 @@ static void _CallPythonObject(void *mem,
goto Done;
}
if (dict && dict->getfunc && !IsSimpleSubType(cnv)) {
if (dict && dict->getfunc && !_ctypes_simple_instance(cnv)) {
PyObject *v = dict->getfunc(*pArgs, dict->size);
if (!v) {
PrintError("create argument %d:\n", i);
@ -241,7 +241,7 @@ static void _CallPythonObject(void *mem,
BTW, the same problem occurrs when they are pushed as parameters
*/
} else if (dict) {
/* Hm, shouldn't we use CData_AtAddress() or something like that instead? */
/* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */
CDataObject *obj = (CDataObject *)PyObject_CallFunctionObjArgs(cnv, NULL);
if (!obj) {
PrintError("create argument %d:\n", i);
@ -272,10 +272,10 @@ static void _CallPythonObject(void *mem,
}
#define CHECK(what, x) \
if (x == NULL) _AddTraceback(what, "_ctypes/callbacks.c", __LINE__ - 1), PyErr_Print()
if (x == NULL) _ctypes_add_traceback(what, "_ctypes/callbacks.c", __LINE__ - 1), PyErr_Print()
if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
error_object = get_error_object(&space);
error_object = _ctypes_get_errobj(&space);
if (error_object == NULL)
goto Done;
if (flags & FUNCFLAG_USE_ERRNO) {
@ -332,7 +332,7 @@ if (x == NULL) _AddTraceback(what, "_ctypes/callbacks.c", __LINE__ - 1), PyErr_P
PyErr_WriteUnraisable(callable);
else if (keep == Py_None) /* Nothing to keep */
Py_DECREF(keep);
else if (setfunc != getentry("O")->setfunc) {
else if (setfunc != _ctypes_get_fielddesc("O")->setfunc) {
if (-1 == PyErr_Warn(PyExc_RuntimeWarning,
"memory leak in callback function."))
PyErr_WriteUnraisable(callable);
@ -367,7 +367,7 @@ static CThunkObject* CThunkObject_new(Py_ssize_t nArgs)
CThunkObject *p;
int i;
p = PyObject_NewVar(CThunkObject, &CThunk_Type, nArgs);
p = PyObject_NewVar(CThunkObject, &PyCThunk_Type, nArgs);
if (p == NULL) {
PyErr_NoMemory();
return NULL;
@ -385,7 +385,7 @@ static CThunkObject* CThunkObject_new(Py_ssize_t nArgs)
return p;
}
CThunkObject *AllocFunctionCallback(PyObject *callable,
CThunkObject *_ctypes_alloc_callback(PyObject *callable,
PyObject *converters,
PyObject *restype,
int flags)
@ -402,7 +402,7 @@ CThunkObject *AllocFunctionCallback(PyObject *callable,
assert(CThunk_CheckExact(p));
p->pcl = MallocClosure();
p->pcl = _ctypes_alloc_closure();
if (p->pcl == NULL) {
PyErr_NoMemory();
goto error;
@ -413,7 +413,7 @@ CThunkObject *AllocFunctionCallback(PyObject *callable,
PyObject *cnv = PySequence_GetItem(converters, i);
if (cnv == NULL)
goto error;
p->atypes[i] = GetType(cnv);
p->atypes[i] = _ctypes_get_ffi_type(cnv);
Py_DECREF(cnv);
}
p->atypes[i] = NULL;
@ -441,7 +441,7 @@ CThunkObject *AllocFunctionCallback(PyObject *callable,
#endif
result = ffi_prep_cif(&p->cif, cc,
Py_SAFE_DOWNCAST(nArgs, Py_ssize_t, int),
GetType(restype),
_ctypes_get_ffi_type(restype),
&p->atypes[0]);
if (result != FFI_OK) {
PyErr_Format(PyExc_RuntimeError,

82
Modules/_ctypes/callproc.c
View File

@ -20,7 +20,7 @@
/*
How are functions called, and how are parameters converted to C ?
1. _ctypes.c::CFuncPtr_call receives an argument tuple 'inargs' and a
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
@ -32,7 +32,7 @@
the callargs tuple, specifying how to build the return value(s) of
the function.
4. _CallProc is then called with the 'callargs' tuple. _CallProc first
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 *' entried.
@ -52,8 +52,8 @@
libffi specific stuff, then it calls ffi_call.
So, there are 4 data structures holding processed arguments:
- the inargs tuple (in CFuncPtr_call)
- the callargs tuple (in CFuncPtr_call)
- the inargs tuple (in PyCFuncPtr_call)
- the callargs tuple (in PyCFuncPtr_call)
- the 'struct argguments' array
- the 'void *' array
@ -118,7 +118,7 @@
kept alive in the thread state dictionary as long as the thread itself.
*/
PyObject *
get_error_object(int **pspace)
_ctypes_get_errobj(int **pspace)
{
PyObject *dict = PyThreadState_GetDict();
PyObject *errobj;
@ -158,7 +158,7 @@ static PyObject *
get_error_internal(PyObject *self, PyObject *args, int index)
{
int *space;
PyObject *errobj = get_error_object(&space);
PyObject *errobj = _ctypes_get_errobj(&space);
PyObject *result;
if (errobj == NULL)
@ -177,7 +177,7 @@ set_error_internal(PyObject *self, PyObject *args, int index)
if (!PyArg_ParseTuple(args, "i", &new_errno))
return NULL;
errobj = get_error_object(&space);
errobj = _ctypes_get_errobj(&space);
if (errobj == NULL)
return NULL;
old_errno = space[index];
@ -410,7 +410,7 @@ check_hresult(PyObject *self, PyObject *args)
/**************************************************************/
PyCArgObject *
new_CArgObject(void)
PyCArgObject_new(void)
{
PyCArgObject *p;
p = PyObject_New(PyCArgObject, &PyCArg_Type);
@ -708,7 +708,7 @@ static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
}
ffi_type *GetType(PyObject *obj)
ffi_type *_ctypes_get_ffi_type(PyObject *obj)
{
StgDictObject *dict;
if (obj == NULL)
@ -788,7 +788,7 @@ static int _call_function_pointer(int flags,
}
if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
error_object = get_error_object(&space);
error_object = _ctypes_get_errobj(&space);
if (error_object == NULL)
return -1;
}
@ -906,24 +906,24 @@ static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)
if (dict == NULL)
return PyObject_CallFunction(restype, "i", *(int *)result);
if (dict->getfunc && !IsSimpleSubType(restype)) {
if (dict->getfunc && !_ctypes_simple_instance(restype)) {
retval = dict->getfunc(result, dict->size);
/* If restype is py_object (detected by comparing getfunc with
O_get), we have to call Py_DECREF because O_get has already
called Py_INCREF.
*/
if (dict->getfunc == getentry("O")->getfunc) {
if (dict->getfunc == _ctypes_get_fielddesc("O")->getfunc) {
Py_DECREF(retval);
}
} else
retval = CData_FromBaseObj(restype, NULL, 0, result);
retval = PyCData_FromBaseObj(restype, NULL, 0, result);
if (!checker || !retval)
return retval;
v = PyObject_CallFunctionObjArgs(checker, retval, NULL);
if (v == NULL)
_AddTraceback("GetResult", "_ctypes/callproc.c", __LINE__-2);
_ctypes_add_traceback("GetResult", "_ctypes/callproc.c", __LINE__-2);
Py_DECREF(retval);
return v;
}
@ -932,7 +932,7 @@ static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)
* Raise a new exception 'exc_class', adding additional text to the original
* exception string.
*/
void Extend_Error_Info(PyObject *exc_class, char *fmt, ...)
void _ctypes_extend_error(PyObject *exc_class, char *fmt, ...)
{
va_list vargs;
PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;
@ -1057,7 +1057,7 @@ GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk)
*
* - XXX various requirements for restype, not yet collected
*/
PyObject *_CallProc(PPROC pProc,
PyObject *_ctypes_callproc(PPROC pProc,
PyObject *argtuple,
#ifdef MS_WIN32
IUnknown *pIunk,
@ -1110,7 +1110,7 @@ PyObject *_CallProc(PPROC pProc,
arg = PyTuple_GET_ITEM(argtuple, i); /* borrowed ref */
/* For cdecl functions, we allow more actual arguments
than the length of the argtypes tuple.
This is checked in _ctypes::CFuncPtr_Call
This is checked in _ctypes::PyCFuncPtr_Call
*/
if (argtypes && argtype_count > i) {
PyObject *v;
@ -1119,26 +1119,26 @@ PyObject *_CallProc(PPROC pProc,
arg,
NULL);
if (v == NULL) {
Extend_Error_Info(PyExc_ArgError, "argument %d: ", i+1);
_ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
goto cleanup;
}
err = ConvParam(v, i+1, pa);
Py_DECREF(v);
if (-1 == err) {
Extend_Error_Info(PyExc_ArgError, "argument %d: ", i+1);
_ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
goto cleanup;
}
} else {
err = ConvParam(arg, i+1, pa);
if (-1 == err) {
Extend_Error_Info(PyExc_ArgError, "argument %d: ", i+1);
_ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
goto cleanup; /* leaking ? */
}
}
}
rtype = GetType(restype);
rtype = _ctypes_get_ffi_type(restype);
resbuf = alloca(max(rtype->size, sizeof(ffi_arg)));
avalues = (void **)alloca(sizeof(void *) * argcount);
@ -1350,7 +1350,7 @@ call_commethod(PyObject *self, PyObject *args)
pIunk = (IUnknown *)(*(void **)(pcom->b_ptr));
lpVtbl = (PPROC *)(pIunk->lpVtbl);
result = _CallProc(lpVtbl[index],
result = _ctypes_callproc(lpVtbl[index],
arguments,
#ifdef MS_WIN32
pIunk,
@ -1473,7 +1473,7 @@ call_function(PyObject *self, PyObject *args)
&PyTuple_Type, &arguments))
return NULL;
result = _CallProc((PPROC)func,
result = _ctypes_callproc((PPROC)func,
arguments,
#ifdef MS_WIN32
NULL,
@ -1504,7 +1504,7 @@ call_cdeclfunction(PyObject *self, PyObject *args)
&PyTuple_Type, &arguments))
return NULL;
result = _CallProc((PPROC)func,
result = _ctypes_callproc((PPROC)func,
arguments,
#ifdef MS_WIN32
NULL,
@ -1596,7 +1596,7 @@ byref(PyObject *self, PyObject *args)
return NULL;
}
parg = new_CArgObject();
parg = PyCArgObject_new();
if (parg == NULL)
return NULL;
@ -1671,17 +1671,17 @@ set_conversion_mode(PyObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "zs:set_conversion_mode", &coding, &mode))
return NULL;
result = Py_BuildValue("(zz)", conversion_mode_encoding, conversion_mode_errors);
result = Py_BuildValue("(zz)", _ctypes_conversion_encoding, _ctypes_conversion_errors);
if (coding) {
PyMem_Free(conversion_mode_encoding);
conversion_mode_encoding = PyMem_Malloc(strlen(coding) + 1);
strcpy(conversion_mode_encoding, coding);
PyMem_Free(_ctypes_conversion_encoding);
_ctypes_conversion_encoding = PyMem_Malloc(strlen(coding) + 1);
strcpy(_ctypes_conversion_encoding, coding);
} else {
conversion_mode_encoding = NULL;
_ctypes_conversion_encoding = NULL;
}
PyMem_Free(conversion_mode_errors);
conversion_mode_errors = PyMem_Malloc(strlen(mode) + 1);
strcpy(conversion_mode_errors, mode);
PyMem_Free(_ctypes_conversion_errors);
_ctypes_conversion_errors = PyMem_Malloc(strlen(mode) + 1);
strcpy(_ctypes_conversion_errors, mode);
return result;
}
#endif
@ -1780,7 +1780,7 @@ POINTER(PyObject *self, PyObject *cls)
PyObject *key;
char *buf;
result = PyDict_GetItem(_pointer_type_cache, cls);
result = PyDict_GetItem(_ctypes_ptrtype_cache, cls);
if (result) {
Py_INCREF(result);
return result;
@ -1788,10 +1788,10 @@ POINTER(PyObject *self, PyObject *cls)
if (PyString_CheckExact(cls)) {
buf = alloca(strlen(PyString_AS_STRING(cls)) + 3 + 1);
sprintf(buf, "LP_%s", PyString_AS_STRING(cls));
result = PyObject_CallFunction((PyObject *)Py_TYPE(&Pointer_Type),
result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type),
"s(O){}",
buf,
&Pointer_Type);
&PyCPointer_Type);
if (result == NULL)
return result;
key = PyLong_FromVoidPtr(result);
@ -1799,10 +1799,10 @@ POINTER(PyObject *self, PyObject *cls)
typ = (PyTypeObject *)cls;
buf = alloca(strlen(typ->tp_name) + 3 + 1);
sprintf(buf, "LP_%s", typ->tp_name);
result = PyObject_CallFunction((PyObject *)Py_TYPE(&Pointer_Type),
result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type),
"s(O){sO}",
buf,
&Pointer_Type,
&PyCPointer_Type,
"_type_", cls);
if (result == NULL)
return result;
@ -1812,7 +1812,7 @@ POINTER(PyObject *self, PyObject *cls)
PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
return NULL;
}
if (-1 == PyDict_SetItem(_pointer_type_cache, key, result)) {
if (-1 == PyDict_SetItem(_ctypes_ptrtype_cache, key, result)) {
Py_DECREF(result);
Py_DECREF(key);
return NULL;
@ -1827,7 +1827,7 @@ pointer(PyObject *self, PyObject *arg)
PyObject *result;
PyObject *typ;
typ = PyDict_GetItem(_pointer_type_cache, (PyObject *)Py_TYPE(arg));
typ = PyDict_GetItem(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg));
if (typ)
return PyObject_CallFunctionObjArgs(typ, arg, NULL);
typ = POINTER(NULL, (PyObject *)Py_TYPE(arg));
@ -1865,7 +1865,7 @@ buffer_info(PyObject *self, PyObject *arg)
return Py_BuildValue("siN", dict->format, dict->ndim, shape);
}
PyMethodDef module_methods[] = {
PyMethodDef _ctypes_module_methods[] = {
{"get_errno", get_errno, METH_NOARGS},
{"set_errno", set_errno, METH_VARARGS},
{"POINTER", POINTER, METH_O },

92
Modules/_ctypes/cfield.c
View File

@ -12,10 +12,10 @@
/******************************************************************/
/*
CField_Type
PyCField_Type
*/
static PyObject *
CField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
PyCField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
CFieldObject *obj;
obj = (CFieldObject *)type->tp_alloc(type, 0);
@ -35,7 +35,7 @@ CField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
* prev_desc points to the type of the previous bitfield, if any.
*/
PyObject *
CField_FromDesc(PyObject *desc, Py_ssize_t index,
PyCField_FromDesc(PyObject *desc, Py_ssize_t index,
Py_ssize_t *pfield_size, int bitsize, int *pbitofs,
Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,
int pack, int big_endian)
@ -52,7 +52,7 @@ CField_FromDesc(PyObject *desc, Py_ssize_t index,
#define CONT_BITFIELD 2
#define EXPAND_BITFIELD 3
self = (CFieldObject *)PyObject_CallObject((PyObject *)&CField_Type,
self = (CFieldObject *)PyObject_CallObject((PyObject *)&PyCField_Type,
NULL);
if (self == NULL)
return NULL;
@ -102,7 +102,7 @@ CField_FromDesc(PyObject *desc, Py_ssize_t index,
/* Field descriptors for 'c_char * n' are be scpecial cased to
return a Python string instead of an Array object instance...
*/
if (ArrayTypeObject_Check(proto)) {
if (PyCArrayTypeObject_Check(proto)) {
StgDictObject *adict = PyType_stgdict(proto);
StgDictObject *idict;
if (adict && adict->proto) {
@ -113,14 +113,14 @@ CField_FromDesc(PyObject *desc, Py_ssize_t index,
Py_DECREF(self);
return NULL;
}
if (idict->getfunc == getentry("c")->getfunc) {
struct fielddesc *fd = getentry("s");
if (idict->getfunc == _ctypes_get_fielddesc("c")->getfunc) {
struct fielddesc *fd = _ctypes_get_fielddesc("s");
getfunc = fd->getfunc;
setfunc = fd->setfunc;
}
#ifdef CTYPES_UNICODE
if (idict->getfunc == getentry("u")->getfunc) {
struct fielddesc *fd = getentry("U");
if (idict->getfunc == _ctypes_get_fielddesc("u")->getfunc) {
struct fielddesc *fd = _ctypes_get_fielddesc("U");
getfunc = fd->getfunc;
setfunc = fd->setfunc;
}
@ -194,7 +194,7 @@ CField_FromDesc(PyObject *desc, Py_ssize_t index,
}
static int
CField_set(CFieldObject *self, PyObject *inst, PyObject *value)
PyCField_set(CFieldObject *self, PyObject *inst, PyObject *value)
{
CDataObject *dst;
char *ptr;
@ -206,12 +206,12 @@ CField_set(CFieldObject *self, PyObject *inst, PyObject *value)
"can't delete attribute");
return -1;
}
return CData_set(inst, self->proto, self->setfunc, value,
return PyCData_set(inst, self->proto, self->setfunc, value,
self->index, self->size, ptr);
}
static PyObject *
CField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type)
PyCField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type)
{
CDataObject *src;
if (inst == NULL) {
@ -220,51 +220,51 @@ CField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type)
}
assert(CDataObject_Check(inst));
src = (CDataObject *)inst;
return CData_get(self->proto, self->getfunc, inst,
return PyCData_get(self->proto, self->getfunc, inst,
self->index, self->size, src->b_ptr + self->offset);
}
static PyObject *
CField_get_offset(PyObject *self, void *data)
PyCField_get_offset(PyObject *self, void *data)
{
return PyInt_FromSsize_t(((CFieldObject *)self)->offset);
}
static PyObject *
CField_get_size(PyObject *self, void *data)
PyCField_get_size(PyObject *self, void *data)
{
return PyInt_FromSsize_t(((CFieldObject *)self)->size);
}
static PyGetSetDef CField_getset[] = {
{ "offset", CField_get_offset, NULL, "offset in bytes of this field" },
{ "size", CField_get_size, NULL, "size in bytes of this field" },
static PyGetSetDef PyCField_getset[] = {
{ "offset", PyCField_get_offset, NULL, "offset in bytes of this field" },
{ "size", PyCField_get_size, NULL, "size in bytes of this field" },
{ NULL, NULL, NULL, NULL },
};
static int
CField_traverse(CFieldObject *self, visitproc visit, void *arg)
PyCField_traverse(CFieldObject *self, visitproc visit, void *arg)
{
Py_VISIT(self->proto);
return 0;
}
static int
CField_clear(CFieldObject *self)
PyCField_clear(CFieldObject *self)
{
Py_CLEAR(self->proto);
return 0;
}
static void
CField_dealloc(PyObject *self)
PyCField_dealloc(PyObject *self)
{
CField_clear((CFieldObject *)self);
PyCField_clear((CFieldObject *)self);
self->ob_type->tp_free((PyObject *)self);
}
static PyObject *
CField_repr(CFieldObject *self)
PyCField_repr(CFieldObject *self)
{
PyObject *result;
Py_ssize_t bits = self->size >> 16;
@ -292,17 +292,17 @@ CField_repr(CFieldObject *self)
return result;
}
PyTypeObject CField_Type = {
PyTypeObject PyCField_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"_ctypes.CField", /* tp_name */
sizeof(CFieldObject), /* tp_basicsize */
0, /* tp_itemsize */
CField_dealloc, /* tp_dealloc */
PyCField_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc)CField_repr, /* tp_repr */
(reprfunc)PyCField_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
@ -314,23 +314,23 @@ PyTypeObject CField_Type = {
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
"Structure/Union member", /* tp_doc */
(traverseproc)CField_traverse, /* tp_traverse */
(inquiry)CField_clear, /* tp_clear */
(traverseproc)PyCField_traverse, /* tp_traverse */
(inquiry)PyCField_clear, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
CField_getset, /* tp_getset */
PyCField_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
(descrgetfunc)CField_get, /* tp_descr_get */
(descrsetfunc)CField_set, /* tp_descr_set */
(descrgetfunc)PyCField_get, /* tp_descr_get */
(descrsetfunc)PyCField_set, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
CField_new, /* tp_new */
PyCField_new, /* tp_new */
0, /* tp_free */
};
@ -1191,8 +1191,8 @@ u_set(void *ptr, PyObject *value, Py_ssize_t size)
if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (!value)
return NULL;
} else if (!PyUnicode_Check(value)) {
@ -1266,8 +1266,8 @@ U_set(void *ptr, PyObject *value, Py_ssize_t length)
if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (!value)
return NULL;
} else if (!PyUnicode_Check(value)) {
@ -1364,8 +1364,8 @@ z_set(void *ptr, PyObject *value, Py_ssize_t size)
return value;
} else if (PyUnicode_Check(value)) {
PyObject *str = PyUnicode_AsEncodedString(value,
conversion_mode_encoding,
conversion_mode_errors);
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (str == NULL)
return NULL;
*(char **)ptr = PyString_AS_STRING(str);
@ -1415,8 +1415,8 @@ Z_set(void *ptr, PyObject *value, Py_ssize_t size)
}
if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (!value)
return NULL;
} else if (PyInt_Check(value) || PyLong_Check(value)) {
@ -1509,8 +1509,8 @@ BSTR_set(void *ptr, PyObject *value, Py_ssize_t size)
value = NULL;
} else if (PyString_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
conversion_mode_encoding,
conversion_mode_errors);
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (!value)
return NULL;
} else if (PyUnicode_Check(value)) {
@ -1670,7 +1670,7 @@ static struct fielddesc formattable[] = {
*/
struct fielddesc *
getentry(char *fmt)
_ctypes_get_fielddesc(char *fmt)
{
static int initialized = 0;
struct fielddesc *table = formattable;
@ -1679,11 +1679,11 @@ getentry(char *fmt)
initialized = 1;
#ifdef CTYPES_UNICODE
if (sizeof(wchar_t) == sizeof(short))
getentry("u")->pffi_type = &ffi_type_sshort;
_ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sshort;
else if (sizeof(wchar_t) == sizeof(int))
getentry("u")->pffi_type = &ffi_type_sint;
_ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sint;
else if (sizeof(wchar_t) == sizeof(long))
getentry("u")->pffi_type = &ffi_type_slong;
_ctypes_get_fielddesc("u")->pffi_type = &ffi_type_slong;
#endif
}

124
Modules/_ctypes/ctypes.h
View File

@ -59,7 +59,7 @@ this buffer is too small, PyMem_Malloc will be called to create a larger one,
and this one is not used.
Making CDataObject a variable size object would be a better solution, but more
difficult in the presence of CFuncPtrObject. Maybe later.
difficult in the presence of PyCFuncPtrObject. Maybe later.
*/
union value {
char c[16];
@ -105,8 +105,8 @@ typedef struct {
ffi_type *ffi_restype;
ffi_type *atypes[1];
} CThunkObject;
extern PyTypeObject CThunk_Type;
#define CThunk_CheckExact(v) ((v)->ob_type == &CThunk_Type)
extern PyTypeObject PyCThunk_Type;
#define CThunk_CheckExact(v) ((v)->ob_type == &PyCThunk_Type)
typedef struct {
/* First part identical to tagCDataObject */
@ -137,61 +137,61 @@ typedef struct {
GUID *iid;
#endif
PyObject *paramflags;
} CFuncPtrObject;
} PyCFuncPtrObject;
extern PyTypeObject StgDict_Type;
#define StgDict_CheckExact(v) ((v)->ob_type == &StgDict_Type)
#define StgDict_Check(v) PyObject_TypeCheck(v, &StgDict_Type)
extern PyTypeObject PyCStgDict_Type;
#define PyCStgDict_CheckExact(v) ((v)->ob_type == &PyCStgDict_Type)
#define PyCStgDict_Check(v) PyObject_TypeCheck(v, &PyCStgDict_Type)
extern int StructUnionType_update_stgdict(PyObject *fields, PyObject *type, int isStruct);
extern int PyCStructUnionType_update_stgdict(PyObject *fields, PyObject *type, int isStruct);
extern int PyType_stginfo(PyTypeObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength);
extern int PyObject_stginfo(PyObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength);
extern PyTypeObject CData_Type;
#define CDataObject_CheckExact(v) ((v)->ob_type == &CData_Type)
#define CDataObject_Check(v) PyObject_TypeCheck(v, &CData_Type)
extern PyTypeObject PyCData_Type;
#define CDataObject_CheckExact(v) ((v)->ob_type == &PyCData_Type)
#define CDataObject_Check(v) PyObject_TypeCheck(v, &PyCData_Type)
extern PyTypeObject SimpleType_Type;
#define SimpleTypeObject_CheckExact(v) ((v)->ob_type == &SimpleType_Type)
#define SimpleTypeObject_Check(v) PyObject_TypeCheck(v, &SimpleType_Type)
extern PyTypeObject PyCSimpleType_Type;
#define PyCSimpleTypeObject_CheckExact(v) ((v)->ob_type == &PyCSimpleType_Type)
#define PyCSimpleTypeObject_Check(v) PyObject_TypeCheck(v, &PyCSimpleType_Type)
extern PyTypeObject CField_Type;
extern struct fielddesc *getentry(char *fmt);
extern PyTypeObject PyCField_Type;
extern struct fielddesc *_ctypes_get_fielddesc(char *fmt);
extern PyObject *
CField_FromDesc(PyObject *desc, Py_ssize_t index,
PyCField_FromDesc(PyObject *desc, Py_ssize_t index,
Py_ssize_t *pfield_size, int bitsize, int *pbitofs,
Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,
int pack, int is_big_endian);
extern PyObject *CData_AtAddress(PyObject *type, void *buf);
extern PyObject *CData_FromBytes(PyObject *type, char *data, Py_ssize_t length);
extern PyObject *PyCData_AtAddress(PyObject *type, void *buf);
extern PyObject *PyCData_FromBytes(PyObject *type, char *data, Py_ssize_t length);
extern PyTypeObject ArrayType_Type;
extern PyTypeObject Array_Type;
extern PyTypeObject PointerType_Type;
extern PyTypeObject Pointer_Type;
extern PyTypeObject CFuncPtr_Type;
extern PyTypeObject CFuncPtrType_Type;
extern PyTypeObject StructType_Type;
extern PyTypeObject PyCArrayType_Type;
extern PyTypeObject PyCArray_Type;
extern PyTypeObject PyCPointerType_Type;
extern PyTypeObject PyCPointer_Type;
extern PyTypeObject PyCFuncPtr_Type;
extern PyTypeObject PyCFuncPtrType_Type;
extern PyTypeObject PyCStructType_Type;
#define ArrayTypeObject_Check(v) PyObject_TypeCheck(v, &ArrayType_Type)
#define ArrayObject_Check(v) PyObject_TypeCheck(v, &Array_Type)
#define PointerObject_Check(v) PyObject_TypeCheck(v, &Pointer_Type)
#define PointerTypeObject_Check(v) PyObject_TypeCheck(v, &PointerType_Type)
#define CFuncPtrObject_Check(v) PyObject_TypeCheck(v, &CFuncPtr_Type)
#define CFuncPtrTypeObject_Check(v) PyObject_TypeCheck(v, &CFuncPtrType_Type)
#define StructTypeObject_Check(v) PyObject_TypeCheck(v, &StructType_Type)
#define PyCArrayTypeObject_Check(v) PyObject_TypeCheck(v, &PyCArrayType_Type)
#define ArrayObject_Check(v) PyObject_TypeCheck(v, &PyCArray_Type)
#define PointerObject_Check(v) PyObject_TypeCheck(v, &PyCPointer_Type)
#define PyCPointerTypeObject_Check(v) PyObject_TypeCheck(v, &PyCPointerType_Type)
#define PyCFuncPtrObject_Check(v) PyObject_TypeCheck(v, &PyCFuncPtr_Type)
#define PyCFuncPtrTypeObject_Check(v) PyObject_TypeCheck(v, &PyCFuncPtrType_Type)
#define PyCStructTypeObject_Check(v) PyObject_TypeCheck(v, &PyCStructType_Type)
extern PyObject *
CreateArrayType(PyObject *itemtype, Py_ssize_t length);
PyCArrayType_from_ctype(PyObject *itemtype, Py_ssize_t length);
extern PyMethodDef module_methods[];
extern PyMethodDef _ctypes_module_methods[];
extern CThunkObject *AllocFunctionCallback(PyObject *callable,
extern CThunkObject *_ctypes_alloc_callback(PyObject *callable,
PyObject *converters,
PyObject *restype,
int flags);
@ -223,7 +223,7 @@ typedef struct {
PyDictObject dict; /* first part identical to PyDictObject */
/* The size and align fields are unneeded, they are in ffi_type as well. As
an experiment shows, it's trivial to get rid of them, the only thing to
remember is that in ArrayType_new the ffi_type fields must be filled in -
remember is that in PyCArrayType_new the ffi_type fields must be filled in -
so far it was unneeded because libffi doesn't support arrays at all
(because they are passed as pointers to function calls anyway). But it's
too much risk to change that now, and there are other fields which doen't
@ -238,7 +238,7 @@ typedef struct {
GETFUNC getfunc; /* Only for simple objects */
PARAMFUNC paramfunc;
/* Following fields only used by CFuncPtrType_Type instances */
/* Following fields only used by PyCFuncPtrType_Type instances */
PyObject *argtypes; /* tuple of CDataObjects */
PyObject *converters; /* tuple([t.from_param for t in argtypes]) */
PyObject *restype; /* CDataObject or NULL */
@ -272,7 +272,7 @@ typedef struct {
construction time, or assigns to it later, tp_setattro should update the
StgDictObject function to a generic one.
Currently, CFuncPtr types have 'converters' and 'checker' entries in their
Currently, PyCFuncPtr types have 'converters' and 'checker' entries in their
type dict. They are only used to cache attributes from other entries, whihc
is wrong.
@ -300,11 +300,11 @@ extern StgDictObject *PyType_stgdict(PyObject *obj);
/* May return NULL, but does not set an exception! */
extern StgDictObject *PyObject_stgdict(PyObject *self);
extern int StgDict_clone(StgDictObject *src, StgDictObject *dst);
extern int PyCStgDict_clone(StgDictObject *src, StgDictObject *dst);
typedef int(* PPROC)(void);
PyObject *_CallProc(PPROC pProc,
PyObject *_ctypes_callproc(PPROC pProc,
PyObject *arguments,
#ifdef MS_WIN32
IUnknown *pIUnk,
@ -352,17 +352,17 @@ struct tagPyCArgObject {
extern PyTypeObject PyCArg_Type;
#define PyCArg_CheckExact(v) ((v)->ob_type == &PyCArg_Type)
extern PyCArgObject *new_CArgObject(void);
extern PyCArgObject *PyCArgObject_new(void);
extern PyObject *
CData_get(PyObject *type, GETFUNC getfunc, PyObject *src,
PyCData_get(PyObject *type, GETFUNC getfunc, PyObject *src,
Py_ssize_t index, Py_ssize_t size, char *ptr);
extern int
CData_set(PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
PyCData_set(PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value,
Py_ssize_t index, Py_ssize_t size, char *ptr);
extern void Extend_Error_Info(PyObject *exc_class, char *fmt, ...);
extern void _ctypes_extend_error(PyObject *exc_class, char *fmt, ...);
struct basespec {
CDataObject *base;
@ -372,13 +372,13 @@ struct basespec {
extern char basespec_string[];
extern ffi_type *GetType(PyObject *obj);
extern ffi_type *_ctypes_get_ffi_type(PyObject *obj);
/* exception classes */
extern PyObject *PyExc_ArgError;
extern char *conversion_mode_encoding;
extern char *conversion_mode_errors;
extern char *_ctypes_conversion_encoding;
extern char *_ctypes_conversion_errors;
/* Python 2.4 macros, which are not available in Python 2.3 */
@ -415,31 +415,31 @@ extern char *conversion_mode_errors;
#endif
#if (PY_VERSION_HEX < 0x02040000)
#ifdef CTYPES_UNICODE
# undef PyUnicode_FromWideChar
# define PyUnicode_FromWideChar My_PyUnicode_FromWideChar
# define PyUnicode_FromWideChar PyUnicode_FromWideChar_fixed
# undef PyUnicode_AsWideChar
# define PyUnicode_AsWideChar My_PyUnicode_AsWideChar
extern PyObject *My_PyUnicode_FromWideChar(const wchar_t *, Py_ssize_t);
extern Py_ssize_t My_PyUnicode_AsWideChar(PyUnicodeObject *, wchar_t *, Py_ssize_t);
# define PyUnicode_AsWideChar PyUnicode_AsWideChar_fixed
extern PyObject *PyUnicode_FromWideChar_fixed(const wchar_t *, Py_ssize_t);
extern Py_ssize_t PyUnicode_AsWideChar_fixed(PyUnicodeObject *, wchar_t *, Py_ssize_t);
#endif
#endif
extern void FreeClosure(void *);
extern void *MallocClosure(void);
extern void _ctypes_free_closure(void *);
extern void *_ctypes_alloc_closure(void);
extern void _AddTraceback(char *, char *, int);
extern void _ctypes_add_traceback(char *, char *, int);
extern PyObject *CData_FromBaseObj(PyObject *type, PyObject *base, Py_ssize_t index, char *adr);
extern char *alloc_format_string(const char *prefix, const char *suffix);
extern PyObject *PyCData_FromBaseObj(PyObject *type, PyObject *base, Py_ssize_t index, char *adr);
extern char *_ctypes_alloc_format_string(const char *prefix, const char *suffix);
/* XXX better name needed! */
extern int IsSimpleSubType(PyObject *obj);
extern int _ctypes_simple_instance(PyObject *obj);
extern PyObject *_pointer_type_cache;
PyObject *get_error_object(int **pspace);
extern PyObject *_ctypes_ptrtype_cache;
PyObject *_ctypes_get_errobj(int **pspace);
#ifdef MS_WIN32
extern PyObject *ComError;

4
Modules/_ctypes/malloc_closure.c
View File

@ -93,7 +93,7 @@ static void more_core(void)
/******************************************************************/
/* put the item back into the free list */
void FreeClosure(void *p)
void _ctypes_free_closure(void *p)
{
ITEM *item = (ITEM *)p;
item->next = free_list;
@ -101,7 +101,7 @@ void FreeClosure(void *p)
}
/* return one item from the free list, allocating more if needed */
void *MallocClosure(void)
void *_ctypes_alloc_closure(void)
{
ITEM *item;
if (!free_list)

48
Modules/_ctypes/stgdict.c
View File

@ -21,7 +21,7 @@
* PyDict_SetItem() (ma_lookup is NULL)
*/
static int
StgDict_init(StgDictObject *self, PyObject *args, PyObject *kwds)
PyCStgDict_init(StgDictObject *self, PyObject *args, PyObject *kwds)
{
if (PyDict_Type.tp_init((PyObject *)self, args, kwds) < 0)
return -1;
@ -32,7 +32,7 @@ StgDict_init(StgDictObject *self, PyObject *args, PyObject *kwds)
}
static int
StgDict_clear(StgDictObject *self)
PyCStgDict_clear(StgDictObject *self)
{
Py_CLEAR(self->proto);
Py_CLEAR(self->argtypes);
@ -43,9 +43,9 @@ StgDict_clear(StgDictObject *self)
}
static void
StgDict_dealloc(StgDictObject *self)
PyCStgDict_dealloc(StgDictObject *self)
{
StgDict_clear(self);
PyCStgDict_clear(self);
PyMem_Free(self->format);
PyMem_Free(self->shape);
PyMem_Free(self->ffi_type_pointer.elements);
@ -53,12 +53,12 @@ StgDict_dealloc(StgDictObject *self)
}
int
StgDict_clone(StgDictObject *dst, StgDictObject *src)
PyCStgDict_clone(StgDictObject *dst, StgDictObject *src)
{
char *d, *s;
Py_ssize_t size;
StgDict_clear(dst);
PyCStgDict_clear(dst);
PyMem_Free(dst->ffi_type_pointer.elements);
PyMem_Free(dst->format);
dst->format = NULL;
@ -106,12 +106,12 @@ StgDict_clone(StgDictObject *dst, StgDictObject *src)
return 0;
}
PyTypeObject StgDict_Type = {
PyTypeObject PyCStgDict_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"StgDict",
sizeof(StgDictObject),
0,
(destructor)StgDict_dealloc, /* tp_dealloc */
(destructor)PyCStgDict_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
@ -142,7 +142,7 @@ PyTypeObject StgDict_Type = {
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)StgDict_init, /* tp_init */
(initproc)PyCStgDict_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
@ -159,7 +159,7 @@ PyType_stgdict(PyObject *obj)
type = (PyTypeObject *)obj;
if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS))
return NULL;
if (!type->tp_dict || !StgDict_CheckExact(type->tp_dict))
if (!type->tp_dict || !PyCStgDict_CheckExact(type->tp_dict))
return NULL;
return (StgDictObject *)type->tp_dict;
}
@ -175,7 +175,7 @@ PyObject_stgdict(PyObject *self)
PyTypeObject *type = self->ob_type;
if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS))
return NULL;
if (!type->tp_dict || !StgDict_CheckExact(type->tp_dict))
if (!type->tp_dict || !PyCStgDict_CheckExact(type->tp_dict))
return NULL;
return (StgDictObject *)type->tp_dict;
}
@ -215,7 +215,7 @@ MakeFields(PyObject *type, CFieldObject *descr,
Py_DECREF(fieldlist);
return -1;
}
if (Py_TYPE(fdescr) != &CField_Type) {
if (Py_TYPE(fdescr) != &PyCField_Type) {
PyErr_SetString(PyExc_TypeError, "unexpected type");
Py_DECREF(fdescr);
Py_DECREF(fieldlist);
@ -232,13 +232,13 @@ MakeFields(PyObject *type, CFieldObject *descr,
}
continue;
}
new_descr = (CFieldObject *)PyObject_CallObject((PyObject *)&CField_Type, NULL);
new_descr = (CFieldObject *)PyObject_CallObject((PyObject *)&PyCField_Type, NULL);
if (new_descr == NULL) {
Py_DECREF(fdescr);
Py_DECREF(fieldlist);
return -1;
}
assert(Py_TYPE(new_descr) == &CField_Type);
assert(Py_TYPE(new_descr) == &PyCField_Type);
new_descr->size = fdescr->size;
new_descr->offset = fdescr->offset + offset;
new_descr->index = fdescr->index + index;
@ -286,7 +286,7 @@ MakeAnonFields(PyObject *type)
Py_DECREF(anon_names);
return -1;
}
assert(Py_TYPE(descr) == &CField_Type);
assert(Py_TYPE(descr) == &PyCField_Type);
descr->anonymous = 1;
/* descr is in the field descriptor. */
@ -309,7 +309,7 @@ MakeAnonFields(PyObject *type)
and create an StgDictObject. Used for Structure and Union subclasses.
*/
int
StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
PyCStructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
{
StgDictObject *stgdict, *basedict;
Py_ssize_t len, offset, size, align, i;
@ -418,12 +418,12 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
assert(stgdict->format == NULL);
if (isStruct && !isPacked) {
stgdict->format = alloc_format_string(NULL, "T{");
stgdict->format = _ctypes_alloc_format_string(NULL, "T{");
} else {
/* PEP3118 doesn't support union, or packed structures (well,
only standard packing, but we dont support the pep for
that). Use 'B' for bytes. */
stgdict->format = alloc_format_string(NULL, "B");
stgdict->format = _ctypes_alloc_format_string(NULL, "B");
}
#define realdict ((PyObject *)&stgdict->dict)
@ -468,9 +468,9 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
case FFI_TYPE_SINT8:
case FFI_TYPE_SINT16:
case FFI_TYPE_SINT32:
if (dict->getfunc != getentry("c")->getfunc
if (dict->getfunc != _ctypes_get_fielddesc("c")->getfunc
#ifdef CTYPES_UNICODE
&& dict->getfunc != getentry("u")->getfunc
&& dict->getfunc != _ctypes_get_fielddesc("u")->getfunc
#endif
)
break;
@ -500,7 +500,7 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
sprintf(buf, "%s:%s:", fieldfmt, fieldname);
ptr = stgdict->format;
stgdict->format = alloc_format_string(stgdict->format, buf);
stgdict->format = _ctypes_alloc_format_string(stgdict->format, buf);
PyMem_Free(ptr);
if (stgdict->format == NULL) {
@ -509,7 +509,7 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
}
}
if (isStruct) {
prop = CField_FromDesc(desc, i,
prop = PyCField_FromDesc(desc, i,
&field_size, bitsize, &bitofs,
&size, &offset, &align,
pack, big_endian);
@ -517,7 +517,7 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
size = 0;
offset = 0;
align = 0;
prop = CField_FromDesc(desc, i,
prop = PyCField_FromDesc(desc, i,
&field_size, bitsize, &bitofs,
&size, &offset, &align,
pack, big_endian);
@ -541,7 +541,7 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
if (isStruct && !isPacked) {
char *ptr = stgdict->format;
stgdict->format = alloc_format_string(stgdict->format, "}");
stgdict->format = _ctypes_alloc_format_string(stgdict->format, "}");
PyMem_Free(ptr);
if (stgdict->format == NULL)
return -1;