Bug Summary

File:Modules/_ctypes/callproc.c
Location:line 824, column 20
Description:Dereference of undefined pointer value

Annotated Source Code

1/*
2 * History: First version dated from 3/97, derived from my SCMLIB version
3 * for win16.
4 */
5/*
6 * Related Work:
7 * - calldll http://www.nightmare.com/software.html
8 * - libffi http://sourceware.cygnus.com/libffi/
9 * - ffcall http://clisp.cons.org/~haible/packages-ffcall.html
10 * and, of course, Don Beaudry's MESS package, but this is more ctypes
11 * related.
12 */
13
14
15/*
16 How are functions called, and how are parameters converted to C ?
17
18 1. _ctypes.c::PyCFuncPtr_call receives an argument tuple 'inargs' and a
19 keyword dictionary 'kwds'.
20
21 2. After several checks, _build_callargs() is called which returns another
22 tuple 'callargs'. This may be the same tuple as 'inargs', a slice of
23 'inargs', or a completely fresh tuple, depending on several things (is is a
24 COM method, are 'paramflags' available).
25
26 3. _build_callargs also calculates bitarrays containing indexes into
27 the callargs tuple, specifying how to build the return value(s) of
28 the function.
29
30 4. _ctypes_callproc is then called with the 'callargs' tuple. _ctypes_callproc first
31 allocates two arrays. The first is an array of 'struct argument' items, the
32 second array has 'void *' entried.
33
34 5. If 'converters' are present (converters is a sequence of argtypes'
35 from_param methods), for each item in 'callargs' converter is called and the
36 result passed to ConvParam. If 'converters' are not present, each argument
37 is directly passed to ConvParm.
38
39 6. For each arg, ConvParam stores the contained C data (or a pointer to it,
40 for structures) into the 'struct argument' array.
41
42 7. Finally, a loop fills the 'void *' array so that each item points to the
43 data contained in or pointed to by the 'struct argument' array.
44
45 8. The 'void *' argument array is what _call_function_pointer
46 expects. _call_function_pointer then has very little to do - only some
47 libffi specific stuff, then it calls ffi_call.
48
49 So, there are 4 data structures holding processed arguments:
50 - the inargs tuple (in PyCFuncPtr_call)
51 - the callargs tuple (in PyCFuncPtr_call)
52 - the 'struct argguments' array
53 - the 'void *' array
54
55 */
56
57#include "Python.h"
58#include "structmember.h"
59
60#ifdef MS_WIN32
61#include <windows.h>
62#include <tchar.h>
63#else
64#include "ctypes_dlfcn.h"
65#endif
66
67#ifdef MS_WIN32
68#include <malloc.h>
69#endif
70
71#include <ffi.h>
72#include "ctypes.h"
73
74#if defined(_DEBUG) || defined(__MINGW32__)
75/* Don't use structured exception handling on Windows if this is defined.
76 MingW, AFAIK, doesn't support it.
77*/
78#define DONT_USE_SEH
79#endif
80
81#define CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem" "_ctypes pymem"
82
83static void pymem_destructor(PyObject *ptr)
84{
85 void *p = PyCapsule_GetPointer(ptr, CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem");
86 if (p) {
87 PyMem_Free(p);
88 }
89}
90
91/*
92 ctypes maintains thread-local storage that has space for two error numbers:
93 private copies of the system 'errno' value and, on Windows, the system error code
94 accessed by the GetLastError() and SetLastError() api functions.
95
96 Foreign functions created with CDLL(..., use_errno=True), when called, swap
97 the system 'errno' value with the private copy just before the actual
98 function call, and swapped again immediately afterwards. The 'use_errno'
99 parameter defaults to False, in this case 'ctypes_errno' is not touched.
100
101 On Windows, foreign functions created with CDLL(..., use_last_error=True) or
102 WinDLL(..., use_last_error=True) swap the system LastError value with the
103 ctypes private copy.
104
105 The values are also swapped immeditately before and after ctypes callback
106 functions are called, if the callbacks are constructed using the new
107 optional use_errno parameter set to True: CFUNCTYPE(..., use_errno=TRUE) or
108 WINFUNCTYPE(..., use_errno=True).
109
110 New ctypes functions are provided to access the ctypes private copies from
111 Python:
112
113 - ctypes.set_errno(value) and ctypes.set_last_error(value) store 'value' in
114 the private copy and returns the previous value.
115
116 - ctypes.get_errno() and ctypes.get_last_error() returns the current ctypes
117 private copies value.
118*/
119
120/*
121 This function creates and returns a thread-local Python object that has
122 space to store two integer error numbers; once created the Python object is
123 kept alive in the thread state dictionary as long as the thread itself.
124*/
125PyObject *
126_ctypes_get_errobj(int **pspace)
127{
128 PyObject *dict = PyThreadState_GetDict();
129 PyObject *errobj;
130 static PyObject *error_object_name;
131 if (dict == 0) {
132 PyErr_SetString(PyExc_RuntimeError,
133 "cannot get thread state");
134 return NULL((void*)0);
135 }
136 if (error_object_name == NULL((void*)0)) {
137 error_object_name = PyUnicode_InternFromString("ctypes.error_object");
138 if (error_object_name == NULL((void*)0))
139 return NULL((void*)0);
140 }
141 errobj = PyDict_GetItem(dict, error_object_name);
142 if (errobj) {
143 if (!PyCapsule_IsValid(errobj, CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem")) {
144 PyErr_SetString(PyExc_RuntimeError,
145 "ctypes.error_object is an invalid capsule");
146 return NULL((void*)0);
147 }
148 Py_INCREF(errobj)( _Py_RefTotal++ , ((PyObject*)(errobj))->ob_refcnt++);
149 }
150 else {
151 void *space = PyMem_Malloc(sizeof(int) * 2);
152 if (space == NULL((void*)0))
153 return NULL((void*)0);
154 memset(space, 0, sizeof(int) * 2)((__builtin_object_size (space, 0) != (size_t) -1) ? __builtin___memset_chk
(space, 0, sizeof(int) * 2, __builtin_object_size (space, 0)
) : __inline_memset_chk (space, 0, sizeof(int) * 2))
;
155 errobj = PyCapsule_New(space, CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem", pymem_destructor);
156 if (errobj == NULL((void*)0))
157 return NULL((void*)0);
158 if (-1 == PyDict_SetItem(dict, error_object_name,
159 errobj)) {
160 Py_DECREF(errobj)do { if (_Py_RefTotal-- , --((PyObject*)(errobj))->ob_refcnt
!= 0) { if (((PyObject*)errobj)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 160, (PyObject *)(errobj)); } else _Py_Dealloc((PyObject *)
(errobj)); } while (0)
;
161 return NULL((void*)0);
162 }
163 }
164 *pspace = (int *)PyCapsule_GetPointer(errobj, CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem");
165 return errobj;
166}
167
168static PyObject *
169get_error_internal(PyObject *self, PyObject *args, int index)
170{
171 int *space;
172 PyObject *errobj = _ctypes_get_errobj(&space);
173 PyObject *result;
174
175 if (errobj == NULL((void*)0))
176 return NULL((void*)0);
177 result = PyLong_FromLong(space[index]);
178 Py_DECREF(errobj)do { if (_Py_RefTotal-- , --((PyObject*)(errobj))->ob_refcnt
!= 0) { if (((PyObject*)errobj)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 178, (PyObject *)(errobj)); } else _Py_Dealloc((PyObject *)
(errobj)); } while (0)
;
179 return result;
180}
181
182static PyObject *
183set_error_internal(PyObject *self, PyObject *args, int index)
184{
185 int new_errno, old_errno;
186 PyObject *errobj;
187 int *space;
188
189 if (!PyArg_ParseTuple(args, "i", &new_errno))
190 return NULL((void*)0);
191 errobj = _ctypes_get_errobj(&space);
192 if (errobj == NULL((void*)0))
193 return NULL((void*)0);
194 old_errno = space[index];
195 space[index] = new_errno;
196 Py_DECREF(errobj)do { if (_Py_RefTotal-- , --((PyObject*)(errobj))->ob_refcnt
!= 0) { if (((PyObject*)errobj)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 196, (PyObject *)(errobj)); } else _Py_Dealloc((PyObject *)
(errobj)); } while (0)
;
197 return PyLong_FromLong(old_errno);
198}
199
200static PyObject *
201get_errno(PyObject *self, PyObject *args)
202{
203 return get_error_internal(self, args, 0);
204}
205
206static PyObject *
207set_errno(PyObject *self, PyObject *args)
208{
209 return set_error_internal(self, args, 0);
210}
211
212#ifdef MS_WIN32
213
214static PyObject *
215get_last_error(PyObject *self, PyObject *args)
216{
217 return get_error_internal(self, args, 1);
218}
219
220static PyObject *
221set_last_error(PyObject *self, PyObject *args)
222{
223 return set_error_internal(self, args, 1);
224}
225
226PyObject *ComError;
227
228static WCHAR *FormatError(DWORD code)
229{
230 WCHAR *lpMsgBuf;
231 DWORD n;
232 n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
233 NULL((void*)0),
234 code,
235 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
236 (LPWSTR) &lpMsgBuf,
237 0,
238 NULL((void*)0));
239 if (n) {
240 while (iswspace(lpMsgBuf[n-1]))
241 --n;
242 lpMsgBuf[n] = L'\0'; /* rstrip() */
243 }
244 return lpMsgBuf;
245}
246
247#ifndef DONT_USE_SEH
248static void SetException(DWORD code, EXCEPTION_RECORD *pr)
249{
250 /* The 'code' is a normal win32 error code so it could be handled by
251 PyErr_SetFromWindowsErr(). However, for some errors, we have additional
252 information not included in the error code. We handle those here and
253 delegate all others to the generic function. */
254 switch (code) {
255 case EXCEPTION_ACCESS_VIOLATION:
256 /* The thread attempted to read from or write
257 to a virtual address for which it does not
258 have the appropriate access. */
259 if (pr->ExceptionInformation[0] == 0)
260 PyErr_Format(PyExc_WindowsError,
261 "exception: access violation reading %p",
262 pr->ExceptionInformation[1]);
263 else
264 PyErr_Format(PyExc_WindowsError,
265 "exception: access violation writing %p",
266 pr->ExceptionInformation[1]);
267 break;
268
269 case EXCEPTION_BREAKPOINT:
270 /* A breakpoint was encountered. */
271 PyErr_SetString(PyExc_WindowsError,
272 "exception: breakpoint encountered");
273 break;
274
275 case EXCEPTION_DATATYPE_MISALIGNMENT:
276 /* The thread attempted to read or write data that is
277 misaligned on hardware that does not provide
278 alignment. For example, 16-bit values must be
279 aligned on 2-byte boundaries, 32-bit values on
280 4-byte boundaries, and so on. */
281 PyErr_SetString(PyExc_WindowsError,
282 "exception: datatype misalignment");
283 break;
284
285 case EXCEPTION_SINGLE_STEP:
286 /* A trace trap or other single-instruction mechanism
287 signaled that one instruction has been executed. */
288 PyErr_SetString(PyExc_WindowsError,
289 "exception: single step");
290 break;
291
292 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
293 /* The thread attempted to access an array element
294 that is out of bounds, and the underlying hardware
295 supports bounds checking. */
296 PyErr_SetString(PyExc_WindowsError,
297 "exception: array bounds exceeded");
298 break;
299
300 case EXCEPTION_FLT_DENORMAL_OPERAND:
301 /* One of the operands in a floating-point operation
302 is denormal. A denormal value is one that is too
303 small to represent as a standard floating-point
304 value. */
305 PyErr_SetString(PyExc_WindowsError,
306 "exception: floating-point operand denormal");
307 break;
308
309 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
310 /* The thread attempted to divide a floating-point
311 value by a floating-point divisor of zero. */
312 PyErr_SetString(PyExc_WindowsError,
313 "exception: float divide by zero");
314 break;
315
316 case EXCEPTION_FLT_INEXACT_RESULT:
317 /* The result of a floating-point operation cannot be
318 represented exactly as a decimal fraction. */
319 PyErr_SetString(PyExc_WindowsError,
320 "exception: float inexact");
321 break;
322
323 case EXCEPTION_FLT_INVALID_OPERATION:
324 /* This exception represents any floating-point
325 exception not included in this list. */
326 PyErr_SetString(PyExc_WindowsError,
327 "exception: float invalid operation");
328 break;
329
330 case EXCEPTION_FLT_OVERFLOW:
331 /* The exponent of a floating-point operation is
332 greater than the magnitude allowed by the
333 corresponding type. */
334 PyErr_SetString(PyExc_WindowsError,
335 "exception: float overflow");
336 break;
337
338 case EXCEPTION_FLT_STACK_CHECK:
339 /* The stack overflowed or underflowed as the result
340 of a floating-point operation. */
341 PyErr_SetString(PyExc_WindowsError,
342 "exception: stack over/underflow");
343 break;
344
345 case EXCEPTION_STACK_OVERFLOW:
346 /* The stack overflowed or underflowed as the result
347 of a floating-point operation. */
348 PyErr_SetString(PyExc_WindowsError,
349 "exception: stack overflow");
350 break;
351
352 case EXCEPTION_FLT_UNDERFLOW:
353 /* The exponent of a floating-point operation is less
354 than the magnitude allowed by the corresponding
355 type. */
356 PyErr_SetString(PyExc_WindowsError,
357 "exception: float underflow");
358 break;
359
360 case EXCEPTION_INT_DIVIDE_BY_ZERO:
361 /* The thread attempted to divide an integer value by
362 an integer divisor of zero. */
363 PyErr_SetString(PyExc_WindowsError,
364 "exception: integer divide by zero");
365 break;
366
367 case EXCEPTION_INT_OVERFLOW:
368 /* The result of an integer operation caused a carry
369 out of the most significant bit of the result. */
370 PyErr_SetString(PyExc_WindowsError,
371 "exception: integer overflow");
372 break;
373
374 case EXCEPTION_PRIV_INSTRUCTION:
375 /* The thread attempted to execute an instruction
376 whose operation is not allowed in the current
377 machine mode. */
378 PyErr_SetString(PyExc_WindowsError,
379 "exception: priviledged instruction");
380 break;
381
382 case EXCEPTION_NONCONTINUABLE_EXCEPTION:
383 /* The thread attempted to continue execution after a
384 noncontinuable exception occurred. */
385 PyErr_SetString(PyExc_WindowsError,
386 "exception: nocontinuable");
387 break;
388
389 default:
390 PyErr_SetFromWindowsErr(code);
391 break;
392 }
393}
394
395static DWORD HandleException(EXCEPTION_POINTERS *ptrs,
396 DWORD *pdw, EXCEPTION_RECORD *record)
397{
398 *pdw = ptrs->ExceptionRecord->ExceptionCode;
399 *record = *ptrs->ExceptionRecord;
400 return EXCEPTION_EXECUTE_HANDLER;
401}
402#endif
403
404static PyObject *
405check_hresult(PyObject *self, PyObject *args)
406{
407 HRESULT hr;
408 if (!PyArg_ParseTuple(args, "i", &hr))
409 return NULL((void*)0);
410 if (FAILED(hr))
411 return PyErr_SetFromWindowsErr(hr);
412 return PyLong_FromLong(hr);
413}
414
415#endif
416
417/**************************************************************/
418
419PyCArgObject *
420PyCArgObject_new(void)
421{
422 PyCArgObject *p;
423 p = PyObject_New(PyCArgObject, &PyCArg_Type)( (PyCArgObject *) _PyObject_New(&PyCArg_Type) );
424 if (p == NULL((void*)0))
425 return NULL((void*)0);
426 p->pffi_type = NULL((void*)0);
427 p->tag = '\0';
428 p->obj = NULL((void*)0);
429 memset(&p->value, 0, sizeof(p->value))((__builtin_object_size (&p->value, 0) != (size_t) -1)
? __builtin___memset_chk (&p->value, 0, sizeof(p->
value), __builtin_object_size (&p->value, 0)) : __inline_memset_chk
(&p->value, 0, sizeof(p->value)))
;
430 return p;
431}
432
433static void
434PyCArg_dealloc(PyCArgObject *self)
435{
436 Py_XDECREF(self->obj)do { if ((self->obj) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(self->obj))->ob_refcnt != 0) { if (
((PyObject*)self->obj)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 436, (PyObject *)(self->obj)); } else _Py_Dealloc((PyObject
*)(self->obj)); } while (0); } while (0)
;
437 PyObject_Del_PyObject_DebugFree(self);
438}
439
440static PyObject *
441PyCArg_repr(PyCArgObject *self)
442{
443 char buffer[256];
444 switch(self->tag) {
445 case 'b':
446 case 'B':
447 sprintf(buffer, "<cparam '%c' (%d)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.b)
448 self->tag, self->value.b)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.b)
;
449 break;
450 case 'h':
451 case 'H':
452 sprintf(buffer, "<cparam '%c' (%d)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.h)
453 self->tag, self->value.h)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.h)
;
454 break;
455 case 'i':
456 case 'I':
457 sprintf(buffer, "<cparam '%c' (%d)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.i)
458 self->tag, self->value.i)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%d)>", self->tag, self->
value.i)
;
459 break;
460 case 'l':
461 case 'L':
462 sprintf(buffer, "<cparam '%c' (%ld)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%ld)>", self->tag, self->
value.l)
463 self->tag, self->value.l)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%ld)>", self->tag, self->
value.l)
;
464 break;
465
466#ifdef HAVE_LONG_LONG1
467 case 'q':
468 case 'Q':
469 sprintf(buffer,__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
470#ifdef MS_WIN32__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
471 "<cparam '%c' (%I64d)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
472#else__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
473 "<cparam '%c' (%qd)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
474#endif__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
475 self->tag, self->value.q)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), ifdef MS_WIN32 "<cparam '%c' (%I64d)>",else
"<cparam '%c' (%qd)>",endif self->tag, self->value
.q)
;
476 break;
477#endif
478 case 'd':
479 sprintf(buffer, "<cparam '%c' (%f)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%f)>", self->tag, self->
value.d)
480 self->tag, self->value.d)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%f)>", self->tag, self->
value.d)
;
481 break;
482 case 'f':
483 sprintf(buffer, "<cparam '%c' (%f)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%f)>", self->tag, self->
value.f)
484 self->tag, self->value.f)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%f)>", self->tag, self->
value.f)
;
485 break;
486
487 case 'c':
488 sprintf(buffer, "<cparam '%c' (%c)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%c)>", self->tag, self->
value.c)
489 self->tag, self->value.c)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%c)>", self->tag, self->
value.c)
;
490 break;
491
492/* Hm, are these 'z' and 'Z' codes useful at all?
493 Shouldn't they be replaced by the functionality of c_string
494 and c_wstring ?
495*/
496 case 'z':
497 case 'Z':
498 case 'P':
499 sprintf(buffer, "<cparam '%c' (%p)>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%p)>", self->tag, self->
value.p)
500 self->tag, self->value.p)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' (%p)>", self->tag, self->
value.p)
;
501 break;
502
503 default:
504 sprintf(buffer, "<cparam '%c' at %p>",__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' at %p>", self->tag, self)
505 self->tag, self)__builtin___sprintf_chk (buffer, 0, __builtin_object_size (buffer
, 2 > 1), "<cparam '%c' at %p>", self->tag, self)
;
506 break;
507 }
508 return PyUnicode_FromStringPyUnicodeUCS2_FromString(buffer);
509}
510
511static PyMemberDef PyCArgType_members[] = {
512 { "_obj", T_OBJECT6,
513 offsetof(PyCArgObject, obj)__builtin_offsetof(PyCArgObject, obj), READONLY1,
514 "the wrapped object" },
515 { NULL((void*)0) },
516};
517
518PyTypeObject PyCArg_Type = {
519 PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 },
520 "CArgObject",
521 sizeof(PyCArgObject),
522 0,
523 (destructor)PyCArg_dealloc, /* tp_dealloc */
524 0, /* tp_print */
525 0, /* tp_getattr */
526 0, /* tp_setattr */
527 0, /* tp_reserved */
528 (reprfunc)PyCArg_repr, /* tp_repr */
529 0, /* tp_as_number */
530 0, /* tp_as_sequence */
531 0, /* tp_as_mapping */
532 0, /* tp_hash */
533 0, /* tp_call */
534 0, /* tp_str */
535 0, /* tp_getattro */
536 0, /* tp_setattro */
537 0, /* tp_as_buffer */
538 Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0), /* tp_flags */
539 0, /* tp_doc */
540 0, /* tp_traverse */
541 0, /* tp_clear */
542 0, /* tp_richcompare */
543 0, /* tp_weaklistoffset */
544 0, /* tp_iter */
545 0, /* tp_iternext */
546 0, /* tp_methods */
547 PyCArgType_members, /* tp_members */
548};
549
550/****************************************************************/
551/*
552 * Convert a PyObject * into a parameter suitable to pass to an
553 * C function call.
554 *
555 * 1. Python integers are converted to C int and passed by value.
556 * Py_None is converted to a C NULL pointer.
557 *
558 * 2. 3-tuples are expected to have a format character in the first
559 * item, which must be 'i', 'f', 'd', 'q', or 'P'.
560 * The second item will have to be an integer, float, double, long long
561 * or integer (denoting an address void *), will be converted to the
562 * corresponding C data type and passed by value.
563 *
564 * 3. Other Python objects are tested for an '_as_parameter_' attribute.
565 * The value of this attribute must be an integer which will be passed
566 * by value, or a 2-tuple or 3-tuple which will be used according
567 * to point 2 above. The third item (if any), is ignored. It is normally
568 * used to keep the object alive where this parameter refers to.
569 * XXX This convention is dangerous - you can construct arbitrary tuples
570 * in Python and pass them. Would it be safer to use a custom container
571 * datatype instead of a tuple?
572 *
573 * 4. Other Python objects cannot be passed as parameters - an exception is raised.
574 *
575 * 5. ConvParam will store the converted result in a struct containing format
576 * and value.
577 */
578
579union result {
580 char c;
581 char b;
582 short h;
583 int i;
584 long l;
585#ifdef HAVE_LONG_LONG1
586 PY_LONG_LONGlong long q;
587#endif
588 long double D;
589 double d;
590 float f;
591 void *p;
592};
593
594struct argument {
595 ffi_type *ffi_type;
596 PyObject *keep;
597 union result value;
598};
599
600/*
601 * Convert a single Python object into a PyCArgObject and return it.
602 */
603static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
604{
605 StgDictObject *dict;
606 pa->keep = NULL((void*)0); /* so we cannot forget it later */
607
608 dict = PyObject_stgdict(obj);
609 if (dict) {
610 PyCArgObject *carg;
611 assert(dict->paramfunc)(__builtin_expect(!(dict->paramfunc), 0) ? __assert_rtn(__func__
, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 611, "dict->paramfunc") : (void)0)
;
612 /* If it has an stgdict, it is a CDataObject */
613 carg = dict->paramfunc((CDataObject *)obj);
614 pa->ffi_type = carg->pffi_type;
615 memcpy(&pa->value, &carg->value, sizeof(pa->value))((__builtin_object_size (&pa->value, 0) != (size_t) -1
) ? __builtin___memcpy_chk (&pa->value, &carg->
value, sizeof(pa->value), __builtin_object_size (&pa->
value, 0)) : __inline_memcpy_chk (&pa->value, &carg
->value, sizeof(pa->value)))
;
616 pa->keep = (PyObject *)carg;
617 return 0;
618 }
619
620 if (PyCArg_CheckExact(obj)((obj)->ob_type == &PyCArg_Type)) {
621 PyCArgObject *carg = (PyCArgObject *)obj;
622 pa->ffi_type = carg->pffi_type;
623 Py_INCREF(obj)( _Py_RefTotal++ , ((PyObject*)(obj))->ob_refcnt++);
624 pa->keep = obj;
625 memcpy(&pa->value, &carg->value, sizeof(pa->value))((__builtin_object_size (&pa->value, 0) != (size_t) -1
) ? __builtin___memcpy_chk (&pa->value, &carg->
value, sizeof(pa->value), __builtin_object_size (&pa->
value, 0)) : __inline_memcpy_chk (&pa->value, &carg
->value, sizeof(pa->value)))
;
626 return 0;
627 }
628
629 /* check for None, integer, string or unicode and use directly if successful */
630 if (obj == Py_None(&_Py_NoneStruct)) {
631 pa->ffi_type = &ffi_type_pointer;
632 pa->value.p = NULL((void*)0);
633 return 0;
634 }
635
636 if (PyLong_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<<
24))) != 0)
) {
637 pa->ffi_type = &ffi_type_sintffi_type_sint32;
638 pa->value.i = (long)PyLong_AsUnsignedLong(obj);
639 if (pa->value.i == -1 && PyErr_Occurred()) {
640 PyErr_Clear();
641 pa->value.i = PyLong_AsLong(obj);
642 if (pa->value.i == -1 && PyErr_Occurred()) {
643 PyErr_SetString(PyExc_OverflowError,
644 "long int too long to convert");
645 return -1;
646 }
647 }
648 return 0;
649 }
650
651 if (PyBytes_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<<
27))) != 0)
) {
652 pa->ffi_type = &ffi_type_pointer;
653 pa->value.p = PyBytes_AsString(obj);
654 Py_INCREF(obj)( _Py_RefTotal++ , ((PyObject*)(obj))->ob_refcnt++);
655 pa->keep = obj;
656 return 0;
657 }
658
659#ifdef CTYPES_UNICODE
660 if (PyUnicode_Check(obj)((((((PyObject*)(obj))->ob_type))->tp_flags & ((1L<<
28))) != 0)
) {
661#if Py_UNICODE_SIZE2 == SIZEOF_WCHAR_T4
662 pa->ffi_type = &ffi_type_pointer;
663 pa->value.p = PyUnicode_AS_UNICODE(obj)((__builtin_expect(!(((((((PyObject*)(obj))->ob_type))->
tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__
, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 663, "PyUnicode_Check(obj)") : (void)0),(((PyUnicodeObject *
)(obj))->str))
;
664 Py_INCREF(obj)( _Py_RefTotal++ , ((PyObject*)(obj))->ob_refcnt++);
665 pa->keep = obj;
666 return 0;
667#else
668 pa->ffi_type = &ffi_type_pointer;
669 pa->value.p = PyUnicode_AsWideCharStringPyUnicodeUCS2_AsWideCharString(obj, NULL((void*)0));
670 if (pa->value.p == NULL((void*)0))
671 return -1;
672 pa->keep = PyCapsule_New(pa->value.p, CTYPES_CAPSULE_NAME_PYMEM"_ctypes pymem", pymem_destructor);
673 if (!pa->keep) {
674 PyMem_Free(pa->value.p);
675 return -1;
676 }
677 return 0;
678#endif
679 }
680#endif
681
682 {
683 PyObject *arg;
684 arg = PyObject_GetAttrString(obj, "_as_parameter_");
685 /* Which types should we exactly allow here?
686 integers are required for using Python classes
687 as parameters (they have to expose the '_as_parameter_'
688 attribute)
689 */
690 if (arg) {
691 int result;
692 result = ConvParam(arg, index, pa);
693 Py_DECREF(arg)do { if (_Py_RefTotal-- , --((PyObject*)(arg))->ob_refcnt !=
0) { if (((PyObject*)arg)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 693, (PyObject *)(arg)); } else _Py_Dealloc((PyObject *)(arg
)); } while (0)
;
694 return result;
695 }
696 PyErr_Format(PyExc_TypeError,
697 "Don't know how to convert parameter %d",
698 Py_SAFE_DOWNCAST(index, Py_ssize_t, int)((__builtin_expect(!((Py_ssize_t)(int)(index) == (index)), 0)
? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 698, "(Py_ssize_t)(int)(index) == (index)") : (void)0), (int
)(index))
);
699 return -1;
700 }
701}
702
703
704ffi_type *_ctypes_get_ffi_type(PyObject *obj)
705{
706 StgDictObject *dict;
707 if (obj == NULL((void*)0))
708 return &ffi_type_sintffi_type_sint32;
709 dict = PyType_stgdict(obj);
710 if (dict == NULL((void*)0))
711 return &ffi_type_sintffi_type_sint32;
712#if defined(MS_WIN32) && !defined(_WIN32_WCE)
713 /* This little trick works correctly with MSVC.
714 It returns small structures in registers
715 */
716 if (dict->ffi_type_pointer.type == FFI_TYPE_STRUCT13) {
717 if (dict->ffi_type_pointer.size <= 4)
718 return &ffi_type_sint32;
719 else if (dict->ffi_type_pointer.size <= 8)
720 return &ffi_type_sint64;
721 }
722#endif
723 return &dict->ffi_type_pointer;
724}
725
726
727/*
728 * libffi uses:
729 *
730 * ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi,
731 * unsigned int nargs,
732 * ffi_type *rtype,
733 * ffi_type **atypes);
734 *
735 * and then
736 *
737 * void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues);
738 */
739static int _call_function_pointer(int flags,
740 PPROC pProc,
741 void **avalues,
742 ffi_type **atypes,
743 ffi_type *restype,
744 void *resmem,
745 int argcount)
746{
747#ifdef WITH_THREAD1
748 PyThreadState *_save = NULL((void*)0); /* For Py_BLOCK_THREADS and Py_UNBLOCK_THREADS */
749#endif
750 PyObject *error_object = NULL((void*)0);
751 int *space;
752 ffi_cif cif;
753 int cc;
754#ifdef MS_WIN32
755 int delta;
756#ifndef DONT_USE_SEH
757 DWORD dwExceptionCode = 0;
758 EXCEPTION_RECORD record;
759#endif
760#endif
761 /* XXX check before here */
762 if (restype == NULL((void*)0)) {
1
Taking false branch
763 PyErr_SetString(PyExc_RuntimeError,
764 "No ffi_type for result");
765 return -1;
766 }
767
768 cc = FFI_DEFAULT_ABI;
769#if defined(MS_WIN32) && !defined(MS_WIN64) && !defined(_WIN32_WCE)
770 if ((flags & FUNCFLAG_CDECL0x1) == 0)
771 cc = FFI_STDCALL;
772#endif
773 if (FFI_OK != ffi_prep_cif(&cif,
2
Taking false branch
774 cc,
775 argcount,
776 restype,
777 atypes)) {
778 PyErr_SetString(PyExc_RuntimeError,
779 "ffi_prep_cif failed");
780 return -1;
781 }
782
783 if (flags & (FUNCFLAG_USE_ERRNO0x8 | FUNCFLAG_USE_LASTERROR0x10)) {
3
Taking false branch
784 error_object = _ctypes_get_errobj(&space);
785 if (error_object == NULL((void*)0))
786 return -1;
787 }
788#ifdef WITH_THREAD1
789 if ((flags & FUNCFLAG_PYTHONAPI0x4) == 0)
4
Taking false branch
790 Py_UNBLOCK_THREADS_save = PyEval_SaveThread();
791#endif
792 if (flags & FUNCFLAG_USE_ERRNO0x8) {
5
Taking false branch
793 int temp = space[0];
794 space[0] = errno(*__error());
795 errno(*__error()) = temp;
796 }
797#ifdef MS_WIN32
798 if (flags & FUNCFLAG_USE_LASTERROR0x10) {
799 int temp = space[1];
800 space[1] = GetLastError();
801 SetLastError(temp);
802 }
803#ifndef DONT_USE_SEH
804 __try {
805#endif
806 delta =
807#endif
808 ffi_call(&cif, (void *)pProc, resmem, avalues);
809#ifdef MS_WIN32
810#ifndef DONT_USE_SEH
811 }
812 __except (HandleException(GetExceptionInformation(),
813 &dwExceptionCode, &record)) {
814 ;
815 }
816#endif
817 if (flags & FUNCFLAG_USE_LASTERROR0x10) {
818 int temp = space[1];
819 space[1] = GetLastError();
820 SetLastError(temp);
821 }
822#endif
823 if (flags & FUNCFLAG_USE_ERRNO0x8) {
6
Taking true branch
824 int temp = space[0];
7
Dereference of undefined pointer value
825 space[0] = errno(*__error());
826 errno(*__error()) = temp;
827 }
828 Py_XDECREF(error_object)do { if ((error_object) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(error_object))->ob_refcnt != 0) { if (
((PyObject*)error_object)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 828, (PyObject *)(error_object)); } else _Py_Dealloc((PyObject
*)(error_object)); } while (0); } while (0)
;
829#ifdef WITH_THREAD1
830 if ((flags & FUNCFLAG_PYTHONAPI0x4) == 0)
831 Py_BLOCK_THREADSPyEval_RestoreThread(_save);
832#endif
833#ifdef MS_WIN32
834#ifndef DONT_USE_SEH
835 if (dwExceptionCode) {
836 SetException(dwExceptionCode, &record);
837 return -1;
838 }
839#endif
840#ifdef MS_WIN64
841 if (delta != 0) {
842 PyErr_Format(PyExc_RuntimeError,
843 "ffi_call failed with code %d",
844 delta);
845 return -1;
846 }
847#else
848 if (delta < 0) {
849 if (flags & FUNCFLAG_CDECL0x1)
850 PyErr_Format(PyExc_ValueError,
851 "Procedure called with not enough "
852 "arguments (%d bytes missing) "
853 "or wrong calling convention",
854 -delta);
855 else
856 PyErr_Format(PyExc_ValueError,
857 "Procedure probably called with not enough "
858 "arguments (%d bytes missing)",
859 -delta);
860 return -1;
861 } else if (delta > 0) {
862 PyErr_Format(PyExc_ValueError,
863 "Procedure probably called with too many "
864 "arguments (%d bytes in excess)",
865 delta);
866 return -1;
867 }
868#endif
869#endif
870 if ((flags & FUNCFLAG_PYTHONAPI0x4) && PyErr_Occurred())
871 return -1;
872 return 0;
873}
874
875/*
876 * Convert the C value in result into a Python object, depending on restype.
877 *
878 * - If restype is NULL, return a Python integer.
879 * - If restype is None, return None.
880 * - If restype is a simple ctypes type (c_int, c_void_p), call the type's getfunc,
881 * pass the result to checker and return the result.
882 * - If restype is another ctypes type, return an instance of that.
883 * - Otherwise, call restype and return the result.
884 */
885static PyObject *GetResult(PyObject *restype, void *result, PyObject *checker)
886{
887 StgDictObject *dict;
888 PyObject *retval, *v;
889
890 if (restype == NULL((void*)0))
891 return PyLong_FromLong(*(int *)result);
892
893 if (restype == Py_None(&_Py_NoneStruct)) {
894 Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt
++)
;
895 return Py_None(&_Py_NoneStruct);
896 }
897
898 dict = PyType_stgdict(restype);
899 if (dict == NULL((void*)0))
900 return PyObject_CallFunction(restype, "i", *(int *)result);
901
902 if (dict->getfunc && !_ctypes_simple_instance(restype)) {
903 retval = dict->getfunc(result, dict->size);
904 /* If restype is py_object (detected by comparing getfunc with
905 O_get), we have to call Py_DECREF because O_get has already
906 called Py_INCREF.
907 */
908 if (dict->getfunc == _ctypes_get_fielddesc("O")->getfunc) {
909 Py_DECREF(retval)do { if (_Py_RefTotal-- , --((PyObject*)(retval))->ob_refcnt
!= 0) { if (((PyObject*)retval)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 909, (PyObject *)(retval)); } else _Py_Dealloc((PyObject *)
(retval)); } while (0)
;
910 }
911 } else
912 retval = PyCData_FromBaseObj(restype, NULL((void*)0), 0, result);
913
914 if (!checker || !retval)
915 return retval;
916
917 v = PyObject_CallFunctionObjArgs(checker, retval, NULL((void*)0));
918 if (v == NULL((void*)0))
919 _ctypes_add_traceback("GetResult", "_ctypes/callproc.c", __LINE__919-2);
920 Py_DECREF(retval)do { if (_Py_RefTotal-- , --((PyObject*)(retval))->ob_refcnt
!= 0) { if (((PyObject*)retval)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 920, (PyObject *)(retval)); } else _Py_Dealloc((PyObject *)
(retval)); } while (0)
;
921 return v;
922}
923
924/*
925 * Raise a new exception 'exc_class', adding additional text to the original
926 * exception string.
927 */
928void _ctypes_extend_error(PyObject *exc_class, char *fmt, ...)
929{
930 va_list vargs;
931 PyObject *tp, *v, *tb, *s, *cls_str, *msg_str;
932
933 va_start(vargs, fmt)__builtin_va_start(vargs, fmt);
934 s = PyUnicode_FromFormatVPyUnicodeUCS2_FromFormatV(fmt, vargs);
935 va_end(vargs)__builtin_va_end(vargs);
936 if (!s)
937 return;
938
939 PyErr_Fetch(&tp, &v, &tb);
940 PyErr_NormalizeException(&tp, &v, &tb);
941 cls_str = PyObject_Str(tp);
942 if (cls_str) {
943 PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, cls_str);
944 PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, PyUnicode_FromStringPyUnicodeUCS2_FromString(": "));
945 if (s == NULL((void*)0))
946 goto error;
947 } else
948 PyErr_Clear();
949 msg_str = PyObject_Str(v);
950 if (msg_str)
951 PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, msg_str);
952 else {
953 PyErr_Clear();
954 PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&s, PyUnicode_FromStringPyUnicodeUCS2_FromString("???"));
955 if (s == NULL((void*)0))
956 goto error;
957 }
958 PyErr_SetObject(exc_class, s);
959error:
960 Py_XDECREF(tp)do { if ((tp) == ((void*)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(tp))->ob_refcnt != 0) { if (((PyObject*)tp
)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 960, (PyObject *)(tp)); } else _Py_Dealloc((PyObject *)(tp)
); } while (0); } while (0)
;
961 Py_XDECREF(v)do { if ((v) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --
((PyObject*)(v))->ob_refcnt != 0) { if (((PyObject*)v)->
ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 961, (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v));
} while (0); } while (0)
;
962 Py_XDECREF(tb)do { if ((tb) == ((void*)0)) ; else do { if (_Py_RefTotal-- ,
--((PyObject*)(tb))->ob_refcnt != 0) { if (((PyObject*)tb
)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 962, (PyObject *)(tb)); } else _Py_Dealloc((PyObject *)(tb)
); } while (0); } while (0)
;
963 Py_XDECREF(s)do { if ((s) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --
((PyObject*)(s))->ob_refcnt != 0) { if (((PyObject*)s)->
ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 963, (PyObject *)(s)); } else _Py_Dealloc((PyObject *)(s));
} while (0); } while (0)
;
964}
965
966
967#ifdef MS_WIN32
968
969static PyObject *
970GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk)
971{
972 HRESULT hr;
973 ISupportErrorInfo *psei = NULL((void*)0);
974 IErrorInfo *pei = NULL((void*)0);
975 BSTR descr=NULL((void*)0), helpfile=NULL((void*)0), source=NULL((void*)0);
976 GUID guid;
977 DWORD helpcontext=0;
978 LPOLESTR progid;
979 PyObject *obj;
980 LPOLESTR text;
981
982 /* We absolutely have to release the GIL during COM method calls,
983 otherwise we may get a deadlock!
984 */
985#ifdef WITH_THREAD1
986 Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();
987#endif
988
989 hr = pIunk->lpVtbl->QueryInterface(pIunk, &IID_ISupportErrorInfo, (void **)&psei);
990 if (FAILED(hr))
991 goto failed;
992
993 hr = psei->lpVtbl->InterfaceSupportsErrorInfo(psei, riid);
994 psei->lpVtbl->Release(psei);
995 if (FAILED(hr))
996 goto failed;
997
998 hr = GetErrorInfo(0, &pei);
999 if (hr != S_OK)
1000 goto failed;
1001
1002 pei->lpVtbl->GetDescription(pei, &descr);
1003 pei->lpVtbl->GetGUID(pei, &guid);
1004 pei->lpVtbl->GetHelpContext(pei, &helpcontext);
1005 pei->lpVtbl->GetHelpFile(pei, &helpfile);
1006 pei->lpVtbl->GetSource(pei, &source);
1007
1008 pei->lpVtbl->Release(pei);
1009
1010 failed:
1011#ifdef WITH_THREAD1
1012 Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }
1013#endif
1014
1015 progid = NULL((void*)0);
1016 ProgIDFromCLSID(&guid, &progid);
1017
1018 text = FormatError(errcode);
1019 obj = Py_BuildValue(
1020 "iu(uuuiu)",
1021 errcode,
1022 text,
1023 descr, source, helpfile, helpcontext,
1024 progid);
1025 if (obj) {
1026 PyErr_SetObject(ComError, obj);
1027 Py_DECREF(obj)do { if (_Py_RefTotal-- , --((PyObject*)(obj))->ob_refcnt !=
0) { if (((PyObject*)obj)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1027, (PyObject *)(obj)); } else _Py_Dealloc((PyObject *)(obj
)); } while (0)
;
1028 }
1029 LocalFree(text);
1030
1031 if (descr)
1032 SysFreeString(descr);
1033 if (helpfile)
1034 SysFreeString(helpfile);
1035 if (source)
1036 SysFreeString(source);
1037
1038 return NULL((void*)0);
1039}
1040#endif
1041
1042/*
1043 * Requirements, must be ensured by the caller:
1044 * - argtuple is tuple of arguments
1045 * - argtypes is either NULL, or a tuple of the same size as argtuple
1046 *
1047 * - XXX various requirements for restype, not yet collected
1048 */
1049PyObject *_ctypes_callproc(PPROC pProc,
1050 PyObject *argtuple,
1051#ifdef MS_WIN32
1052 IUnknown *pIunk,
1053 GUID *iid,
1054#endif
1055 int flags,
1056 PyObject *argtypes, /* misleading name: This is a tuple of
1057 methods, not types: the .from_param
1058 class methods of the types */
1059 PyObject *restype,
1060 PyObject *checker)
1061{
1062 Py_ssize_t i, n, argcount, argtype_count;
1063 void *resbuf;
1064 struct argument *args, *pa;
1065 ffi_type **atypes;
1066 ffi_type *rtype;
1067 void **avalues;
1068 PyObject *retval = NULL((void*)0);
1069
1070 n = argcount = PyTuple_GET_SIZE(argtuple)(((PyVarObject*)(argtuple))->ob_size);
1071#ifdef MS_WIN32
1072 /* an optional COM object this pointer */
1073 if (pIunk)
1074 ++argcount;
1075#endif
1076
1077 args = (struct argument *)alloca(sizeof(struct argument) * argcount)__builtin_alloca(sizeof(struct argument) * argcount);
1078 if (!args) {
1079 PyErr_NoMemory();
1080 return NULL((void*)0);
1081 }
1082 memset(args, 0, sizeof(struct argument) * argcount)((__builtin_object_size (args, 0) != (size_t) -1) ? __builtin___memset_chk
(args, 0, sizeof(struct argument) * argcount, __builtin_object_size
(args, 0)) : __inline_memset_chk (args, 0, sizeof(struct argument
) * argcount))
;
1083 argtype_count = argtypes ? PyTuple_GET_SIZE(argtypes)(((PyVarObject*)(argtypes))->ob_size) : 0;
1084#ifdef MS_WIN32
1085 if (pIunk) {
1086 args[0].ffi_type = &ffi_type_pointer;
1087 args[0].value.p = pIunk;
1088 pa = &args[1];
1089 } else
1090#endif
1091 pa = &args[0];
1092
1093 /* Convert the arguments */
1094 for (i = 0; i < n; ++i, ++pa) {
1095 PyObject *converter;
1096 PyObject *arg;
1097 int err;
1098
1099 arg = PyTuple_GET_ITEM(argtuple, i)(((PyTupleObject *)(argtuple))->ob_item[i]); /* borrowed ref */
1100 /* For cdecl functions, we allow more actual arguments
1101 than the length of the argtypes tuple.
1102 This is checked in _ctypes::PyCFuncPtr_Call
1103 */
1104 if (argtypes && argtype_count > i) {
1105 PyObject *v;
1106 converter = PyTuple_GET_ITEM(argtypes, i)(((PyTupleObject *)(argtypes))->ob_item[i]);
1107 v = PyObject_CallFunctionObjArgs(converter,
1108 arg,
1109 NULL((void*)0));
1110 if (v == NULL((void*)0)) {
1111 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1112 goto cleanup;
1113 }
1114
1115 err = ConvParam(v, i+1, pa);
1116 Py_DECREF(v)do { if (_Py_RefTotal-- , --((PyObject*)(v))->ob_refcnt !=
0) { if (((PyObject*)v)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1116, (PyObject *)(v)); } else _Py_Dealloc((PyObject *)(v))
; } while (0)
;
1117 if (-1 == err) {
1118 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1119 goto cleanup;
1120 }
1121 } else {
1122 err = ConvParam(arg, i+1, pa);
1123 if (-1 == err) {
1124 _ctypes_extend_error(PyExc_ArgError, "argument %d: ", i+1);
1125 goto cleanup; /* leaking ? */
1126 }
1127 }
1128 }
1129
1130 rtype = _ctypes_get_ffi_type(restype);
1131 resbuf = alloca(max(rtype->size, sizeof(ffi_arg)))__builtin_alloca(((rtype->size) > (sizeof(ffi_arg)) ? (
rtype->size) : (sizeof(ffi_arg))))
;
1132
1133 avalues = (void **)alloca(sizeof(void *) * argcount)__builtin_alloca(sizeof(void *) * argcount);
1134 atypes = (ffi_type **)alloca(sizeof(ffi_type *) * argcount)__builtin_alloca(sizeof(ffi_type *) * argcount);
1135 if (!resbuf || !avalues || !atypes) {
1136 PyErr_NoMemory();
1137 goto cleanup;
1138 }
1139 for (i = 0; i < argcount; ++i) {
1140 atypes[i] = args[i].ffi_type;
1141 if (atypes[i]->type == FFI_TYPE_STRUCT13
1142#ifdef _WIN64
1143 && atypes[i]->size <= sizeof(void *)
1144#endif
1145 )
1146 avalues[i] = (void *)args[i].value.p;
1147 else
1148 avalues[i] = (void *)&args[i].value;
1149 }
1150
1151 if (-1 == _call_function_pointer(flags, pProc, avalues, atypes,
1152 rtype, resbuf,
1153 Py_SAFE_DOWNCAST(argcount,((__builtin_expect(!((Py_ssize_t)(int)(argcount) == (argcount
)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1155, "( Py_ssize_t)( int)(argcount) == (argcount)") : (void
)0), (int)(argcount))
1154 Py_ssize_t,((__builtin_expect(!((Py_ssize_t)(int)(argcount) == (argcount
)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1155, "( Py_ssize_t)( int)(argcount) == (argcount)") : (void
)0), (int)(argcount))
1155 int)((__builtin_expect(!((Py_ssize_t)(int)(argcount) == (argcount
)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1155, "( Py_ssize_t)( int)(argcount) == (argcount)") : (void
)0), (int)(argcount))
))
1156 goto cleanup;
1157
1158#ifdef WORDS_BIGENDIAN
1159 /* libffi returns the result in a buffer with sizeof(ffi_arg). This
1160 causes problems on big endian machines, since the result buffer
1161 address cannot simply be used as result pointer, instead we must
1162 adjust the pointer value:
1163 */
1164 /*
1165 XXX I should find out and clarify why this is needed at all,
1166 especially why adjusting for ffi_type_float must be avoided on
1167 64-bit platforms.
1168 */
1169 if (rtype->type != FFI_TYPE_FLOAT2
1170 && rtype->type != FFI_TYPE_STRUCT13
1171 && rtype->size < sizeof(ffi_arg))
1172 resbuf = (char *)resbuf + sizeof(ffi_arg) - rtype->size;
1173#endif
1174
1175#ifdef MS_WIN32
1176 if (iid && pIunk) {
1177 if (*(int *)resbuf & 0x80000000)
1178 retval = GetComError(*(HRESULT *)resbuf, iid, pIunk);
1179 else
1180 retval = PyLong_FromLong(*(int *)resbuf);
1181 } else if (flags & FUNCFLAG_HRESULT0x2) {
1182 if (*(int *)resbuf & 0x80000000)
1183 retval = PyErr_SetFromWindowsErr(*(int *)resbuf);
1184 else
1185 retval = PyLong_FromLong(*(int *)resbuf);
1186 } else
1187#endif
1188 retval = GetResult(restype, resbuf, checker);
1189 cleanup:
1190 for (i = 0; i < argcount; ++i)
1191 Py_XDECREF(args[i].keep)do { if ((args[i].keep) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(args[i].keep))->ob_refcnt != 0) { if (
((PyObject*)args[i].keep)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1191, (PyObject *)(args[i].keep)); } else _Py_Dealloc((PyObject
*)(args[i].keep)); } while (0); } while (0)
;
1192 return retval;
1193}
1194
1195static int
1196_parse_voidp(PyObject *obj, void **address)
1197{
1198 *address = PyLong_AsVoidPtr(obj);
1199 if (*address == NULL((void*)0))
1200 return 0;
1201 return 1;
1202}
1203
1204#ifdef MS_WIN32
1205
1206static char format_error_doc[] =
1207"FormatError([integer]) -> string\n\
1208\n\
1209Convert a win32 error code into a string. If the error code is not\n\
1210given, the return value of a call to GetLastError() is used.\n";
1211static PyObject *format_error(PyObject *self, PyObject *args)
1212{
1213 PyObject *result;
1214 wchar_t *lpMsgBuf;
1215 DWORD code = 0;
1216 if (!PyArg_ParseTuple(args, "|i:FormatError", &code))
1217 return NULL((void*)0);
1218 if (code == 0)
1219 code = GetLastError();
1220 lpMsgBuf = FormatError(code);
1221 if (lpMsgBuf) {
1222 result = PyUnicode_FromWideCharPyUnicodeUCS2_FromWideChar(lpMsgBuf, wcslen(lpMsgBuf));
1223 LocalFree(lpMsgBuf);
1224 } else {
1225 result = PyUnicode_FromStringPyUnicodeUCS2_FromString("<no description>");
1226 }
1227 return result;
1228}
1229
1230static char load_library_doc[] =
1231"LoadLibrary(name) -> handle\n\
1232\n\
1233Load an executable (usually a DLL), and return a handle to it.\n\
1234The handle may be used to locate exported functions in this\n\
1235module.\n";
1236static PyObject *load_library(PyObject *self, PyObject *args)
1237{
1238 WCHAR *name;
1239 PyObject *nameobj;
1240 PyObject *ignored;
1241 HMODULE hMod;
1242 if (!PyArg_ParseTuple(args, "O|O:LoadLibrary", &nameobj, &ignored))
1243 return NULL((void*)0);
1244
1245 name = PyUnicode_AsUnicodePyUnicodeUCS2_AsUnicode(nameobj);
1246 if (!name)
1247 return NULL((void*)0);
1248
1249 hMod = LoadLibraryW(name);
1250 if (!hMod)
1251 return PyErr_SetFromWindowsErr(GetLastError());
1252#ifdef _WIN64
1253 return PyLong_FromVoidPtr(hMod);
1254#else
1255 return Py_BuildValue("i", hMod);
1256#endif
1257}
1258
1259static char free_library_doc[] =
1260"FreeLibrary(handle) -> void\n\
1261\n\
1262Free the handle of an executable previously loaded by LoadLibrary.\n";
1263static PyObject *free_library(PyObject *self, PyObject *args)
1264{
1265 void *hMod;
1266 if (!PyArg_ParseTuple(args, "O&:FreeLibrary", &_parse_voidp, &hMod))
1267 return NULL((void*)0);
1268 if (!FreeLibrary((HMODULE)hMod))
1269 return PyErr_SetFromWindowsErr(GetLastError());
1270 Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt
++)
;
1271 return Py_None(&_Py_NoneStruct);
1272}
1273
1274/* obsolete, should be removed */
1275/* Only used by sample code (in samples\Windows\COM.py) */
1276static PyObject *
1277call_commethod(PyObject *self, PyObject *args)
1278{
1279 IUnknown *pIunk;
1280 int index;
1281 PyObject *arguments;
1282 PPROC *lpVtbl;
1283 PyObject *result;
1284 CDataObject *pcom;
1285 PyObject *argtypes = NULL((void*)0);
1286
1287 if (!PyArg_ParseTuple(args,
1288 "OiO!|O!",
1289 &pcom, &index,
1290 &PyTuple_Type, &arguments,
1291 &PyTuple_Type, &argtypes))
1292 return NULL((void*)0);
1293
1294 if (argtypes && (PyTuple_GET_SIZE(arguments)(((PyVarObject*)(arguments))->ob_size) != PyTuple_GET_SIZE(argtypes)(((PyVarObject*)(argtypes))->ob_size))) {
1295 PyErr_Format(PyExc_TypeError,
1296 "Method takes %d arguments (%d given)",
1297 PyTuple_GET_SIZE(argtypes)(((PyVarObject*)(argtypes))->ob_size), PyTuple_GET_SIZE(arguments)(((PyVarObject*)(arguments))->ob_size));
1298 return NULL((void*)0);
1299 }
1300
1301 if (!CDataObject_Check(pcom)((((PyObject*)(pcom))->ob_type) == (&PyCData_Type) || PyType_IsSubtype
((((PyObject*)(pcom))->ob_type), (&PyCData_Type)))
|| (pcom->b_size != sizeof(void *))) {
1302 PyErr_Format(PyExc_TypeError,
1303 "COM Pointer expected instead of %s instance",
1304 Py_TYPE(pcom)(((PyObject*)(pcom))->ob_type)->tp_name);
1305 return NULL((void*)0);
1306 }
1307
1308 if ((*(void **)(pcom->b_ptr)) == NULL((void*)0)) {
1309 PyErr_SetString(PyExc_ValueError,
1310 "The COM 'this' pointer is NULL");
1311 return NULL((void*)0);
1312 }
1313
1314 pIunk = (IUnknown *)(*(void **)(pcom->b_ptr));
1315 lpVtbl = (PPROC *)(pIunk->lpVtbl);
1316
1317 result = _ctypes_callproc(lpVtbl[index],
1318 arguments,
1319#ifdef MS_WIN32
1320 pIunk,
1321 NULL((void*)0),
1322#endif
1323 FUNCFLAG_HRESULT0x2, /* flags */
1324 argtypes, /* self->argtypes */
1325 NULL((void*)0), /* self->restype */
1326 NULL((void*)0)); /* checker */
1327 return result;
1328}
1329
1330static char copy_com_pointer_doc[] =
1331"CopyComPointer(src, dst) -> HRESULT value\n";
1332
1333static PyObject *
1334copy_com_pointer(PyObject *self, PyObject *args)
1335{
1336 PyObject *p1, *p2, *r = NULL((void*)0);
1337 struct argument a, b;
1338 IUnknown *src, **pdst;
1339 if (!PyArg_ParseTuple(args, "OO:CopyComPointer", &p1, &p2))
1340 return NULL((void*)0);
1341 a.keep = b.keep = NULL((void*)0);
1342
1343 if (-1 == ConvParam(p1, 0, &a) || -1 == ConvParam(p2, 1, &b))
1344 goto done;
1345 src = (IUnknown *)a.value.p;
1346 pdst = (IUnknown **)b.value.p;
1347
1348 if (pdst == NULL((void*)0))
1349 r = PyLong_FromLong(E_POINTER);
1350 else {
1351 if (src)
1352 src->lpVtbl->AddRef(src);
1353 *pdst = src;
1354 r = PyLong_FromLong(S_OK);
1355 }
1356 done:
1357 Py_XDECREF(a.keep)do { if ((a.keep) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(a.keep))->ob_refcnt != 0) { if (((PyObject
*)a.keep)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1357, (PyObject *)(a.keep)); } else _Py_Dealloc((PyObject *
)(a.keep)); } while (0); } while (0)
;
1358 Py_XDECREF(b.keep)do { if ((b.keep) == ((void*)0)) ; else do { if (_Py_RefTotal
-- , --((PyObject*)(b.keep))->ob_refcnt != 0) { if (((PyObject
*)b.keep)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1358, (PyObject *)(b.keep)); } else _Py_Dealloc((PyObject *
)(b.keep)); } while (0); } while (0)
;
1359 return r;
1360}
1361#else
1362
1363static PyObject *py_dl_open(PyObject *self, PyObject *args)
1364{
1365 PyObject *name, *name2;
1366 char *name_str;
1367 void * handle;
1368#ifdef RTLD_LOCAL0x4
1369 int mode = RTLD_NOW0x2 | RTLD_LOCAL0x4;
1370#else
1371 /* cygwin doesn't define RTLD_LOCAL */
1372 int mode = RTLD_NOW0x2;
1373#endif
1374 if (!PyArg_ParseTuple(args, "O|i:dlopen", &name, &mode))
1375 return NULL((void*)0);
1376 mode |= RTLD_NOW0x2;
1377 if (name != Py_None(&_Py_NoneStruct)) {
1378 if (PyUnicode_FSConverterPyUnicodeUCS2_FSConverter(name, &name2) == 0)
1379 return NULL((void*)0);
1380 if (PyBytes_Check(name2)((((((PyObject*)(name2))->ob_type))->tp_flags & ((1L
<<27))) != 0)
)
1381 name_str = PyBytes_AS_STRING(name2)((__builtin_expect(!(((((((PyObject*)(name2))->ob_type))->
tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__
, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1381, "PyBytes_Check(name2)") : (void)0), (((PyBytesObject *
)(name2))->ob_sval))
;
1382 else
1383 name_str = PyByteArray_AS_STRING(name2)((__builtin_expect(!(((((PyObject*)(name2))->ob_type) == (
&PyByteArray_Type) || PyType_IsSubtype((((PyObject*)(name2
))->ob_type), (&PyByteArray_Type)))), 0) ? __assert_rtn
(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1383, "PyByteArray_Check(name2)") : (void)0), (((PyVarObject
*)(name2))->ob_size) ? ((PyByteArrayObject *)(name2))->
ob_bytes : _PyByteArray_empty_string)
;
1384 } else {
1385 name_str = NULL((void*)0);
1386 name2 = NULL((void*)0);
1387 }
1388 handle = ctypes_dlopendlopen(name_str, mode);
1389 Py_XDECREF(name2)do { if ((name2) == ((void*)0)) ; else do { if (_Py_RefTotal--
, --((PyObject*)(name2))->ob_refcnt != 0) { if (((PyObject
*)name2)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1389, (PyObject *)(name2)); } else _Py_Dealloc((PyObject *)
(name2)); } while (0); } while (0)
;
1390 if (!handle) {
1391 char *errmsg = ctypes_dlerrordlerror();
1392 if (!errmsg)
1393 errmsg = "dlopen() error";
1394 PyErr_SetString(PyExc_OSError,
1395 errmsg);
1396 return NULL((void*)0);
1397 }
1398 return PyLong_FromVoidPtr(handle);
1399}
1400
1401static PyObject *py_dl_close(PyObject *self, PyObject *args)
1402{
1403 void *handle;
1404
1405 if (!PyArg_ParseTuple(args, "O&:dlclose", &_parse_voidp, &handle))
1406 return NULL((void*)0);
1407 if (dlclose(handle)) {
1408 PyErr_SetString(PyExc_OSError,
1409 ctypes_dlerrordlerror());
1410 return NULL((void*)0);
1411 }
1412 Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt
++)
;
1413 return Py_None(&_Py_NoneStruct);
1414}
1415
1416static PyObject *py_dl_sym(PyObject *self, PyObject *args)
1417{
1418 char *name;
1419 void *handle;
1420 void *ptr;
1421
1422 if (!PyArg_ParseTuple(args, "O&s:dlsym",
1423 &_parse_voidp, &handle, &name))
1424 return NULL((void*)0);
1425 ptr = ctypes_dlsymdlsym((void*)handle, name);
1426 if (!ptr) {
1427 PyErr_SetString(PyExc_OSError,
1428 ctypes_dlerrordlerror());
1429 return NULL((void*)0);
1430 }
1431 return PyLong_FromVoidPtr(ptr);
1432}
1433#endif
1434
1435/*
1436 * Only for debugging so far: So that we can call CFunction instances
1437 *
1438 * XXX Needs to accept more arguments: flags, argtypes, restype
1439 */
1440static PyObject *
1441call_function(PyObject *self, PyObject *args)
1442{
1443 void *func;
1444 PyObject *arguments;
1445 PyObject *result;
1446
1447 if (!PyArg_ParseTuple(args,
1448 "O&O!",
1449 &_parse_voidp, &func,
1450 &PyTuple_Type, &arguments))
1451 return NULL((void*)0);
1452
1453 result = _ctypes_callproc((PPROC)func,
1454 arguments,
1455#ifdef MS_WIN32
1456 NULL((void*)0),
1457 NULL((void*)0),
1458#endif
1459 0, /* flags */
1460 NULL((void*)0), /* self->argtypes */
1461 NULL((void*)0), /* self->restype */
1462 NULL((void*)0)); /* checker */
1463 return result;
1464}
1465
1466/*
1467 * Only for debugging so far: So that we can call CFunction instances
1468 *
1469 * XXX Needs to accept more arguments: flags, argtypes, restype
1470 */
1471static PyObject *
1472call_cdeclfunction(PyObject *self, PyObject *args)
1473{
1474 void *func;
1475 PyObject *arguments;
1476 PyObject *result;
1477
1478 if (!PyArg_ParseTuple(args,
1479 "O&O!",
1480 &_parse_voidp, &func,
1481 &PyTuple_Type, &arguments))
1482 return NULL((void*)0);
1483
1484 result = _ctypes_callproc((PPROC)func,
1485 arguments,
1486#ifdef MS_WIN32
1487 NULL((void*)0),
1488 NULL((void*)0),
1489#endif
1490 FUNCFLAG_CDECL0x1, /* flags */
1491 NULL((void*)0), /* self->argtypes */
1492 NULL((void*)0), /* self->restype */
1493 NULL((void*)0)); /* checker */
1494 return result;
1495}
1496
1497/*****************************************************************
1498 * functions
1499 */
1500static char sizeof_doc[] =
1501"sizeof(C type) -> integer\n"
1502"sizeof(C instance) -> integer\n"
1503"Return the size in bytes of a C instance";
1504
1505static PyObject *
1506sizeof_func(PyObject *self, PyObject *obj)
1507{
1508 StgDictObject *dict;
1509
1510 dict = PyType_stgdict(obj);
1511 if (dict)
1512 return PyLong_FromSsize_t(dict->size);
1513
1514 if (CDataObject_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyCData_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyCData_Type)))
)
1515 return PyLong_FromSsize_t(((CDataObject *)obj)->b_size);
1516 PyErr_SetString(PyExc_TypeError,
1517 "this type has no size");
1518 return NULL((void*)0);
1519}
1520
1521static char alignment_doc[] =
1522"alignment(C type) -> integer\n"
1523"alignment(C instance) -> integer\n"
1524"Return the alignment requirements of a C instance";
1525
1526static PyObject *
1527align_func(PyObject *self, PyObject *obj)
1528{
1529 StgDictObject *dict;
1530
1531 dict = PyType_stgdict(obj);
1532 if (dict)
1533 return PyLong_FromSsize_t(dict->align);
1534
1535 dict = PyObject_stgdict(obj);
1536 if (dict)
1537 return PyLong_FromSsize_t(dict->align);
1538
1539 PyErr_SetString(PyExc_TypeError,
1540 "no alignment info");
1541 return NULL((void*)0);
1542}
1543
1544static char byref_doc[] =
1545"byref(C instance[, offset=0]) -> byref-object\n"
1546"Return a pointer lookalike to a C instance, only usable\n"
1547"as function argument";
1548
1549/*
1550 * We must return something which can be converted to a parameter,
1551 * but still has a reference to self.
1552 */
1553static PyObject *
1554byref(PyObject *self, PyObject *args)
1555{
1556 PyCArgObject *parg;
1557 PyObject *obj;
1558 PyObject *pyoffset = NULL((void*)0);
1559 Py_ssize_t offset = 0;
1560
1561 if (!PyArg_UnpackTuple(args, "byref", 1, 2,
1562 &obj, &pyoffset))
1563 return NULL((void*)0);
1564 if (pyoffset) {
1565 offset = PyNumber_AsSsize_t(pyoffset, NULL((void*)0));
1566 if (offset == -1 && PyErr_Occurred())
1567 return NULL((void*)0);
1568 }
1569 if (!CDataObject_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyCData_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyCData_Type)))
) {
1570 PyErr_Format(PyExc_TypeError,
1571 "byref() argument must be a ctypes instance, not '%s'",
1572 Py_TYPE(obj)(((PyObject*)(obj))->ob_type)->tp_name);
1573 return NULL((void*)0);
1574 }
1575
1576 parg = PyCArgObject_new();
1577 if (parg == NULL((void*)0))
1578 return NULL((void*)0);
1579
1580 parg->tag = 'P';
1581 parg->pffi_type = &ffi_type_pointer;
1582 Py_INCREF(obj)( _Py_RefTotal++ , ((PyObject*)(obj))->ob_refcnt++);
1583 parg->obj = obj;
1584 parg->value.p = (char *)((CDataObject *)obj)->b_ptr + offset;
1585 return (PyObject *)parg;
1586}
1587
1588static char addressof_doc[] =
1589"addressof(C instance) -> integer\n"
1590"Return the address of the C instance internal buffer";
1591
1592static PyObject *
1593addressof(PyObject *self, PyObject *obj)
1594{
1595 if (CDataObject_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyCData_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyCData_Type)))
)
1596 return PyLong_FromVoidPtr(((CDataObject *)obj)->b_ptr);
1597 PyErr_SetString(PyExc_TypeError,
1598 "invalid type");
1599 return NULL((void*)0);
1600}
1601
1602static int
1603converter(PyObject *obj, void **address)
1604{
1605 *address = PyLong_AsVoidPtr(obj);
1606 return *address != NULL((void*)0);
1607}
1608
1609static PyObject *
1610My_PyObj_FromPtr(PyObject *self, PyObject *args)
1611{
1612 PyObject *ob;
1613 if (!PyArg_ParseTuple(args, "O&:PyObj_FromPtr", converter, &ob))
1614 return NULL((void*)0);
1615 Py_INCREF(ob)( _Py_RefTotal++ , ((PyObject*)(ob))->ob_refcnt++);
1616 return ob;
1617}
1618
1619static PyObject *
1620My_Py_INCREF(PyObject *self, PyObject *arg)
1621{
1622 Py_INCREF(arg)( _Py_RefTotal++ , ((PyObject*)(arg))->ob_refcnt++); /* that's what this function is for */
1623 Py_INCREF(arg)( _Py_RefTotal++ , ((PyObject*)(arg))->ob_refcnt++); /* that for returning it */
1624 return arg;
1625}
1626
1627static PyObject *
1628My_Py_DECREF(PyObject *self, PyObject *arg)
1629{
1630 Py_DECREF(arg)do { if (_Py_RefTotal-- , --((PyObject*)(arg))->ob_refcnt !=
0) { if (((PyObject*)arg)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1630, (PyObject *)(arg)); } else _Py_Dealloc((PyObject *)(arg
)); } while (0)
; /* that's what this function is for */
1631 Py_INCREF(arg)( _Py_RefTotal++ , ((PyObject*)(arg))->ob_refcnt++); /* that's for returning it */
1632 return arg;
1633}
1634
1635static PyObject *
1636resize(PyObject *self, PyObject *args)
1637{
1638 CDataObject *obj;
1639 StgDictObject *dict;
1640 Py_ssize_t size;
1641
1642 if (!PyArg_ParseTuple(args,
1643 "On:resize",
1644 &obj, &size))
1645 return NULL((void*)0);
1646
1647 dict = PyObject_stgdict((PyObject *)obj);
1648 if (dict == NULL((void*)0)) {
1649 PyErr_SetString(PyExc_TypeError,
1650 "excepted ctypes instance");
1651 return NULL((void*)0);
1652 }
1653 if (size < dict->size) {
1654 PyErr_Format(PyExc_ValueError,
1655 "minimum size is %zd",
1656 dict->size);
1657 return NULL((void*)0);
1658 }
1659 if (obj->b_needsfree == 0) {
1660 PyErr_Format(PyExc_ValueError,
1661 "Memory cannot be resized because this object doesn't own it");
1662 return NULL((void*)0);
1663 }
1664 if (size <= sizeof(obj->b_value)) {
1665 /* internal default buffer is large enough */
1666 obj->b_size = size;
1667 goto done;
1668 }
1669 if (obj->b_size <= sizeof(obj->b_value)) {
1670 /* We are currently using the objects default buffer, but it
1671 isn't large enough any more. */
1672 void *ptr = PyMem_Malloc(size);
1673 if (ptr == NULL((void*)0))
1674 return PyErr_NoMemory();
1675 memset(ptr, 0, size)((__builtin_object_size (ptr, 0) != (size_t) -1) ? __builtin___memset_chk
(ptr, 0, size, __builtin_object_size (ptr, 0)) : __inline_memset_chk
(ptr, 0, size))
;
1676 memmove(ptr, obj->b_ptr, obj->b_size)((__builtin_object_size (ptr, 0) != (size_t) -1) ? __builtin___memmove_chk
(ptr, obj->b_ptr, obj->b_size, __builtin_object_size (
ptr, 0)) : __inline_memmove_chk (ptr, obj->b_ptr, obj->
b_size))
;
1677 obj->b_ptr = ptr;
1678 obj->b_size = size;
1679 } else {
1680 void * ptr = PyMem_Realloc(obj->b_ptr, size);
1681 if (ptr == NULL((void*)0))
1682 return PyErr_NoMemory();
1683 obj->b_ptr = ptr;
1684 obj->b_size = size;
1685 }
1686 done:
1687 Py_INCREF(Py_None)( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt
++)
;
1688 return Py_None(&_Py_NoneStruct);
1689}
1690
1691static PyObject *
1692unpickle(PyObject *self, PyObject *args)
1693{
1694 PyObject *typ;
1695 PyObject *state;
1696 PyObject *result;
1697 PyObject *tmp;
1698
1699 if (!PyArg_ParseTuple(args, "OO", &typ, &state))
1700 return NULL((void*)0);
1701 result = PyObject_CallMethod(typ, "__new__", "O", typ);
1702 if (result == NULL((void*)0))
1703 return NULL((void*)0);
1704 tmp = PyObject_CallMethod(result, "__setstate__", "O", state);
1705 if (tmp == NULL((void*)0)) {
1706 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1706, (PyObject *)(result)); } else _Py_Dealloc((PyObject *
)(result)); } while (0)
;
1707 return NULL((void*)0);
1708 }
1709 Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt !=
0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1709, (PyObject *)(tmp)); } else _Py_Dealloc((PyObject *)(tmp
)); } while (0)
;
1710 return result;
1711}
1712
1713static PyObject *
1714POINTER(PyObject *self, PyObject *cls)
1715{
1716 PyObject *result;
1717 PyTypeObject *typ;
1718 PyObject *key;
1719 char *buf;
1720
1721 result = PyDict_GetItem(_ctypes_ptrtype_cache, cls);
1722 if (result) {
1723 Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++);
1724 return result;
1725 }
1726 if (PyUnicode_CheckExact(cls)((((PyObject*)(cls))->ob_type) == &PyUnicode_Type)) {
1727 char *name = _PyUnicode_AsString(cls);
1728 buf = alloca(strlen(name) + 3 + 1)__builtin_alloca(strlen(name) + 3 + 1);
1729 sprintf(buf, "LP_%s", name)__builtin___sprintf_chk (buf, 0, __builtin_object_size (buf, 2
> 1), "LP_%s", name)
;
1730 result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type)(((PyObject*)(&PyCPointer_Type))->ob_type),
1731 "s(O){}",
1732 buf,
1733 &PyCPointer_Type);
1734 if (result == NULL((void*)0))
1735 return result;
1736 key = PyLong_FromVoidPtr(result);
1737 } else if (PyType_Check(cls)((((((PyObject*)(cls))->ob_type))->tp_flags & ((1L<<
31))) != 0)
) {
1738 typ = (PyTypeObject *)cls;
1739 buf = alloca(strlen(typ->tp_name) + 3 + 1)__builtin_alloca(strlen(typ->tp_name) + 3 + 1);
1740 sprintf(buf, "LP_%s", typ->tp_name)__builtin___sprintf_chk (buf, 0, __builtin_object_size (buf, 2
> 1), "LP_%s", typ->tp_name)
;
1741 result = PyObject_CallFunction((PyObject *)Py_TYPE(&PyCPointer_Type)(((PyObject*)(&PyCPointer_Type))->ob_type),
1742 "s(O){sO}",
1743 buf,
1744 &PyCPointer_Type,
1745 "_type_", cls);
1746 if (result == NULL((void*)0))
1747 return result;
1748 Py_INCREF(cls)( _Py_RefTotal++ , ((PyObject*)(cls))->ob_refcnt++);
1749 key = cls;
1750 } else {
1751 PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
1752 return NULL((void*)0);
1753 }
1754 if (-1 == PyDict_SetItem(_ctypes_ptrtype_cache, key, result)) {
1755 Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt
!= 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1755, (PyObject *)(result)); } else _Py_Dealloc((PyObject *
)(result)); } while (0)
;
1756 Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt !=
0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1756, (PyObject *)(key)); } else _Py_Dealloc((PyObject *)(key
)); } while (0)
;
1757 return NULL((void*)0);
1758 }
1759 Py_DECREF(key)do { if (_Py_RefTotal-- , --((PyObject*)(key))->ob_refcnt !=
0) { if (((PyObject*)key)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1759, (PyObject *)(key)); } else _Py_Dealloc((PyObject *)(key
)); } while (0)
;
1760 return result;
1761}
1762
1763static PyObject *
1764pointer(PyObject *self, PyObject *arg)
1765{
1766 PyObject *result;
1767 PyObject *typ;
1768
1769 typ = PyDict_GetItem(_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg)(((PyObject*)(arg))->ob_type));
1770 if (typ)
1771 return PyObject_CallFunctionObjArgs(typ, arg, NULL((void*)0));
1772 typ = POINTER(NULL((void*)0), (PyObject *)Py_TYPE(arg)(((PyObject*)(arg))->ob_type));
1773 if (typ == NULL((void*)0))
1774 return NULL((void*)0);
1775 result = PyObject_CallFunctionObjArgs(typ, arg, NULL((void*)0));
1776 Py_DECREF(typ)do { if (_Py_RefTotal-- , --((PyObject*)(typ))->ob_refcnt !=
0) { if (((PyObject*)typ)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1776, (PyObject *)(typ)); } else _Py_Dealloc((PyObject *)(typ
)); } while (0)
;
1777 return result;
1778}
1779
1780static PyObject *
1781buffer_info(PyObject *self, PyObject *arg)
1782{
1783 StgDictObject *dict = PyType_stgdict(arg);
1784 PyObject *shape;
1785 Py_ssize_t i;
1786
1787 if (dict == NULL((void*)0))
1788 dict = PyObject_stgdict(arg);
1789 if (dict == NULL((void*)0)) {
1790 PyErr_SetString(PyExc_TypeError,
1791 "not a ctypes type or object");
1792 return NULL((void*)0);
1793 }
1794 shape = PyTuple_New(dict->ndim);
1795 if (shape == NULL((void*)0))
1796 return NULL((void*)0);
1797 for (i = 0; i < (int)dict->ndim; ++i)
1798 PyTuple_SET_ITEM(shape, i, PyLong_FromSsize_t(dict->shape[i]))(((PyTupleObject *)(shape))->ob_item[i] = PyLong_FromSsize_t
(dict->shape[i]))
;
1799
1800 if (PyErr_Occurred()) {
1801 Py_DECREF(shape)do { if (_Py_RefTotal-- , --((PyObject*)(shape))->ob_refcnt
!= 0) { if (((PyObject*)shape)->ob_refcnt < 0) _Py_NegativeRefcount
("/Users/brett/Dev/python/3.x/py3k/Modules/_ctypes/callproc.c"
, 1801, (PyObject *)(shape)); } else _Py_Dealloc((PyObject *)
(shape)); } while (0)
;
1802 return NULL((void*)0);
1803 }
1804 return Py_BuildValue("siN", dict->format, dict->ndim, shape);
1805}
1806
1807PyMethodDef _ctypes_module_methods[] = {
1808 {"get_errno", get_errno, METH_NOARGS0x0004},
1809 {"set_errno", set_errno, METH_VARARGS0x0001},
1810 {"POINTER", POINTER, METH_O0x0008 },
1811 {"pointer", pointer, METH_O0x0008 },
1812 {"_unpickle", unpickle, METH_VARARGS0x0001 },
1813 {"buffer_info", buffer_info, METH_O0x0008, "Return buffer interface information"},
1814 {"resize", resize, METH_VARARGS0x0001, "Resize the memory buffer of a ctypes instance"},
1815#ifdef MS_WIN32
1816 {"get_last_error", get_last_error, METH_NOARGS0x0004},
1817 {"set_last_error", set_last_error, METH_VARARGS0x0001},
1818 {"CopyComPointer", copy_com_pointer, METH_VARARGS0x0001, copy_com_pointer_doc},
1819 {"FormatError", format_error, METH_VARARGS0x0001, format_error_doc},
1820 {"LoadLibrary", load_library, METH_VARARGS0x0001, load_library_doc},
1821 {"FreeLibrary", free_library, METH_VARARGS0x0001, free_library_doc},
1822 {"call_commethod", call_commethod, METH_VARARGS0x0001 },
1823 {"_check_HRESULT", check_hresult, METH_VARARGS0x0001},
1824#else
1825 {"dlopen", py_dl_open, METH_VARARGS0x0001,
1826 "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library"},
1827 {"dlclose", py_dl_close, METH_VARARGS0x0001, "dlclose a library"},
1828 {"dlsym", py_dl_sym, METH_VARARGS0x0001, "find symbol in shared library"},
1829#endif
1830 {"alignment", align_func, METH_O0x0008, alignment_doc},
1831 {"sizeof", sizeof_func, METH_O0x0008, sizeof_doc},
1832 {"byref", byref, METH_VARARGS0x0001, byref_doc},
1833 {"addressof", addressof, METH_O0x0008, addressof_doc},
1834 {"call_function", call_function, METH_VARARGS0x0001 },
1835 {"call_cdeclfunction", call_cdeclfunction, METH_VARARGS0x0001 },
1836 {"PyObj_FromPtr", My_PyObj_FromPtr, METH_VARARGS0x0001 },
1837 {"Py_INCREF", My_Py_INCREF, METH_O0x0008 },
1838 {"Py_DECREF", My_Py_DECREF, METH_O0x0008 },
1839 {NULL((void*)0), NULL((void*)0)} /* Sentinel */
1840};
1841
1842/*
1843 Local Variables:
1844 compile-command: "cd .. && python setup.py -q build -g && python setup.py -q build install --home ~"
1845 End:
1846*/