1 /*****************************************************************
2 This file contains remnant Python 2.3 compatibility code that is no longer
3 strictly required.
4 *****************************************************************/
5
6 #include "Python.h"
7
8 #include <ffi.h>
9 #ifdef MS_WIN32
10 #include <windows.h>
11 #endif
12 #include "ctypes.h"
13
14
15 #if defined(CTYPES_UNICODE) && !defined(HAVE_USABLE_WCHAR_T)
16 # define CTYPES_CAPSULE_WCHAR_T "_ctypes/cfield.c wchar_t buffer from unicode"
CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_WCHAR_T)17 CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_WCHAR_T)
18 #endif
19
20
21 /******************************************************************/
22 /*
23 PyCField_Type
24 */
25 static PyObject *
26 PyCField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
27 {
28 CFieldObject *obj;
29 obj = (CFieldObject *)type->tp_alloc(type, 0);
30 return (PyObject *)obj;
31 }
32
33 /*
34 * Expects the size, index and offset for the current field in *psize and
35 * *poffset, stores the total size so far in *psize, the offset for the next
36 * field in *poffset, the alignment requirements for the current field in
37 * *palign, and returns a field desriptor for this field.
38 */
39 /*
40 * bitfields extension:
41 * bitsize != 0: this is a bit field.
42 * pbitofs points to the current bit offset, this will be updated.
43 * prev_desc points to the type of the previous bitfield, if any.
44 */
45 PyObject *
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)46 PyCField_FromDesc(PyObject *desc, Py_ssize_t index,
47 Py_ssize_t *pfield_size, int bitsize, int *pbitofs,
48 Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,
49 int pack, int big_endian)
50 {
51 CFieldObject *self;
52 PyObject *proto;
53 Py_ssize_t size, align;
54 SETFUNC setfunc = NULL;
55 GETFUNC getfunc = NULL;
56 StgDictObject *dict;
57 int fieldtype;
58 #define NO_BITFIELD 0
59 #define NEW_BITFIELD 1
60 #define CONT_BITFIELD 2
61 #define EXPAND_BITFIELD 3
62
63 self = (CFieldObject *)PyObject_CallObject((PyObject *)&PyCField_Type,
64 NULL);
65 if (self == NULL)
66 return NULL;
67 dict = PyType_stgdict(desc);
68 if (!dict) {
69 PyErr_SetString(PyExc_TypeError,
70 "has no _stginfo_");
71 Py_DECREF(self);
72 return NULL;
73 }
74 if (bitsize /* this is a bitfield request */
75 && *pfield_size /* we have a bitfield open */
76 #ifdef MS_WIN32
77 /* MSVC, GCC with -mms-bitfields */
78 && dict->size * 8 == *pfield_size
79 #else
80 /* GCC */
81 && dict->size * 8 <= *pfield_size
82 #endif
83 && (*pbitofs + bitsize) <= *pfield_size) {
84 /* continue bit field */
85 fieldtype = CONT_BITFIELD;
86 #ifndef MS_WIN32
87 } else if (bitsize /* this is a bitfield request */
88 && *pfield_size /* we have a bitfield open */
89 && dict->size * 8 >= *pfield_size
90 && (*pbitofs + bitsize) <= dict->size * 8) {
91 /* expand bit field */
92 fieldtype = EXPAND_BITFIELD;
93 #endif
94 } else if (bitsize) {
95 /* start new bitfield */
96 fieldtype = NEW_BITFIELD;
97 *pbitofs = 0;
98 *pfield_size = dict->size * 8;
99 } else {
100 /* not a bit field */
101 fieldtype = NO_BITFIELD;
102 *pbitofs = 0;
103 *pfield_size = 0;
104 }
105
106 size = dict->size;
107 proto = desc;
108
109 /* Field descriptors for 'c_char * n' are be scpecial cased to
110 return a Python string instead of an Array object instance...
111 */
112 if (PyCArrayTypeObject_Check(proto)) {
113 StgDictObject *adict = PyType_stgdict(proto);
114 StgDictObject *idict;
115 if (adict && adict->proto) {
116 idict = PyType_stgdict(adict->proto);
117 if (!idict) {
118 PyErr_SetString(PyExc_TypeError,
119 "has no _stginfo_");
120 Py_DECREF(self);
121 return NULL;
122 }
123 if (idict->getfunc == _ctypes_get_fielddesc("c")->getfunc) {
124 struct fielddesc *fd = _ctypes_get_fielddesc("s");
125 getfunc = fd->getfunc;
126 setfunc = fd->setfunc;
127 }
128 #ifdef CTYPES_UNICODE
129 if (idict->getfunc == _ctypes_get_fielddesc("u")->getfunc) {
130 struct fielddesc *fd = _ctypes_get_fielddesc("U");
131 getfunc = fd->getfunc;
132 setfunc = fd->setfunc;
133 }
134 #endif
135 }
136 }
137
138 self->setfunc = setfunc;
139 self->getfunc = getfunc;
140 self->index = index;
141
142 Py_INCREF(proto);
143 self->proto = proto;
144
145 switch (fieldtype) {
146 case NEW_BITFIELD:
147 if (big_endian)
148 self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;
149 else
150 self->size = (bitsize << 16) + *pbitofs;
151 *pbitofs = bitsize;
152 /* fall through */
153 case NO_BITFIELD:
154 if (pack)
155 align = min(pack, dict->align);
156 else
157 align = dict->align;
158 if (align && *poffset % align) {
159 Py_ssize_t delta = align - (*poffset % align);
160 *psize += delta;
161 *poffset += delta;
162 }
163
164 if (bitsize == 0)
165 self->size = size;
166 *psize += size;
167
168 self->offset = *poffset;
169 *poffset += size;
170
171 *palign = align;
172 break;
173
174 case EXPAND_BITFIELD:
175 *poffset += dict->size - *pfield_size/8;
176 *psize += dict->size - *pfield_size/8;
177
178 *pfield_size = dict->size * 8;
179
180 if (big_endian)
181 self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;
182 else
183 self->size = (bitsize << 16) + *pbitofs;
184
185 self->offset = *poffset - size; /* poffset is already updated for the NEXT field */
186 *pbitofs += bitsize;
187 break;
188
189 case CONT_BITFIELD:
190 if (big_endian)
191 self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;
192 else
193 self->size = (bitsize << 16) + *pbitofs;
194
195 self->offset = *poffset - size; /* poffset is already updated for the NEXT field */
196 *pbitofs += bitsize;
197 break;
198 }
199
200 return (PyObject *)self;
201 }
202
203 static int
PyCField_set(CFieldObject * self,PyObject * inst,PyObject * value)204 PyCField_set(CFieldObject *self, PyObject *inst, PyObject *value)
205 {
206 CDataObject *dst;
207 char *ptr;
208 if (!CDataObject_Check(inst)) {
209 PyErr_SetString(PyExc_TypeError,
210 "not a ctype instance");
211 return -1;
212 }
213 dst = (CDataObject *)inst;
214 ptr = dst->b_ptr + self->offset;
215 if (value == NULL) {
216 PyErr_SetString(PyExc_TypeError,
217 "can't delete attribute");
218 return -1;
219 }
220 return PyCData_set(inst, self->proto, self->setfunc, value,
221 self->index, self->size, ptr);
222 }
223
224 static PyObject *
PyCField_get(CFieldObject * self,PyObject * inst,PyTypeObject * type)225 PyCField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type)
226 {
227 CDataObject *src;
228 if (inst == NULL) {
229 Py_INCREF(self);
230 return (PyObject *)self;
231 }
232 if (!CDataObject_Check(inst)) {
233 PyErr_SetString(PyExc_TypeError,
234 "not a ctype instance");
235 return NULL;
236 }
237 src = (CDataObject *)inst;
238 return PyCData_get(self->proto, self->getfunc, inst,
239 self->index, self->size, src->b_ptr + self->offset);
240 }
241
242 static PyObject *
PyCField_get_offset(PyObject * self,void * data)243 PyCField_get_offset(PyObject *self, void *data)
244 {
245 return PyInt_FromSsize_t(((CFieldObject *)self)->offset);
246 }
247
248 static PyObject *
PyCField_get_size(PyObject * self,void * data)249 PyCField_get_size(PyObject *self, void *data)
250 {
251 return PyInt_FromSsize_t(((CFieldObject *)self)->size);
252 }
253
254 static PyGetSetDef PyCField_getset[] = {
255 { "offset", PyCField_get_offset, NULL, "offset in bytes of this field" },
256 { "size", PyCField_get_size, NULL, "size in bytes of this field" },
257 { NULL, NULL, NULL, NULL },
258 };
259
260 static int
PyCField_traverse(CFieldObject * self,visitproc visit,void * arg)261 PyCField_traverse(CFieldObject *self, visitproc visit, void *arg)
262 {
263 Py_VISIT(self->proto);
264 return 0;
265 }
266
267 static int
PyCField_clear(CFieldObject * self)268 PyCField_clear(CFieldObject *self)
269 {
270 Py_CLEAR(self->proto);
271 return 0;
272 }
273
274 static void
PyCField_dealloc(PyObject * self)275 PyCField_dealloc(PyObject *self)
276 {
277 PyCField_clear((CFieldObject *)self);
278 self->ob_type->tp_free((PyObject *)self);
279 }
280
281 static PyObject *
PyCField_repr(CFieldObject * self)282 PyCField_repr(CFieldObject *self)
283 {
284 PyObject *result;
285 Py_ssize_t bits = self->size >> 16;
286 Py_ssize_t size = self->size & 0xFFFF;
287 const char *name;
288
289 name = ((PyTypeObject *)self->proto)->tp_name;
290
291 if (bits)
292 result = PyString_FromFormat(
293 #if (PY_VERSION_HEX < 0x02050000)
294 "<Field type=%s, ofs=%d:%d, bits=%d>",
295 #else
296 "<Field type=%s, ofs=%zd:%zd, bits=%zd>",
297 #endif
298 name, self->offset, size, bits);
299 else
300 result = PyString_FromFormat(
301 #if (PY_VERSION_HEX < 0x02050000)
302 "<Field type=%s, ofs=%d, size=%d>",
303 #else
304 "<Field type=%s, ofs=%zd, size=%zd>",
305 #endif
306 name, self->offset, size);
307 return result;
308 }
309
310 PyTypeObject PyCField_Type = {
311 PyVarObject_HEAD_INIT(NULL, 0)
312 "_ctypes.CField", /* tp_name */
313 sizeof(CFieldObject), /* tp_basicsize */
314 0, /* tp_itemsize */
315 PyCField_dealloc, /* tp_dealloc */
316 0, /* tp_print */
317 0, /* tp_getattr */
318 0, /* tp_setattr */
319 0, /* tp_compare */
320 (reprfunc)PyCField_repr, /* tp_repr */
321 0, /* tp_as_number */
322 0, /* tp_as_sequence */
323 0, /* tp_as_mapping */
324 0, /* tp_hash */
325 0, /* tp_call */
326 0, /* tp_str */
327 0, /* tp_getattro */
328 0, /* tp_setattro */
329 0, /* tp_as_buffer */
330 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
331 "Structure/Union member", /* tp_doc */
332 (traverseproc)PyCField_traverse, /* tp_traverse */
333 (inquiry)PyCField_clear, /* tp_clear */
334 0, /* tp_richcompare */
335 0, /* tp_weaklistoffset */
336 0, /* tp_iter */
337 0, /* tp_iternext */
338 0, /* tp_methods */
339 0, /* tp_members */
340 PyCField_getset, /* tp_getset */
341 0, /* tp_base */
342 0, /* tp_dict */
343 (descrgetfunc)PyCField_get, /* tp_descr_get */
344 (descrsetfunc)PyCField_set, /* tp_descr_set */
345 0, /* tp_dictoffset */
346 0, /* tp_init */
347 0, /* tp_alloc */
348 PyCField_new, /* tp_new */
349 0, /* tp_free */
350 };
351
352
353 /******************************************************************/
354 /*
355 Accessor functions
356 */
357
358 /* Derived from Modules/structmodule.c:
359 Helper routine to get a Python integer and raise the appropriate error
360 if it isn't one */
361
362 static int
get_long(PyObject * v,long * p)363 get_long(PyObject *v, long *p)
364 {
365 long x;
366 if (PyFloat_Check(v)) {
367 PyErr_SetString(PyExc_TypeError,
368 "int expected instead of float");
369 return -1;
370 }
371 x = PyInt_AsUnsignedLongMask(v);
372 if (x == -1 && PyErr_Occurred())
373 return -1;
374 *p = x;
375 return 0;
376 }
377
378 /* Same, but handling unsigned long */
379
380 static int
get_ulong(PyObject * v,unsigned long * p)381 get_ulong(PyObject *v, unsigned long *p)
382 {
383 unsigned long x;
384 if (PyFloat_Check(v)) {
385 PyErr_SetString(PyExc_TypeError,
386 "int expected instead of float");
387 return -1;
388 }
389 x = PyInt_AsUnsignedLongMask(v);
390 if (x == (unsigned long)-1 && PyErr_Occurred())
391 return -1;
392 *p = x;
393 return 0;
394 }
395
396 #ifdef HAVE_LONG_LONG
397
398 /* Same, but handling native long long. */
399
400 static int
get_longlong(PyObject * v,PY_LONG_LONG * p)401 get_longlong(PyObject *v, PY_LONG_LONG *p)
402 {
403 PY_LONG_LONG x;
404 if (PyFloat_Check(v)) {
405 PyErr_SetString(PyExc_TypeError,
406 "int expected instead of float");
407 return -1;
408 }
409 x = PyInt_AsUnsignedLongLongMask(v);
410 if (x == -1 && PyErr_Occurred())
411 return -1;
412 *p = x;
413 return 0;
414 }
415
416 /* Same, but handling native unsigned long long. */
417
418 static int
get_ulonglong(PyObject * v,unsigned PY_LONG_LONG * p)419 get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
420 {
421 unsigned PY_LONG_LONG x;
422 if (PyFloat_Check(v)) {
423 PyErr_SetString(PyExc_TypeError,
424 "int expected instead of float");
425 return -1;
426 }
427 x = PyInt_AsUnsignedLongLongMask(v);
428 if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())
429 return -1;
430 *p = x;
431 return 0;
432 }
433
434 #endif
435
436 /*****************************************************************
437 * Integer fields, with bitfield support
438 */
439
440 /* how to decode the size field, for integer get/set functions */
441 #define LOW_BIT(x) ((x) & 0xFFFF)
442 #define NUM_BITS(x) ((x) >> 16)
443
444 /* Doesn't work if NUM_BITS(size) == 0, but it never happens in SET() call. */
445 #define BIT_MASK(type, size) (((((type)1 << (NUM_BITS(size) - 1)) - 1) << 1) + 1)
446
447 /* This macro CHANGES the first parameter IN PLACE. For proper sign handling,
448 we must first shift left, then right.
449 */
450 #define GET_BITFIELD(v, size) \
451 if (NUM_BITS(size)) { \
452 v <<= (sizeof(v)*8 - LOW_BIT(size) - NUM_BITS(size)); \
453 v >>= (sizeof(v)*8 - NUM_BITS(size)); \
454 }
455
456 /* This macro RETURNS the first parameter with the bit field CHANGED. */
457 #define SET(type, x, v, size) \
458 (NUM_BITS(size) ? \
459 ( ( (type)x & ~(BIT_MASK(type, size) << LOW_BIT(size)) ) | ( ((type)v & BIT_MASK(type, size)) << LOW_BIT(size) ) ) \
460 : (type)v)
461
462 /* byte swapping macros */
463 #define SWAP_2(v) \
464 ( ( (v >> 8) & 0x00FF) | \
465 ( (v << 8) & 0xFF00) )
466
467 #define SWAP_4(v) \
468 ( ( (v & 0x000000FF) << 24 ) | \
469 ( (v & 0x0000FF00) << 8 ) | \
470 ( (v & 0x00FF0000) >> 8 ) | \
471 ( ((v >> 24) & 0xFF)) )
472
473 #ifdef _MSC_VER
474 #define SWAP_8(v) \
475 ( ( (v & 0x00000000000000FFL) << 56 ) | \
476 ( (v & 0x000000000000FF00L) << 40 ) | \
477 ( (v & 0x0000000000FF0000L) << 24 ) | \
478 ( (v & 0x00000000FF000000L) << 8 ) | \
479 ( (v & 0x000000FF00000000L) >> 8 ) | \
480 ( (v & 0x0000FF0000000000L) >> 24 ) | \
481 ( (v & 0x00FF000000000000L) >> 40 ) | \
482 ( ((v >> 56) & 0xFF)) )
483 #else
484 #define SWAP_8(v) \
485 ( ( (v & 0x00000000000000FFLL) << 56 ) | \
486 ( (v & 0x000000000000FF00LL) << 40 ) | \
487 ( (v & 0x0000000000FF0000LL) << 24 ) | \
488 ( (v & 0x00000000FF000000LL) << 8 ) | \
489 ( (v & 0x000000FF00000000LL) >> 8 ) | \
490 ( (v & 0x0000FF0000000000LL) >> 24 ) | \
491 ( (v & 0x00FF000000000000LL) >> 40 ) | \
492 ( ((v >> 56) & 0xFF)) )
493 #endif
494
495 #define SWAP_INT SWAP_4
496
497 #if SIZEOF_LONG == 4
498 # define SWAP_LONG SWAP_4
499 #elif SIZEOF_LONG == 8
500 # define SWAP_LONG SWAP_8
501 #endif
502 /*****************************************************************
503 * The setter methods return an object which must be kept alive, to keep the
504 * data valid which has been stored in the memory block. The ctypes object
505 * instance inserts this object into its 'b_objects' list.
506 *
507 * For simple Python types like integers or characters, there is nothing that
508 * has to been kept alive, so Py_None is returned in these cases. But this
509 * makes inspecting the 'b_objects' list, which is accessible from Python for
510 * debugging, less useful.
511 *
512 * So, defining the _CTYPES_DEBUG_KEEP symbol returns the original value
513 * instead of Py_None.
514 */
515
516 #ifdef _CTYPES_DEBUG_KEEP
517 #define _RET(x) Py_INCREF(x); return x
518 #else
519 #define _RET(X) Py_INCREF(Py_None); return Py_None
520 #endif
521
522 /*****************************************************************
523 * integer accessor methods, supporting bit fields
524 */
525
526 static PyObject *
b_set(void * ptr,PyObject * value,Py_ssize_t size)527 b_set(void *ptr, PyObject *value, Py_ssize_t size)
528 {
529 long val;
530 if (get_long(value, &val) < 0)
531 return NULL;
532 *(signed char *)ptr = SET(signed char, *(signed char *)ptr, val, size);
533 _RET(value);
534 }
535
536
537 static PyObject *
b_get(void * ptr,Py_ssize_t size)538 b_get(void *ptr, Py_ssize_t size)
539 {
540 signed char val = *(signed char *)ptr;
541 GET_BITFIELD(val, size);
542 return PyInt_FromLong(val);
543 }
544
545 static PyObject *
B_set(void * ptr,PyObject * value,Py_ssize_t size)546 B_set(void *ptr, PyObject *value, Py_ssize_t size)
547 {
548 unsigned long val;
549 if (get_ulong(value, &val) < 0)
550 return NULL;
551 *(unsigned char *)ptr = SET(unsigned char, *(unsigned char*)ptr, val, size);
552 _RET(value);
553 }
554
555
556 static PyObject *
B_get(void * ptr,Py_ssize_t size)557 B_get(void *ptr, Py_ssize_t size)
558 {
559 unsigned char val = *(unsigned char *)ptr;
560 GET_BITFIELD(val, size);
561 return PyInt_FromLong(val);
562 }
563
564 static PyObject *
h_set(void * ptr,PyObject * value,Py_ssize_t size)565 h_set(void *ptr, PyObject *value, Py_ssize_t size)
566 {
567 long val;
568 short x;
569 if (get_long(value, &val) < 0)
570 return NULL;
571 memcpy(&x, ptr, sizeof(x));
572 x = SET(short, x, val, size);
573 memcpy(ptr, &x, sizeof(x));
574 _RET(value);
575 }
576
577
578 static PyObject *
h_set_sw(void * ptr,PyObject * value,Py_ssize_t size)579 h_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
580 {
581 long val;
582 short field;
583 if (get_long(value, &val) < 0)
584 return NULL;
585 memcpy(&field, ptr, sizeof(field));
586 field = SWAP_2(field);
587 field = SET(short, field, val, size);
588 field = SWAP_2(field);
589 memcpy(ptr, &field, sizeof(field));
590 _RET(value);
591 }
592
593 static PyObject *
h_get(void * ptr,Py_ssize_t size)594 h_get(void *ptr, Py_ssize_t size)
595 {
596 short val;
597 memcpy(&val, ptr, sizeof(val));
598 GET_BITFIELD(val, size);
599 return PyInt_FromLong((long)val);
600 }
601
602 static PyObject *
h_get_sw(void * ptr,Py_ssize_t size)603 h_get_sw(void *ptr, Py_ssize_t size)
604 {
605 short val;
606 memcpy(&val, ptr, sizeof(val));
607 val = SWAP_2(val);
608 GET_BITFIELD(val, size);
609 return PyInt_FromLong(val);
610 }
611
612 static PyObject *
H_set(void * ptr,PyObject * value,Py_ssize_t size)613 H_set(void *ptr, PyObject *value, Py_ssize_t size)
614 {
615 unsigned long val;
616 unsigned short x;
617 if (get_ulong(value, &val) < 0)
618 return NULL;
619 memcpy(&x, ptr, sizeof(x));
620 x = SET(unsigned short, x, val, size);
621 memcpy(ptr, &x, sizeof(x));
622 _RET(value);
623 }
624
625 static PyObject *
H_set_sw(void * ptr,PyObject * value,Py_ssize_t size)626 H_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
627 {
628 unsigned long val;
629 unsigned short field;
630 if (get_ulong(value, &val) < 0)
631 return NULL;
632 memcpy(&field, ptr, sizeof(field));
633 field = SWAP_2(field);
634 field = SET(unsigned short, field, val, size);
635 field = SWAP_2(field);
636 memcpy(ptr, &field, sizeof(field));
637 _RET(value);
638 }
639
640
641 static PyObject *
H_get(void * ptr,Py_ssize_t size)642 H_get(void *ptr, Py_ssize_t size)
643 {
644 unsigned short val;
645 memcpy(&val, ptr, sizeof(val));
646 GET_BITFIELD(val, size);
647 return PyInt_FromLong(val);
648 }
649
650 static PyObject *
H_get_sw(void * ptr,Py_ssize_t size)651 H_get_sw(void *ptr, Py_ssize_t size)
652 {
653 unsigned short val;
654 memcpy(&val, ptr, sizeof(val));
655 val = SWAP_2(val);
656 GET_BITFIELD(val, size);
657 return PyInt_FromLong(val);
658 }
659
660 static PyObject *
i_set(void * ptr,PyObject * value,Py_ssize_t size)661 i_set(void *ptr, PyObject *value, Py_ssize_t size)
662 {
663 long val;
664 int x;
665 if (get_long(value, &val) < 0)
666 return NULL;
667 memcpy(&x, ptr, sizeof(x));
668 x = SET(int, x, val, size);
669 memcpy(ptr, &x, sizeof(x));
670 _RET(value);
671 }
672
673 static PyObject *
i_set_sw(void * ptr,PyObject * value,Py_ssize_t size)674 i_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
675 {
676 long val;
677 int field;
678 if (get_long(value, &val) < 0)
679 return NULL;
680 memcpy(&field, ptr, sizeof(field));
681 field = SWAP_INT(field);
682 field = SET(int, field, val, size);
683 field = SWAP_INT(field);
684 memcpy(ptr, &field, sizeof(field));
685 _RET(value);
686 }
687
688
689 static PyObject *
i_get(void * ptr,Py_ssize_t size)690 i_get(void *ptr, Py_ssize_t size)
691 {
692 int val;
693 memcpy(&val, ptr, sizeof(val));
694 GET_BITFIELD(val, size);
695 return PyInt_FromLong(val);
696 }
697
698 static PyObject *
i_get_sw(void * ptr,Py_ssize_t size)699 i_get_sw(void *ptr, Py_ssize_t size)
700 {
701 int val;
702 memcpy(&val, ptr, sizeof(val));
703 val = SWAP_INT(val);
704 GET_BITFIELD(val, size);
705 return PyInt_FromLong(val);
706 }
707
708 #ifdef MS_WIN32
709 /* short BOOL - VARIANT_BOOL */
710 static PyObject *
vBOOL_set(void * ptr,PyObject * value,Py_ssize_t size)711 vBOOL_set(void *ptr, PyObject *value, Py_ssize_t size)
712 {
713 switch (PyObject_IsTrue(value)) {
714 case -1:
715 return NULL;
716 case 0:
717 *(short int *)ptr = VARIANT_FALSE;
718 _RET(value);
719 default:
720 *(short int *)ptr = VARIANT_TRUE;
721 _RET(value);
722 }
723 }
724
725 static PyObject *
vBOOL_get(void * ptr,Py_ssize_t size)726 vBOOL_get(void *ptr, Py_ssize_t size)
727 {
728 return PyBool_FromLong((long)*(short int *)ptr);
729 }
730 #endif
731
732 #ifdef HAVE_C99_BOOL
733 #define BOOL_TYPE _Bool
734 #else
735 #define BOOL_TYPE char
736 #undef SIZEOF__BOOL
737 #define SIZEOF__BOOL 1
738 #endif
739
740 static PyObject *
bool_set(void * ptr,PyObject * value,Py_ssize_t size)741 bool_set(void *ptr, PyObject *value, Py_ssize_t size)
742 {
743 switch (PyObject_IsTrue(value)) {
744 case -1:
745 return NULL;
746 case 0:
747 *(BOOL_TYPE *)ptr = 0;
748 _RET(value);
749 default:
750 *(BOOL_TYPE *)ptr = 1;
751 _RET(value);
752 }
753 }
754
755 static PyObject *
bool_get(void * ptr,Py_ssize_t size)756 bool_get(void *ptr, Py_ssize_t size)
757 {
758 return PyBool_FromLong((long)*(BOOL_TYPE *)ptr);
759 }
760
761 static PyObject *
I_set(void * ptr,PyObject * value,Py_ssize_t size)762 I_set(void *ptr, PyObject *value, Py_ssize_t size)
763 {
764 unsigned long val;
765 unsigned int x;
766 if (get_ulong(value, &val) < 0)
767 return NULL;
768 memcpy(&x, ptr, sizeof(x));
769 x = SET(unsigned int, x, val, size);
770 memcpy(ptr, &x, sizeof(x));
771 _RET(value);
772 }
773
774 static PyObject *
I_set_sw(void * ptr,PyObject * value,Py_ssize_t size)775 I_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
776 {
777 unsigned long val;
778 unsigned int field;
779 if (get_ulong(value, &val) < 0)
780 return NULL;
781 memcpy(&field, ptr, sizeof(field));
782 field = SWAP_INT(field);
783 field = SET(unsigned int, field, (unsigned int)val, size);
784 field = SWAP_INT(field);
785 memcpy(ptr, &field, sizeof(field));
786 _RET(value);
787 }
788
789
790 static PyObject *
I_get(void * ptr,Py_ssize_t size)791 I_get(void *ptr, Py_ssize_t size)
792 {
793 unsigned int val;
794 memcpy(&val, ptr, sizeof(val));
795 GET_BITFIELD(val, size);
796 return PyLong_FromUnsignedLong(val);
797 }
798
799 static PyObject *
I_get_sw(void * ptr,Py_ssize_t size)800 I_get_sw(void *ptr, Py_ssize_t size)
801 {
802 unsigned int val;
803 memcpy(&val, ptr, sizeof(val));
804 val = SWAP_INT(val);
805 GET_BITFIELD(val, size);
806 return PyLong_FromUnsignedLong(val);
807 }
808
809 static PyObject *
l_set(void * ptr,PyObject * value,Py_ssize_t size)810 l_set(void *ptr, PyObject *value, Py_ssize_t size)
811 {
812 long val;
813 long x;
814 if (get_long(value, &val) < 0)
815 return NULL;
816 memcpy(&x, ptr, sizeof(x));
817 x = SET(long, x, val, size);
818 memcpy(ptr, &x, sizeof(x));
819 _RET(value);
820 }
821
822 static PyObject *
l_set_sw(void * ptr,PyObject * value,Py_ssize_t size)823 l_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
824 {
825 long val;
826 long field;
827 if (get_long(value, &val) < 0)
828 return NULL;
829 memcpy(&field, ptr, sizeof(field));
830 field = SWAP_LONG(field);
831 field = SET(long, field, val, size);
832 field = SWAP_LONG(field);
833 memcpy(ptr, &field, sizeof(field));
834 _RET(value);
835 }
836
837
838 static PyObject *
l_get(void * ptr,Py_ssize_t size)839 l_get(void *ptr, Py_ssize_t size)
840 {
841 long val;
842 memcpy(&val, ptr, sizeof(val));
843 GET_BITFIELD(val, size);
844 return PyInt_FromLong(val);
845 }
846
847 static PyObject *
l_get_sw(void * ptr,Py_ssize_t size)848 l_get_sw(void *ptr, Py_ssize_t size)
849 {
850 long val;
851 memcpy(&val, ptr, sizeof(val));
852 val = SWAP_LONG(val);
853 GET_BITFIELD(val, size);
854 return PyInt_FromLong(val);
855 }
856
857 static PyObject *
L_set(void * ptr,PyObject * value,Py_ssize_t size)858 L_set(void *ptr, PyObject *value, Py_ssize_t size)
859 {
860 unsigned long val;
861 unsigned long x;
862 if (get_ulong(value, &val) < 0)
863 return NULL;
864 memcpy(&x, ptr, sizeof(x));
865 x = SET(unsigned long, x, val, size);
866 memcpy(ptr, &x, sizeof(x));
867 _RET(value);
868 }
869
870 static PyObject *
L_set_sw(void * ptr,PyObject * value,Py_ssize_t size)871 L_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
872 {
873 unsigned long val;
874 unsigned long field;
875 if (get_ulong(value, &val) < 0)
876 return NULL;
877 memcpy(&field, ptr, sizeof(field));
878 field = SWAP_LONG(field);
879 field = SET(unsigned long, field, val, size);
880 field = SWAP_LONG(field);
881 memcpy(ptr, &field, sizeof(field));
882 _RET(value);
883 }
884
885
886 static PyObject *
L_get(void * ptr,Py_ssize_t size)887 L_get(void *ptr, Py_ssize_t size)
888 {
889 unsigned long val;
890 memcpy(&val, ptr, sizeof(val));
891 GET_BITFIELD(val, size);
892 return PyLong_FromUnsignedLong(val);
893 }
894
895 static PyObject *
L_get_sw(void * ptr,Py_ssize_t size)896 L_get_sw(void *ptr, Py_ssize_t size)
897 {
898 unsigned long val;
899 memcpy(&val, ptr, sizeof(val));
900 val = SWAP_LONG(val);
901 GET_BITFIELD(val, size);
902 return PyLong_FromUnsignedLong(val);
903 }
904
905 #ifdef HAVE_LONG_LONG
906 static PyObject *
q_set(void * ptr,PyObject * value,Py_ssize_t size)907 q_set(void *ptr, PyObject *value, Py_ssize_t size)
908 {
909 PY_LONG_LONG val;
910 PY_LONG_LONG x;
911 if (get_longlong(value, &val) < 0)
912 return NULL;
913 memcpy(&x, ptr, sizeof(x));
914 x = SET(PY_LONG_LONG, x, val, size);
915 memcpy(ptr, &x, sizeof(x));
916 _RET(value);
917 }
918
919 static PyObject *
q_set_sw(void * ptr,PyObject * value,Py_ssize_t size)920 q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
921 {
922 PY_LONG_LONG val;
923 PY_LONG_LONG field;
924 if (get_longlong(value, &val) < 0)
925 return NULL;
926 memcpy(&field, ptr, sizeof(field));
927 field = SWAP_8(field);
928 field = SET(PY_LONG_LONG, field, val, size);
929 field = SWAP_8(field);
930 memcpy(ptr, &field, sizeof(field));
931 _RET(value);
932 }
933
934 static PyObject *
q_get(void * ptr,Py_ssize_t size)935 q_get(void *ptr, Py_ssize_t size)
936 {
937 PY_LONG_LONG val;
938 memcpy(&val, ptr, sizeof(val));
939 GET_BITFIELD(val, size);
940 return PyLong_FromLongLong(val);
941 }
942
943 static PyObject *
q_get_sw(void * ptr,Py_ssize_t size)944 q_get_sw(void *ptr, Py_ssize_t size)
945 {
946 PY_LONG_LONG val;
947 memcpy(&val, ptr, sizeof(val));
948 val = SWAP_8(val);
949 GET_BITFIELD(val, size);
950 return PyLong_FromLongLong(val);
951 }
952
953 static PyObject *
Q_set(void * ptr,PyObject * value,Py_ssize_t size)954 Q_set(void *ptr, PyObject *value, Py_ssize_t size)
955 {
956 unsigned PY_LONG_LONG val;
957 unsigned PY_LONG_LONG x;
958 if (get_ulonglong(value, &val) < 0)
959 return NULL;
960 memcpy(&x, ptr, sizeof(x));
961 x = SET(PY_LONG_LONG, x, val, size);
962 memcpy(ptr, &x, sizeof(x));
963 _RET(value);
964 }
965
966 static PyObject *
Q_set_sw(void * ptr,PyObject * value,Py_ssize_t size)967 Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
968 {
969 unsigned PY_LONG_LONG val;
970 unsigned PY_LONG_LONG field;
971 if (get_ulonglong(value, &val) < 0)
972 return NULL;
973 memcpy(&field, ptr, sizeof(field));
974 field = SWAP_8(field);
975 field = SET(unsigned PY_LONG_LONG, field, val, size);
976 field = SWAP_8(field);
977 memcpy(ptr, &field, sizeof(field));
978 _RET(value);
979 }
980
981 static PyObject *
Q_get(void * ptr,Py_ssize_t size)982 Q_get(void *ptr, Py_ssize_t size)
983 {
984 unsigned PY_LONG_LONG val;
985 memcpy(&val, ptr, sizeof(val));
986 GET_BITFIELD(val, size);
987 return PyLong_FromUnsignedLongLong(val);
988 }
989
990 static PyObject *
Q_get_sw(void * ptr,Py_ssize_t size)991 Q_get_sw(void *ptr, Py_ssize_t size)
992 {
993 unsigned PY_LONG_LONG val;
994 memcpy(&val, ptr, sizeof(val));
995 val = SWAP_8(val);
996 GET_BITFIELD(val, size);
997 return PyLong_FromUnsignedLongLong(val);
998 }
999 #endif
1000
1001 /*****************************************************************
1002 * non-integer accessor methods, not supporting bit fields
1003 */
1004
1005
1006 static PyObject *
g_set(void * ptr,PyObject * value,Py_ssize_t size)1007 g_set(void *ptr, PyObject *value, Py_ssize_t size)
1008 {
1009 long double x;
1010
1011 x = PyFloat_AsDouble(value);
1012 if (x == -1 && PyErr_Occurred())
1013 return NULL;
1014 memcpy(ptr, &x, sizeof(long double));
1015 _RET(value);
1016 }
1017
1018 static PyObject *
g_get(void * ptr,Py_ssize_t size)1019 g_get(void *ptr, Py_ssize_t size)
1020 {
1021 long double val;
1022 memcpy(&val, ptr, sizeof(long double));
1023 return PyFloat_FromDouble(val);
1024 }
1025
1026 static PyObject *
d_set(void * ptr,PyObject * value,Py_ssize_t size)1027 d_set(void *ptr, PyObject *value, Py_ssize_t size)
1028 {
1029 double x;
1030
1031 x = PyFloat_AsDouble(value);
1032 if (x == -1 && PyErr_Occurred())
1033 return NULL;
1034 memcpy(ptr, &x, sizeof(double));
1035 _RET(value);
1036 }
1037
1038 static PyObject *
d_get(void * ptr,Py_ssize_t size)1039 d_get(void *ptr, Py_ssize_t size)
1040 {
1041 double val;
1042 memcpy(&val, ptr, sizeof(val));
1043 return PyFloat_FromDouble(val);
1044 }
1045
1046 static PyObject *
d_set_sw(void * ptr,PyObject * value,Py_ssize_t size)1047 d_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
1048 {
1049 double x;
1050
1051 x = PyFloat_AsDouble(value);
1052 if (x == -1 && PyErr_Occurred())
1053 return NULL;
1054 #ifdef WORDS_BIGENDIAN
1055 if (_PyFloat_Pack8(x, (unsigned char *)ptr, 1))
1056 return NULL;
1057 #else
1058 if (_PyFloat_Pack8(x, (unsigned char *)ptr, 0))
1059 return NULL;
1060 #endif
1061 _RET(value);
1062 }
1063
1064 static PyObject *
d_get_sw(void * ptr,Py_ssize_t size)1065 d_get_sw(void *ptr, Py_ssize_t size)
1066 {
1067 #ifdef WORDS_BIGENDIAN
1068 return PyFloat_FromDouble(_PyFloat_Unpack8(ptr, 1));
1069 #else
1070 return PyFloat_FromDouble(_PyFloat_Unpack8(ptr, 0));
1071 #endif
1072 }
1073
1074 static PyObject *
f_set(void * ptr,PyObject * value,Py_ssize_t size)1075 f_set(void *ptr, PyObject *value, Py_ssize_t size)
1076 {
1077 float x;
1078
1079 x = (float)PyFloat_AsDouble(value);
1080 if (x == -1 && PyErr_Occurred())
1081 return NULL;
1082 memcpy(ptr, &x, sizeof(x));
1083 _RET(value);
1084 }
1085
1086 static PyObject *
f_get(void * ptr,Py_ssize_t size)1087 f_get(void *ptr, Py_ssize_t size)
1088 {
1089 float val;
1090 memcpy(&val, ptr, sizeof(val));
1091 return PyFloat_FromDouble(val);
1092 }
1093
1094 static PyObject *
f_set_sw(void * ptr,PyObject * value,Py_ssize_t size)1095 f_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
1096 {
1097 float x;
1098
1099 x = (float)PyFloat_AsDouble(value);
1100 if (x == -1 && PyErr_Occurred())
1101 return NULL;
1102 #ifdef WORDS_BIGENDIAN
1103 if (_PyFloat_Pack4(x, (unsigned char *)ptr, 1))
1104 return NULL;
1105 #else
1106 if (_PyFloat_Pack4(x, (unsigned char *)ptr, 0))
1107 return NULL;
1108 #endif
1109 _RET(value);
1110 }
1111
1112 static PyObject *
f_get_sw(void * ptr,Py_ssize_t size)1113 f_get_sw(void *ptr, Py_ssize_t size)
1114 {
1115 #ifdef WORDS_BIGENDIAN
1116 return PyFloat_FromDouble(_PyFloat_Unpack4(ptr, 1));
1117 #else
1118 return PyFloat_FromDouble(_PyFloat_Unpack4(ptr, 0));
1119 #endif
1120 }
1121
1122 /*
1123 py_object refcounts:
1124
1125 1. If we have a py_object instance, O_get must Py_INCREF the returned
1126 object, of course. If O_get is called from a function result, no py_object
1127 instance is created - so callproc.c::GetResult has to call Py_DECREF.
1128
1129 2. The memory block in py_object owns a refcount. So, py_object must call
1130 Py_DECREF on destruction. Maybe only when b_needsfree is non-zero.
1131 */
1132 static PyObject *
O_get(void * ptr,Py_ssize_t size)1133 O_get(void *ptr, Py_ssize_t size)
1134 {
1135 PyObject *ob = *(PyObject **)ptr;
1136 if (ob == NULL) {
1137 if (!PyErr_Occurred())
1138 /* Set an error if not yet set */
1139 PyErr_SetString(PyExc_ValueError,
1140 "PyObject is NULL");
1141 return NULL;
1142 }
1143 Py_INCREF(ob);
1144 return ob;
1145 }
1146
1147 static PyObject *
O_set(void * ptr,PyObject * value,Py_ssize_t size)1148 O_set(void *ptr, PyObject *value, Py_ssize_t size)
1149 {
1150 /* Hm, does the memory block need it's own refcount or not? */
1151 *(PyObject **)ptr = value;
1152 Py_INCREF(value);
1153 return value;
1154 }
1155
1156
1157 static PyObject *
c_set(void * ptr,PyObject * value,Py_ssize_t size)1158 c_set(void *ptr, PyObject *value, Py_ssize_t size)
1159 {
1160 if (!PyString_Check(value) || (1 != PyString_Size(value))) {
1161 PyErr_Format(PyExc_TypeError,
1162 "one character string expected");
1163 return NULL;
1164 }
1165 *(char *)ptr = PyString_AS_STRING(value)[0];
1166 _RET(value);
1167 }
1168
1169
1170 static PyObject *
c_get(void * ptr,Py_ssize_t size)1171 c_get(void *ptr, Py_ssize_t size)
1172 {
1173 return PyString_FromStringAndSize((char *)ptr, 1);
1174 }
1175
1176 #ifdef CTYPES_UNICODE
1177 /* u - a single wchar_t character */
1178 static PyObject *
u_set(void * ptr,PyObject * value,Py_ssize_t size)1179 u_set(void *ptr, PyObject *value, Py_ssize_t size)
1180 {
1181 Py_ssize_t len;
1182
1183 if (PyString_Check(value)) {
1184 value = PyUnicode_FromEncodedObject(value,
1185 _ctypes_conversion_encoding,
1186 _ctypes_conversion_errors);
1187 if (!value)
1188 return NULL;
1189 } else if (!PyUnicode_Check(value)) {
1190 PyErr_Format(PyExc_TypeError,
1191 "unicode string expected instead of %s instance",
1192 value->ob_type->tp_name);
1193 return NULL;
1194 } else
1195 Py_INCREF(value);
1196
1197 len = PyUnicode_GET_SIZE(value);
1198 if (len != 1) {
1199 Py_DECREF(value);
1200 PyErr_SetString(PyExc_TypeError,
1201 "one character unicode string expected");
1202 return NULL;
1203 }
1204
1205 *(wchar_t *)ptr = PyUnicode_AS_UNICODE(value)[0];
1206 Py_DECREF(value);
1207
1208 _RET(value);
1209 }
1210
1211
1212 static PyObject *
u_get(void * ptr,Py_ssize_t size)1213 u_get(void *ptr, Py_ssize_t size)
1214 {
1215 return PyUnicode_FromWideChar((wchar_t *)ptr, 1);
1216 }
1217
1218 /* U - a unicode string */
1219 static PyObject *
U_get(void * ptr,Py_ssize_t size)1220 U_get(void *ptr, Py_ssize_t size)
1221 {
1222 PyObject *result;
1223 Py_ssize_t len;
1224 Py_UNICODE *p;
1225
1226 size /= sizeof(wchar_t); /* we count character units here, not bytes */
1227
1228 result = PyUnicode_FromWideChar((wchar_t *)ptr, size);
1229 if (!result)
1230 return NULL;
1231 /* We need 'result' to be able to count the characters with wcslen,
1232 since ptr may not be NUL terminated. If the length is smaller (if
1233 it was actually NUL terminated, we construct a new one and throw
1234 away the result.
1235 */
1236 /* chop off at the first NUL character, if any. */
1237 p = PyUnicode_AS_UNICODE(result);
1238 for (len = 0; len < size; ++len)
1239 if (!p[len])
1240 break;
1241
1242 if (len < size) {
1243 PyObject *ob = PyUnicode_FromWideChar((wchar_t *)ptr, len);
1244 Py_DECREF(result);
1245 return ob;
1246 }
1247 return result;
1248 }
1249
1250 static PyObject *
U_set(void * ptr,PyObject * value,Py_ssize_t length)1251 U_set(void *ptr, PyObject *value, Py_ssize_t length)
1252 {
1253 Py_ssize_t size;
1254
1255 /* It's easier to calculate in characters than in bytes */
1256 length /= sizeof(wchar_t);
1257
1258 if (PyString_Check(value)) {
1259 value = PyUnicode_FromEncodedObject(value,
1260 _ctypes_conversion_encoding,
1261 _ctypes_conversion_errors);
1262 if (!value)
1263 return NULL;
1264 } else if (!PyUnicode_Check(value)) {
1265 PyErr_Format(PyExc_TypeError,
1266 "unicode string expected instead of %s instance",
1267 value->ob_type->tp_name);
1268 return NULL;
1269 } else
1270 Py_INCREF(value);
1271 size = PyUnicode_GET_SIZE(value);
1272 if (size > length) {
1273 PyErr_Format(PyExc_ValueError,
1274 #if (PY_VERSION_HEX < 0x02050000)
1275 "string too long (%d, maximum length %d)",
1276 #else
1277 "string too long (%zd, maximum length %zd)",
1278 #endif
1279 size, length);
1280 Py_DECREF(value);
1281 return NULL;
1282 } else if (size < length-1)
1283 /* copy terminating NUL character if there is space */
1284 size += 1;
1285 PyUnicode_AsWideChar((PyUnicodeObject *)value, (wchar_t *)ptr, size);
1286 return value;
1287 }
1288
1289 #endif
1290
1291 static PyObject *
s_get(void * ptr,Py_ssize_t size)1292 s_get(void *ptr, Py_ssize_t size)
1293 {
1294 Py_ssize_t i;
1295 char *p;
1296
1297 p = (char *)ptr;
1298 for (i = 0; i < size; ++i) {
1299 if (*p++ == '\0')
1300 break;
1301 }
1302
1303 return PyBytes_FromStringAndSize((char *)ptr, (Py_ssize_t)i);
1304 }
1305
1306 static PyObject *
s_set(void * ptr,PyObject * value,Py_ssize_t length)1307 s_set(void *ptr, PyObject *value, Py_ssize_t length)
1308 {
1309 char *data;
1310 Py_ssize_t size;
1311
1312 data = PyString_AsString(value);
1313 if (!data)
1314 return NULL;
1315 size = strlen(data);
1316 if (size < length) {
1317 /* This will copy the trailing NUL character
1318 * if there is space for it.
1319 */
1320 ++size;
1321 } else if (size > length) {
1322 PyErr_Format(PyExc_ValueError,
1323 #if (PY_VERSION_HEX < 0x02050000)
1324 "string too long (%d, maximum length %d)",
1325 #else
1326 "string too long (%zd, maximum length %zd)",
1327 #endif
1328 size, length);
1329 return NULL;
1330 }
1331 /* Also copy the terminating NUL character if there is space */
1332 memcpy((char *)ptr, data, size);
1333 _RET(value);
1334 }
1335
1336 static PyObject *
z_set(void * ptr,PyObject * value,Py_ssize_t size)1337 z_set(void *ptr, PyObject *value, Py_ssize_t size)
1338 {
1339 if (value == Py_None) {
1340 *(char **)ptr = NULL;
1341 Py_INCREF(value);
1342 return value;
1343 }
1344 if (PyString_Check(value)) {
1345 *(char **)ptr = PyString_AS_STRING(value);
1346 Py_INCREF(value);
1347 return value;
1348 } else if (PyUnicode_Check(value)) {
1349 PyObject *str = PyUnicode_AsEncodedString(value,
1350 _ctypes_conversion_encoding,
1351 _ctypes_conversion_errors);
1352 if (str == NULL)
1353 return NULL;
1354 *(char **)ptr = PyString_AS_STRING(str);
1355 return str;
1356 } else if (_PyAnyInt_Check(value)) {
1357 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
1358 *(char **)ptr = (char *)PyInt_AsUnsignedLongLongMask(value);
1359 #else
1360 *(char **)ptr = (char *)PyInt_AsUnsignedLongMask(value);
1361 #endif
1362 _RET(value);
1363 }
1364 PyErr_Format(PyExc_TypeError,
1365 "string or integer address expected instead of %s instance",
1366 value->ob_type->tp_name);
1367 return NULL;
1368 }
1369
1370 static PyObject *
z_get(void * ptr,Py_ssize_t size)1371 z_get(void *ptr, Py_ssize_t size)
1372 {
1373 /* XXX What about invalid pointers ??? */
1374 if (*(void **)ptr) {
1375 #if defined(MS_WIN32) && !defined(_WIN32_WCE)
1376 if (IsBadStringPtrA(*(char **)ptr, -1)) {
1377 PyErr_Format(PyExc_ValueError,
1378 "invalid string pointer %p",
1379 *(char **)ptr);
1380 return NULL;
1381 }
1382 #endif
1383 return PyString_FromString(*(char **)ptr);
1384 } else {
1385 Py_INCREF(Py_None);
1386 return Py_None;
1387 }
1388 }
1389
1390 #ifdef CTYPES_UNICODE
1391 static PyObject *
Z_set(void * ptr,PyObject * value,Py_ssize_t size)1392 Z_set(void *ptr, PyObject *value, Py_ssize_t size)
1393 {
1394 if (value == Py_None) {
1395 *(wchar_t **)ptr = NULL;
1396 Py_INCREF(value);
1397 return value;
1398 }
1399 if (PyString_Check(value)) {
1400 value = PyUnicode_FromEncodedObject(value,
1401 _ctypes_conversion_encoding,
1402 _ctypes_conversion_errors);
1403 if (!value)
1404 return NULL;
1405 } else if (_PyAnyInt_Check(value)) {
1406 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
1407 *(wchar_t **)ptr = (wchar_t *)PyInt_AsUnsignedLongLongMask(value);
1408 #else
1409 *(wchar_t **)ptr = (wchar_t *)PyInt_AsUnsignedLongMask(value);
1410 #endif
1411 Py_INCREF(Py_None);
1412 return Py_None;
1413 } else if (!PyUnicode_Check(value)) {
1414 PyErr_Format(PyExc_TypeError,
1415 "unicode string or integer address expected instead of %s instance",
1416 value->ob_type->tp_name);
1417 return NULL;
1418 } else
1419 Py_INCREF(value);
1420 #ifdef HAVE_USABLE_WCHAR_T
1421 /* HAVE_USABLE_WCHAR_T means that Py_UNICODE and wchar_t is the same
1422 type. So we can copy directly. Hm, are unicode objects always NUL
1423 terminated in Python, internally?
1424 */
1425 *(wchar_t **)ptr = PyUnicode_AS_UNICODE(value);
1426 return value;
1427 #else
1428 {
1429 /* We must create a wchar_t* buffer from the unicode object,
1430 and keep it alive */
1431 PyObject *keep;
1432 wchar_t *buffer;
1433
1434 int size = PyUnicode_GET_SIZE(value);
1435 size += 1; /* terminating NUL */
1436 size *= sizeof(wchar_t);
1437 buffer = (wchar_t *)PyMem_Malloc(size);
1438 if (!buffer) {
1439 Py_DECREF(value);
1440 return PyErr_NoMemory();
1441 }
1442 memset(buffer, 0, size);
1443 keep = CAPSULE_NEW(buffer, CTYPES_CAPSULE_WCHAR_T);
1444 if (!keep) {
1445 Py_DECREF(value);
1446 PyMem_Free(buffer);
1447 return NULL;
1448 }
1449 *(wchar_t **)ptr = (wchar_t *)buffer;
1450 if (-1 == PyUnicode_AsWideChar((PyUnicodeObject *)value,
1451 buffer, PyUnicode_GET_SIZE(value))) {
1452 Py_DECREF(value);
1453 Py_DECREF(keep);
1454 return NULL;
1455 }
1456 Py_DECREF(value);
1457 return keep;
1458 }
1459 #endif
1460 }
1461
1462 static PyObject *
Z_get(void * ptr,Py_ssize_t size)1463 Z_get(void *ptr, Py_ssize_t size)
1464 {
1465 wchar_t *p;
1466 p = *(wchar_t **)ptr;
1467 if (p) {
1468 #if defined(MS_WIN32) && !defined(_WIN32_WCE)
1469 if (IsBadStringPtrW(*(wchar_t **)ptr, -1)) {
1470 PyErr_Format(PyExc_ValueError,
1471 "invalid string pointer %p",
1472 *(wchar_t **)ptr);
1473 return NULL;
1474 }
1475 #endif
1476 return PyUnicode_FromWideChar(p, wcslen(p));
1477 } else {
1478 Py_INCREF(Py_None);
1479 return Py_None;
1480 }
1481 }
1482 #endif
1483
1484 #ifdef MS_WIN32
1485 static PyObject *
BSTR_set(void * ptr,PyObject * value,Py_ssize_t size)1486 BSTR_set(void *ptr, PyObject *value, Py_ssize_t size)
1487 {
1488 BSTR bstr;
1489
1490 /* convert value into a PyUnicodeObject or NULL */
1491 if (Py_None == value) {
1492 value = NULL;
1493 } else if (PyString_Check(value)) {
1494 value = PyUnicode_FromEncodedObject(value,
1495 _ctypes_conversion_encoding,
1496 _ctypes_conversion_errors);
1497 if (!value)
1498 return NULL;
1499 } else if (PyUnicode_Check(value)) {
1500 Py_INCREF(value); /* for the descref below */
1501 } else {
1502 PyErr_Format(PyExc_TypeError,
1503 "unicode string expected instead of %s instance",
1504 value->ob_type->tp_name);
1505 return NULL;
1506 }
1507
1508 /* create a BSTR from value */
1509 if (value) {
1510 Py_ssize_t size = PyUnicode_GET_SIZE(value);
1511 if ((unsigned) size != size) {
1512 Py_DECREF(value);
1513 PyErr_SetString(PyExc_ValueError, "String too long for BSTR");
1514 return NULL;
1515 }
1516 bstr = SysAllocStringLen(PyUnicode_AS_UNICODE(value),
1517 (unsigned)size);
1518 Py_DECREF(value);
1519 } else
1520 bstr = NULL;
1521
1522 /* free the previous contents, if any */
1523 if (*(BSTR *)ptr)
1524 SysFreeString(*(BSTR *)ptr);
1525
1526 /* and store it */
1527 *(BSTR *)ptr = bstr;
1528
1529 /* We don't need to keep any other object */
1530 _RET(value);
1531 }
1532
1533
1534 static PyObject *
BSTR_get(void * ptr,Py_ssize_t size)1535 BSTR_get(void *ptr, Py_ssize_t size)
1536 {
1537 BSTR p;
1538 p = *(BSTR *)ptr;
1539 if (p)
1540 return PyUnicode_FromWideChar(p, SysStringLen(p));
1541 else {
1542 /* Hm, it seems NULL pointer and zero length string are the
1543 same in BSTR, see Don Box, p 81
1544 */
1545 Py_INCREF(Py_None);
1546 return Py_None;
1547 }
1548 }
1549 #endif
1550
1551 static PyObject *
P_set(void * ptr,PyObject * value,Py_ssize_t size)1552 P_set(void *ptr, PyObject *value, Py_ssize_t size)
1553 {
1554 void *v;
1555 if (value == Py_None) {
1556 *(void **)ptr = NULL;
1557 _RET(value);
1558 }
1559
1560 if (!_PyAnyInt_Check(value)) {
1561 PyErr_SetString(PyExc_TypeError,
1562 "cannot be converted to pointer");
1563 return NULL;
1564 }
1565
1566 #if SIZEOF_VOID_P <= SIZEOF_LONG
1567 v = (void *)PyInt_AsUnsignedLongMask(value);
1568 #else
1569 #ifndef HAVE_LONG_LONG
1570 # error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
1571 #elif SIZEOF_LONG_LONG < SIZEOF_VOID_P
1572 # error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
1573 #endif
1574 v = (void *)PyInt_AsUnsignedLongLongMask(value);
1575 #endif
1576
1577 if (PyErr_Occurred())
1578 return NULL;
1579
1580 *(void **)ptr = v;
1581 _RET(value);
1582 }
1583
1584 static PyObject *
P_get(void * ptr,Py_ssize_t size)1585 P_get(void *ptr, Py_ssize_t size)
1586 {
1587 if (*(void **)ptr == NULL) {
1588 Py_INCREF(Py_None);
1589 return Py_None;
1590 }
1591 return PyLong_FromVoidPtr(*(void **)ptr);
1592 }
1593
1594 static struct fielddesc formattable[] = {
1595 { 's', s_set, s_get, &ffi_type_pointer},
1596 { 'b', b_set, b_get, &ffi_type_schar},
1597 { 'B', B_set, B_get, &ffi_type_uchar},
1598 { 'c', c_set, c_get, &ffi_type_schar},
1599 { 'd', d_set, d_get, &ffi_type_double, d_set_sw, d_get_sw},
1600 { 'g', g_set, g_get, &ffi_type_longdouble},
1601 { 'f', f_set, f_get, &ffi_type_float, f_set_sw, f_get_sw},
1602 { 'h', h_set, h_get, &ffi_type_sshort, h_set_sw, h_get_sw},
1603 { 'H', H_set, H_get, &ffi_type_ushort, H_set_sw, H_get_sw},
1604 { 'i', i_set, i_get, &ffi_type_sint, i_set_sw, i_get_sw},
1605 { 'I', I_set, I_get, &ffi_type_uint, I_set_sw, I_get_sw},
1606 /* XXX Hm, sizeof(int) == sizeof(long) doesn't hold on every platform */
1607 /* As soon as we can get rid of the type codes, this is no longer a problem */
1608 #if SIZEOF_LONG == 4
1609 { 'l', l_set, l_get, &ffi_type_sint32, l_set_sw, l_get_sw},
1610 { 'L', L_set, L_get, &ffi_type_uint32, L_set_sw, L_get_sw},
1611 #elif SIZEOF_LONG == 8
1612 { 'l', l_set, l_get, &ffi_type_sint64, l_set_sw, l_get_sw},
1613 { 'L', L_set, L_get, &ffi_type_uint64, L_set_sw, L_get_sw},
1614 #else
1615 # error
1616 #endif
1617 #ifdef HAVE_LONG_LONG
1618 #if SIZEOF_LONG_LONG == 8
1619 { 'q', q_set, q_get, &ffi_type_sint64, q_set_sw, q_get_sw},
1620 { 'Q', Q_set, Q_get, &ffi_type_uint64, Q_set_sw, Q_get_sw},
1621 #else
1622 # error
1623 #endif
1624 #endif
1625 { 'P', P_set, P_get, &ffi_type_pointer},
1626 { 'z', z_set, z_get, &ffi_type_pointer},
1627 #ifdef CTYPES_UNICODE
1628 { 'u', u_set, u_get, NULL}, /* ffi_type set later */
1629 { 'U', U_set, U_get, &ffi_type_pointer},
1630 { 'Z', Z_set, Z_get, &ffi_type_pointer},
1631 #endif
1632 #ifdef MS_WIN32
1633 { 'X', BSTR_set, BSTR_get, &ffi_type_pointer},
1634 { 'v', vBOOL_set, vBOOL_get, &ffi_type_sshort},
1635 #endif
1636 #if SIZEOF__BOOL == 1
1637 { '?', bool_set, bool_get, &ffi_type_uchar}, /* Also fallback for no native _Bool support */
1638 #elif SIZEOF__BOOL == SIZEOF_SHORT
1639 { '?', bool_set, bool_get, &ffi_type_ushort},
1640 #elif SIZEOF__BOOL == SIZEOF_INT
1641 { '?', bool_set, bool_get, &ffi_type_uint, I_set_sw, I_get_sw},
1642 #elif SIZEOF__BOOL == SIZEOF_LONG
1643 { '?', bool_set, bool_get, &ffi_type_ulong, L_set_sw, L_get_sw},
1644 #elif SIZEOF__BOOL == SIZEOF_LONG_LONG
1645 { '?', bool_set, bool_get, &ffi_type_ulong, Q_set_sw, Q_get_sw},
1646 #endif /* SIZEOF__BOOL */
1647 { 'O', O_set, O_get, &ffi_type_pointer},
1648 { 0, NULL, NULL, NULL},
1649 };
1650
1651 /*
1652 Ideas: Implement VARIANT in this table, using 'V' code.
1653 Use '?' as code for BOOL.
1654 */
1655
1656 struct fielddesc *
_ctypes_get_fielddesc(char * fmt)1657 _ctypes_get_fielddesc(char *fmt)
1658 {
1659 static int initialized = 0;
1660 struct fielddesc *table = formattable;
1661
1662 if (!initialized) {
1663 initialized = 1;
1664 #ifdef CTYPES_UNICODE
1665 if (sizeof(wchar_t) == sizeof(short))
1666 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sshort;
1667 else if (sizeof(wchar_t) == sizeof(int))
1668 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sint;
1669 else if (sizeof(wchar_t) == sizeof(long))
1670 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_slong;
1671 #endif
1672 }
1673
1674 for (; table->code; ++table) {
1675 if (table->code == fmt[0])
1676 return table;
1677 }
1678 return NULL;
1679 }
1680
1681 typedef struct { char c; char x; } s_char;
1682 typedef struct { char c; short x; } s_short;
1683 typedef struct { char c; int x; } s_int;
1684 typedef struct { char c; long x; } s_long;
1685 typedef struct { char c; float x; } s_float;
1686 typedef struct { char c; double x; } s_double;
1687 typedef struct { char c; long double x; } s_long_double;
1688 typedef struct { char c; char *x; } s_char_p;
1689 typedef struct { char c; void *x; } s_void_p;
1690
1691 /*
1692 #define CHAR_ALIGN (sizeof(s_char) - sizeof(char))
1693 #define SHORT_ALIGN (sizeof(s_short) - sizeof(short))
1694 #define LONG_ALIGN (sizeof(s_long) - sizeof(long))
1695 */
1696 #define INT_ALIGN (sizeof(s_int) - sizeof(int))
1697 #define FLOAT_ALIGN (sizeof(s_float) - sizeof(float))
1698 #define DOUBLE_ALIGN (sizeof(s_double) - sizeof(double))
1699 #define LONGDOUBLE_ALIGN (sizeof(s_long_double) - sizeof(long double))
1700
1701 /* #define CHAR_P_ALIGN (sizeof(s_char_p) - sizeof(char*)) */
1702 #define VOID_P_ALIGN (sizeof(s_void_p) - sizeof(void*))
1703
1704 /*
1705 #ifdef HAVE_USABLE_WCHAR_T
1706 typedef struct { char c; wchar_t x; } s_wchar;
1707 typedef struct { char c; wchar_t *x; } s_wchar_p;
1708
1709 #define WCHAR_ALIGN (sizeof(s_wchar) - sizeof(wchar_t))
1710 #define WCHAR_P_ALIGN (sizeof(s_wchar_p) - sizeof(wchar_t*))
1711 #endif
1712 */
1713
1714 #ifdef HAVE_LONG_LONG
1715 typedef struct { char c; PY_LONG_LONG x; } s_long_long;
1716 #define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(PY_LONG_LONG))
1717 #endif
1718
1719 /* from ffi.h:
1720 typedef struct _ffi_type
1721 {
1722 size_t size;
1723 unsigned short alignment;
1724 unsigned short type;
1725 struct _ffi_type **elements;
1726 } ffi_type;
1727 */
1728
1729 /* align and size are bogus for void, but they must not be zero */
1730 ffi_type ffi_type_void = { 1, 1, FFI_TYPE_VOID };
1731
1732 ffi_type ffi_type_uint8 = { 1, 1, FFI_TYPE_UINT8 };
1733 ffi_type ffi_type_sint8 = { 1, 1, FFI_TYPE_SINT8 };
1734
1735 ffi_type ffi_type_uint16 = { 2, 2, FFI_TYPE_UINT16 };
1736 ffi_type ffi_type_sint16 = { 2, 2, FFI_TYPE_SINT16 };
1737
1738 ffi_type ffi_type_uint32 = { 4, INT_ALIGN, FFI_TYPE_UINT32 };
1739 ffi_type ffi_type_sint32 = { 4, INT_ALIGN, FFI_TYPE_SINT32 };
1740
1741 ffi_type ffi_type_uint64 = { 8, LONG_LONG_ALIGN, FFI_TYPE_UINT64 };
1742 ffi_type ffi_type_sint64 = { 8, LONG_LONG_ALIGN, FFI_TYPE_SINT64 };
1743
1744 ffi_type ffi_type_float = { sizeof(float), FLOAT_ALIGN, FFI_TYPE_FLOAT };
1745 ffi_type ffi_type_double = { sizeof(double), DOUBLE_ALIGN, FFI_TYPE_DOUBLE };
1746
1747 #ifdef ffi_type_longdouble
1748 #undef ffi_type_longdouble
1749 #endif
1750 /* This is already defined on OSX */
1751 ffi_type ffi_type_longdouble = { sizeof(long double), LONGDOUBLE_ALIGN,
1752 FFI_TYPE_LONGDOUBLE };
1753
1754 ffi_type ffi_type_pointer = { sizeof(void *), VOID_P_ALIGN, FFI_TYPE_POINTER };
1755
1756 /*---------------- EOF ----------------*/
1757