1 #include "Python.h"
2
3 #include <ffi.h>
4 #ifdef MS_WIN32
5 #include <windows.h>
6 #endif
7 #include "ctypes.h"
8
9
10 #define CTYPES_CFIELD_CAPSULE_NAME_PYMEM "_ctypes/cfield.c pymem"
11
pymem_destructor(PyObject * ptr)12 static void pymem_destructor(PyObject *ptr)
13 {
14 void *p = PyCapsule_GetPointer(ptr, CTYPES_CFIELD_CAPSULE_NAME_PYMEM);
15 if (p) {
16 PyMem_Free(p);
17 }
18 }
19
20
21 /******************************************************************/
22 /*
23 PyCField_Type
24 */
25 static PyObject *
PyCField_new(PyTypeObject * type,PyObject * args,PyObject * kwds)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 PyLong_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 PyLong_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 = PyUnicode_FromFormat(
293 "<Field type=%s, ofs=%zd:%zd, bits=%zd>",
294 name, self->offset, size, bits);
295 else
296 result = PyUnicode_FromFormat(
297 "<Field type=%s, ofs=%zd, size=%zd>",
298 name, self->offset, size);
299 return result;
300 }
301
302 PyTypeObject PyCField_Type = {
303 PyVarObject_HEAD_INIT(NULL, 0)
304 "_ctypes.CField", /* tp_name */
305 sizeof(CFieldObject), /* tp_basicsize */
306 0, /* tp_itemsize */
307 PyCField_dealloc, /* tp_dealloc */
308 0, /* tp_vectorcall_offset */
309 0, /* tp_getattr */
310 0, /* tp_setattr */
311 0, /* tp_as_async */
312 (reprfunc)PyCField_repr, /* tp_repr */
313 0, /* tp_as_number */
314 0, /* tp_as_sequence */
315 0, /* tp_as_mapping */
316 0, /* tp_hash */
317 0, /* tp_call */
318 0, /* tp_str */
319 0, /* tp_getattro */
320 0, /* tp_setattro */
321 0, /* tp_as_buffer */
322 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
323 "Structure/Union member", /* tp_doc */
324 (traverseproc)PyCField_traverse, /* tp_traverse */
325 (inquiry)PyCField_clear, /* tp_clear */
326 0, /* tp_richcompare */
327 0, /* tp_weaklistoffset */
328 0, /* tp_iter */
329 0, /* tp_iternext */
330 0, /* tp_methods */
331 0, /* tp_members */
332 PyCField_getset, /* tp_getset */
333 0, /* tp_base */
334 0, /* tp_dict */
335 (descrgetfunc)PyCField_get, /* tp_descr_get */
336 (descrsetfunc)PyCField_set, /* tp_descr_set */
337 0, /* tp_dictoffset */
338 0, /* tp_init */
339 0, /* tp_alloc */
340 PyCField_new, /* tp_new */
341 0, /* tp_free */
342 };
343
344
345 /******************************************************************/
346 /*
347 Accessor functions
348 */
349
350 /* Derived from Modules/structmodule.c:
351 Helper routine to get a Python integer and raise the appropriate error
352 if it isn't one */
353
354 static int
get_long(PyObject * v,long * p)355 get_long(PyObject *v, long *p)
356 {
357 long x;
358
359 if (PyFloat_Check(v)) {
360 PyErr_SetString(PyExc_TypeError,
361 "int expected instead of float");
362 return -1;
363 }
364 x = PyLong_AsUnsignedLongMask(v);
365 if (x == -1 && PyErr_Occurred())
366 return -1;
367 *p = x;
368 return 0;
369 }
370
371 /* Same, but handling unsigned long */
372
373 static int
get_ulong(PyObject * v,unsigned long * p)374 get_ulong(PyObject *v, unsigned long *p)
375 {
376 unsigned long x;
377
378 if (PyFloat_Check(v)) {
379 PyErr_SetString(PyExc_TypeError,
380 "int expected instead of float");
381 return -1;
382 }
383 x = PyLong_AsUnsignedLongMask(v);
384 if (x == (unsigned long)-1 && PyErr_Occurred())
385 return -1;
386 *p = x;
387 return 0;
388 }
389
390 /* Same, but handling native long long. */
391
392 static int
get_longlong(PyObject * v,long long * p)393 get_longlong(PyObject *v, long long *p)
394 {
395 long long x;
396 if (PyFloat_Check(v)) {
397 PyErr_SetString(PyExc_TypeError,
398 "int expected instead of float");
399 return -1;
400 }
401 x = PyLong_AsUnsignedLongLongMask(v);
402 if (x == -1 && PyErr_Occurred())
403 return -1;
404 *p = x;
405 return 0;
406 }
407
408 /* Same, but handling native unsigned long long. */
409
410 static int
get_ulonglong(PyObject * v,unsigned long long * p)411 get_ulonglong(PyObject *v, unsigned long long *p)
412 {
413 unsigned long long x;
414 if (PyFloat_Check(v)) {
415 PyErr_SetString(PyExc_TypeError,
416 "int expected instead of float");
417 return -1;
418 }
419 x = PyLong_AsUnsignedLongLongMask(v);
420 if (x == (unsigned long long)-1 && PyErr_Occurred())
421 return -1;
422 *p = x;
423 return 0;
424 }
425
426 /*****************************************************************
427 * Integer fields, with bitfield support
428 */
429
430 /* how to decode the size field, for integer get/set functions */
431 #define LOW_BIT(x) ((x) & 0xFFFF)
432 #define NUM_BITS(x) ((x) >> 16)
433
434 /* Doesn't work if NUM_BITS(size) == 0, but it never happens in SET() call. */
435 #define BIT_MASK(type, size) (((((type)1 << (NUM_BITS(size) - 1)) - 1) << 1) + 1)
436
437 /* This macro CHANGES the first parameter IN PLACE. For proper sign handling,
438 we must first shift left, then right.
439 */
440 #define GET_BITFIELD(v, size) \
441 if (NUM_BITS(size)) { \
442 v <<= (sizeof(v)*8 - LOW_BIT(size) - NUM_BITS(size)); \
443 v >>= (sizeof(v)*8 - NUM_BITS(size)); \
444 }
445
446 /* This macro RETURNS the first parameter with the bit field CHANGED. */
447 #define SET(type, x, v, size) \
448 (NUM_BITS(size) ? \
449 ( ( (type)x & ~(BIT_MASK(type, size) << LOW_BIT(size)) ) | ( ((type)v & BIT_MASK(type, size)) << LOW_BIT(size) ) ) \
450 : (type)v)
451
452 /* byte swapping macros */
453 #define SWAP_2(v) \
454 ( ( (v >> 8) & 0x00FF) | \
455 ( (v << 8) & 0xFF00) )
456
457 #define SWAP_4(v) \
458 ( ( (v & 0x000000FF) << 24 ) | \
459 ( (v & 0x0000FF00) << 8 ) | \
460 ( (v & 0x00FF0000) >> 8 ) | \
461 ( ((v >> 24) & 0xFF)) )
462
463 #ifdef _MSC_VER
464 #define SWAP_8(v) \
465 ( ( (v & 0x00000000000000FFL) << 56 ) | \
466 ( (v & 0x000000000000FF00L) << 40 ) | \
467 ( (v & 0x0000000000FF0000L) << 24 ) | \
468 ( (v & 0x00000000FF000000L) << 8 ) | \
469 ( (v & 0x000000FF00000000L) >> 8 ) | \
470 ( (v & 0x0000FF0000000000L) >> 24 ) | \
471 ( (v & 0x00FF000000000000L) >> 40 ) | \
472 ( ((v >> 56) & 0xFF)) )
473 #else
474 #define SWAP_8(v) \
475 ( ( (v & 0x00000000000000FFLL) << 56 ) | \
476 ( (v & 0x000000000000FF00LL) << 40 ) | \
477 ( (v & 0x0000000000FF0000LL) << 24 ) | \
478 ( (v & 0x00000000FF000000LL) << 8 ) | \
479 ( (v & 0x000000FF00000000LL) >> 8 ) | \
480 ( (v & 0x0000FF0000000000LL) >> 24 ) | \
481 ( (v & 0x00FF000000000000LL) >> 40 ) | \
482 ( ((v >> 56) & 0xFF)) )
483 #endif
484
485 #define SWAP_INT SWAP_4
486
487 #if SIZEOF_LONG == 4
488 # define SWAP_LONG SWAP_4
489 #elif SIZEOF_LONG == 8
490 # define SWAP_LONG SWAP_8
491 #endif
492 /*****************************************************************
493 * The setter methods return an object which must be kept alive, to keep the
494 * data valid which has been stored in the memory block. The ctypes object
495 * instance inserts this object into its 'b_objects' list.
496 *
497 * For simple Python types like integers or characters, there is nothing that
498 * has to been kept alive, so Py_None is returned in these cases. But this
499 * makes inspecting the 'b_objects' list, which is accessible from Python for
500 * debugging, less useful.
501 *
502 * So, defining the _CTYPES_DEBUG_KEEP symbol returns the original value
503 * instead of Py_None.
504 */
505
506 #ifdef _CTYPES_DEBUG_KEEP
507 #define _RET(x) Py_INCREF(x); return x
508 #else
509 #define _RET(X) Py_RETURN_NONE
510 #endif
511
512 /*****************************************************************
513 * integer accessor methods, supporting bit fields
514 */
515
516 static PyObject *
b_set(void * ptr,PyObject * value,Py_ssize_t size)517 b_set(void *ptr, PyObject *value, Py_ssize_t size)
518 {
519 long val;
520 if (get_long(value, &val) < 0)
521 return NULL;
522 *(signed char *)ptr = SET(signed char, *(signed char *)ptr, val, size);
523 _RET(value);
524 }
525
526
527 static PyObject *
b_get(void * ptr,Py_ssize_t size)528 b_get(void *ptr, Py_ssize_t size)
529 {
530 signed char val = *(signed char *)ptr;
531 GET_BITFIELD(val, size);
532 return PyLong_FromLong(val);
533 }
534
535 static PyObject *
B_set(void * ptr,PyObject * value,Py_ssize_t size)536 B_set(void *ptr, PyObject *value, Py_ssize_t size)
537 {
538 unsigned long val;
539 if (get_ulong(value, &val) < 0)
540 return NULL;
541 *(unsigned char *)ptr = SET(unsigned char, *(unsigned char*)ptr, val, size);
542 _RET(value);
543 }
544
545
546 static PyObject *
B_get(void * ptr,Py_ssize_t size)547 B_get(void *ptr, Py_ssize_t size)
548 {
549 unsigned char val = *(unsigned char *)ptr;
550 GET_BITFIELD(val, size);
551 return PyLong_FromLong(val);
552 }
553
554 static PyObject *
h_set(void * ptr,PyObject * value,Py_ssize_t size)555 h_set(void *ptr, PyObject *value, Py_ssize_t size)
556 {
557 long val;
558 short x;
559 if (get_long(value, &val) < 0)
560 return NULL;
561 memcpy(&x, ptr, sizeof(x));
562 x = SET(short, x, val, size);
563 memcpy(ptr, &x, sizeof(x));
564 _RET(value);
565 }
566
567
568 static PyObject *
h_set_sw(void * ptr,PyObject * value,Py_ssize_t size)569 h_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
570 {
571 long val;
572 short field;
573 if (get_long(value, &val) < 0)
574 return NULL;
575 memcpy(&field, ptr, sizeof(field));
576 field = SWAP_2(field);
577 field = SET(short, field, val, size);
578 field = SWAP_2(field);
579 memcpy(ptr, &field, sizeof(field));
580 _RET(value);
581 }
582
583 static PyObject *
h_get(void * ptr,Py_ssize_t size)584 h_get(void *ptr, Py_ssize_t size)
585 {
586 short val;
587 memcpy(&val, ptr, sizeof(val));
588 GET_BITFIELD(val, size);
589 return PyLong_FromLong((long)val);
590 }
591
592 static PyObject *
h_get_sw(void * ptr,Py_ssize_t size)593 h_get_sw(void *ptr, Py_ssize_t size)
594 {
595 short val;
596 memcpy(&val, ptr, sizeof(val));
597 val = SWAP_2(val);
598 GET_BITFIELD(val, size);
599 return PyLong_FromLong(val);
600 }
601
602 static PyObject *
H_set(void * ptr,PyObject * value,Py_ssize_t size)603 H_set(void *ptr, PyObject *value, Py_ssize_t size)
604 {
605 unsigned long val;
606 unsigned short x;
607 if (get_ulong(value, &val) < 0)
608 return NULL;
609 memcpy(&x, ptr, sizeof(x));
610 x = SET(unsigned short, x, val, size);
611 memcpy(ptr, &x, sizeof(x));
612 _RET(value);
613 }
614
615 static PyObject *
H_set_sw(void * ptr,PyObject * value,Py_ssize_t size)616 H_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
617 {
618 unsigned long val;
619 unsigned short field;
620 if (get_ulong(value, &val) < 0)
621 return NULL;
622 memcpy(&field, ptr, sizeof(field));
623 field = SWAP_2(field);
624 field = SET(unsigned short, field, val, size);
625 field = SWAP_2(field);
626 memcpy(ptr, &field, sizeof(field));
627 _RET(value);
628 }
629
630
631 static PyObject *
H_get(void * ptr,Py_ssize_t size)632 H_get(void *ptr, Py_ssize_t size)
633 {
634 unsigned short val;
635 memcpy(&val, ptr, sizeof(val));
636 GET_BITFIELD(val, size);
637 return PyLong_FromLong(val);
638 }
639
640 static PyObject *
H_get_sw(void * ptr,Py_ssize_t size)641 H_get_sw(void *ptr, Py_ssize_t size)
642 {
643 unsigned short val;
644 memcpy(&val, ptr, sizeof(val));
645 val = SWAP_2(val);
646 GET_BITFIELD(val, size);
647 return PyLong_FromLong(val);
648 }
649
650 static PyObject *
i_set(void * ptr,PyObject * value,Py_ssize_t size)651 i_set(void *ptr, PyObject *value, Py_ssize_t size)
652 {
653 long val;
654 int x;
655 if (get_long(value, &val) < 0)
656 return NULL;
657 memcpy(&x, ptr, sizeof(x));
658 x = SET(int, x, val, size);
659 memcpy(ptr, &x, sizeof(x));
660 _RET(value);
661 }
662
663 static PyObject *
i_set_sw(void * ptr,PyObject * value,Py_ssize_t size)664 i_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
665 {
666 long val;
667 int field;
668 if (get_long(value, &val) < 0)
669 return NULL;
670 memcpy(&field, ptr, sizeof(field));
671 field = SWAP_INT(field);
672 field = SET(int, field, val, size);
673 field = SWAP_INT(field);
674 memcpy(ptr, &field, sizeof(field));
675 _RET(value);
676 }
677
678
679 static PyObject *
i_get(void * ptr,Py_ssize_t size)680 i_get(void *ptr, Py_ssize_t size)
681 {
682 int val;
683 memcpy(&val, ptr, sizeof(val));
684 GET_BITFIELD(val, size);
685 return PyLong_FromLong(val);
686 }
687
688 static PyObject *
i_get_sw(void * ptr,Py_ssize_t size)689 i_get_sw(void *ptr, Py_ssize_t size)
690 {
691 int val;
692 memcpy(&val, ptr, sizeof(val));
693 val = SWAP_INT(val);
694 GET_BITFIELD(val, size);
695 return PyLong_FromLong(val);
696 }
697
698 #ifndef MS_WIN32
699 /* http://msdn.microsoft.com/en-us/library/cc237864.aspx */
700 #define VARIANT_FALSE 0x0000
701 #define VARIANT_TRUE 0xFFFF
702 #endif
703 /* short BOOL - VARIANT_BOOL */
704 static PyObject *
vBOOL_set(void * ptr,PyObject * value,Py_ssize_t size)705 vBOOL_set(void *ptr, PyObject *value, Py_ssize_t size)
706 {
707 switch (PyObject_IsTrue(value)) {
708 case -1:
709 return NULL;
710 case 0:
711 *(short int *)ptr = VARIANT_FALSE;
712 _RET(value);
713 default:
714 *(short int *)ptr = VARIANT_TRUE;
715 _RET(value);
716 }
717 }
718
719 static PyObject *
vBOOL_get(void * ptr,Py_ssize_t size)720 vBOOL_get(void *ptr, Py_ssize_t size)
721 {
722 return PyBool_FromLong((long)*(short int *)ptr);
723 }
724
725 static PyObject *
bool_set(void * ptr,PyObject * value,Py_ssize_t size)726 bool_set(void *ptr, PyObject *value, Py_ssize_t size)
727 {
728 switch (PyObject_IsTrue(value)) {
729 case -1:
730 return NULL;
731 case 0:
732 *(_Bool *)ptr = 0;
733 _RET(value);
734 default:
735 *(_Bool *)ptr = 1;
736 _RET(value);
737 }
738 }
739
740 static PyObject *
bool_get(void * ptr,Py_ssize_t size)741 bool_get(void *ptr, Py_ssize_t size)
742 {
743 return PyBool_FromLong((long)*(_Bool *)ptr);
744 }
745
746 static PyObject *
I_set(void * ptr,PyObject * value,Py_ssize_t size)747 I_set(void *ptr, PyObject *value, Py_ssize_t size)
748 {
749 unsigned long val;
750 unsigned int x;
751 if (get_ulong(value, &val) < 0)
752 return NULL;
753 memcpy(&x, ptr, sizeof(x));
754 x = SET(unsigned int, x, val, size);
755 memcpy(ptr, &x, sizeof(x));
756 _RET(value);
757 }
758
759 static PyObject *
I_set_sw(void * ptr,PyObject * value,Py_ssize_t size)760 I_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
761 {
762 unsigned long val;
763 unsigned int field;
764 if (get_ulong(value, &val) < 0)
765 return NULL;
766 memcpy(&field, ptr, sizeof(field));
767 field = SWAP_INT(field);
768 field = SET(unsigned int, field, (unsigned int)val, size);
769 field = SWAP_INT(field);
770 memcpy(ptr, &field, sizeof(field));
771 _RET(value);
772 }
773
774
775 static PyObject *
I_get(void * ptr,Py_ssize_t size)776 I_get(void *ptr, Py_ssize_t size)
777 {
778 unsigned int val;
779 memcpy(&val, ptr, sizeof(val));
780 GET_BITFIELD(val, size);
781 return PyLong_FromUnsignedLong(val);
782 }
783
784 static PyObject *
I_get_sw(void * ptr,Py_ssize_t size)785 I_get_sw(void *ptr, Py_ssize_t size)
786 {
787 unsigned int val;
788 memcpy(&val, ptr, sizeof(val));
789 val = SWAP_INT(val);
790 GET_BITFIELD(val, size);
791 return PyLong_FromUnsignedLong(val);
792 }
793
794 static PyObject *
l_set(void * ptr,PyObject * value,Py_ssize_t size)795 l_set(void *ptr, PyObject *value, Py_ssize_t size)
796 {
797 long val;
798 long x;
799 if (get_long(value, &val) < 0)
800 return NULL;
801 memcpy(&x, ptr, sizeof(x));
802 x = SET(long, x, val, size);
803 memcpy(ptr, &x, sizeof(x));
804 _RET(value);
805 }
806
807 static PyObject *
l_set_sw(void * ptr,PyObject * value,Py_ssize_t size)808 l_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
809 {
810 long val;
811 long field;
812 if (get_long(value, &val) < 0)
813 return NULL;
814 memcpy(&field, ptr, sizeof(field));
815 field = SWAP_LONG(field);
816 field = SET(long, field, val, size);
817 field = SWAP_LONG(field);
818 memcpy(ptr, &field, sizeof(field));
819 _RET(value);
820 }
821
822
823 static PyObject *
l_get(void * ptr,Py_ssize_t size)824 l_get(void *ptr, Py_ssize_t size)
825 {
826 long val;
827 memcpy(&val, ptr, sizeof(val));
828 GET_BITFIELD(val, size);
829 return PyLong_FromLong(val);
830 }
831
832 static PyObject *
l_get_sw(void * ptr,Py_ssize_t size)833 l_get_sw(void *ptr, Py_ssize_t size)
834 {
835 long val;
836 memcpy(&val, ptr, sizeof(val));
837 val = SWAP_LONG(val);
838 GET_BITFIELD(val, size);
839 return PyLong_FromLong(val);
840 }
841
842 static PyObject *
L_set(void * ptr,PyObject * value,Py_ssize_t size)843 L_set(void *ptr, PyObject *value, Py_ssize_t size)
844 {
845 unsigned long val;
846 unsigned long x;
847 if (get_ulong(value, &val) < 0)
848 return NULL;
849 memcpy(&x, ptr, sizeof(x));
850 x = SET(unsigned long, x, val, size);
851 memcpy(ptr, &x, sizeof(x));
852 _RET(value);
853 }
854
855 static PyObject *
L_set_sw(void * ptr,PyObject * value,Py_ssize_t size)856 L_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
857 {
858 unsigned long val;
859 unsigned long field;
860 if (get_ulong(value, &val) < 0)
861 return NULL;
862 memcpy(&field, ptr, sizeof(field));
863 field = SWAP_LONG(field);
864 field = SET(unsigned long, field, val, size);
865 field = SWAP_LONG(field);
866 memcpy(ptr, &field, sizeof(field));
867 _RET(value);
868 }
869
870
871 static PyObject *
L_get(void * ptr,Py_ssize_t size)872 L_get(void *ptr, Py_ssize_t size)
873 {
874 unsigned long val;
875 memcpy(&val, ptr, sizeof(val));
876 GET_BITFIELD(val, size);
877 return PyLong_FromUnsignedLong(val);
878 }
879
880 static PyObject *
L_get_sw(void * ptr,Py_ssize_t size)881 L_get_sw(void *ptr, Py_ssize_t size)
882 {
883 unsigned long val;
884 memcpy(&val, ptr, sizeof(val));
885 val = SWAP_LONG(val);
886 GET_BITFIELD(val, size);
887 return PyLong_FromUnsignedLong(val);
888 }
889
890 static PyObject *
q_set(void * ptr,PyObject * value,Py_ssize_t size)891 q_set(void *ptr, PyObject *value, Py_ssize_t size)
892 {
893 long long val;
894 long long x;
895 if (get_longlong(value, &val) < 0)
896 return NULL;
897 memcpy(&x, ptr, sizeof(x));
898 x = SET(long long, x, val, size);
899 memcpy(ptr, &x, sizeof(x));
900 _RET(value);
901 }
902
903 static PyObject *
q_set_sw(void * ptr,PyObject * value,Py_ssize_t size)904 q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
905 {
906 long long val;
907 long long field;
908 if (get_longlong(value, &val) < 0)
909 return NULL;
910 memcpy(&field, ptr, sizeof(field));
911 field = SWAP_8(field);
912 field = SET(long long, field, val, size);
913 field = SWAP_8(field);
914 memcpy(ptr, &field, sizeof(field));
915 _RET(value);
916 }
917
918 static PyObject *
q_get(void * ptr,Py_ssize_t size)919 q_get(void *ptr, Py_ssize_t size)
920 {
921 long long val;
922 memcpy(&val, ptr, sizeof(val));
923 GET_BITFIELD(val, size);
924 return PyLong_FromLongLong(val);
925 }
926
927 static PyObject *
q_get_sw(void * ptr,Py_ssize_t size)928 q_get_sw(void *ptr, Py_ssize_t size)
929 {
930 long long val;
931 memcpy(&val, ptr, sizeof(val));
932 val = SWAP_8(val);
933 GET_BITFIELD(val, size);
934 return PyLong_FromLongLong(val);
935 }
936
937 static PyObject *
Q_set(void * ptr,PyObject * value,Py_ssize_t size)938 Q_set(void *ptr, PyObject *value, Py_ssize_t size)
939 {
940 unsigned long long val;
941 unsigned long long x;
942 if (get_ulonglong(value, &val) < 0)
943 return NULL;
944 memcpy(&x, ptr, sizeof(x));
945 x = SET(long long, x, val, size);
946 memcpy(ptr, &x, sizeof(x));
947 _RET(value);
948 }
949
950 static PyObject *
Q_set_sw(void * ptr,PyObject * value,Py_ssize_t size)951 Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
952 {
953 unsigned long long val;
954 unsigned long long field;
955 if (get_ulonglong(value, &val) < 0)
956 return NULL;
957 memcpy(&field, ptr, sizeof(field));
958 field = SWAP_8(field);
959 field = SET(unsigned long long, field, val, size);
960 field = SWAP_8(field);
961 memcpy(ptr, &field, sizeof(field));
962 _RET(value);
963 }
964
965 static PyObject *
Q_get(void * ptr,Py_ssize_t size)966 Q_get(void *ptr, Py_ssize_t size)
967 {
968 unsigned long long val;
969 memcpy(&val, ptr, sizeof(val));
970 GET_BITFIELD(val, size);
971 return PyLong_FromUnsignedLongLong(val);
972 }
973
974 static PyObject *
Q_get_sw(void * ptr,Py_ssize_t size)975 Q_get_sw(void *ptr, Py_ssize_t size)
976 {
977 unsigned long long val;
978 memcpy(&val, ptr, sizeof(val));
979 val = SWAP_8(val);
980 GET_BITFIELD(val, size);
981 return PyLong_FromUnsignedLongLong(val);
982 }
983
984 /*****************************************************************
985 * non-integer accessor methods, not supporting bit fields
986 */
987
988
989 static PyObject *
g_set(void * ptr,PyObject * value,Py_ssize_t size)990 g_set(void *ptr, PyObject *value, Py_ssize_t size)
991 {
992 long double x;
993
994 x = PyFloat_AsDouble(value);
995 if (x == -1 && PyErr_Occurred())
996 return NULL;
997 memcpy(ptr, &x, sizeof(long double));
998 _RET(value);
999 }
1000
1001 static PyObject *
g_get(void * ptr,Py_ssize_t size)1002 g_get(void *ptr, Py_ssize_t size)
1003 {
1004 long double val;
1005 memcpy(&val, ptr, sizeof(long double));
1006 return PyFloat_FromDouble(val);
1007 }
1008
1009 static PyObject *
d_set(void * ptr,PyObject * value,Py_ssize_t size)1010 d_set(void *ptr, PyObject *value, Py_ssize_t size)
1011 {
1012 double x;
1013
1014 x = PyFloat_AsDouble(value);
1015 if (x == -1 && PyErr_Occurred())
1016 return NULL;
1017 memcpy(ptr, &x, sizeof(double));
1018 _RET(value);
1019 }
1020
1021 static PyObject *
d_get(void * ptr,Py_ssize_t size)1022 d_get(void *ptr, Py_ssize_t size)
1023 {
1024 double val;
1025 memcpy(&val, ptr, sizeof(val));
1026 return PyFloat_FromDouble(val);
1027 }
1028
1029 static PyObject *
d_set_sw(void * ptr,PyObject * value,Py_ssize_t size)1030 d_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
1031 {
1032 double x;
1033
1034 x = PyFloat_AsDouble(value);
1035 if (x == -1 && PyErr_Occurred())
1036 return NULL;
1037 #ifdef WORDS_BIGENDIAN
1038 if (_PyFloat_Pack8(x, (unsigned char *)ptr, 1))
1039 return NULL;
1040 #else
1041 if (_PyFloat_Pack8(x, (unsigned char *)ptr, 0))
1042 return NULL;
1043 #endif
1044 _RET(value);
1045 }
1046
1047 static PyObject *
d_get_sw(void * ptr,Py_ssize_t size)1048 d_get_sw(void *ptr, Py_ssize_t size)
1049 {
1050 #ifdef WORDS_BIGENDIAN
1051 return PyFloat_FromDouble(_PyFloat_Unpack8(ptr, 1));
1052 #else
1053 return PyFloat_FromDouble(_PyFloat_Unpack8(ptr, 0));
1054 #endif
1055 }
1056
1057 static PyObject *
f_set(void * ptr,PyObject * value,Py_ssize_t size)1058 f_set(void *ptr, PyObject *value, Py_ssize_t size)
1059 {
1060 float x;
1061
1062 x = (float)PyFloat_AsDouble(value);
1063 if (x == -1 && PyErr_Occurred())
1064 return NULL;
1065 memcpy(ptr, &x, sizeof(x));
1066 _RET(value);
1067 }
1068
1069 static PyObject *
f_get(void * ptr,Py_ssize_t size)1070 f_get(void *ptr, Py_ssize_t size)
1071 {
1072 float val;
1073 memcpy(&val, ptr, sizeof(val));
1074 return PyFloat_FromDouble(val);
1075 }
1076
1077 static PyObject *
f_set_sw(void * ptr,PyObject * value,Py_ssize_t size)1078 f_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
1079 {
1080 float x;
1081
1082 x = (float)PyFloat_AsDouble(value);
1083 if (x == -1 && PyErr_Occurred())
1084 return NULL;
1085 #ifdef WORDS_BIGENDIAN
1086 if (_PyFloat_Pack4(x, (unsigned char *)ptr, 1))
1087 return NULL;
1088 #else
1089 if (_PyFloat_Pack4(x, (unsigned char *)ptr, 0))
1090 return NULL;
1091 #endif
1092 _RET(value);
1093 }
1094
1095 static PyObject *
f_get_sw(void * ptr,Py_ssize_t size)1096 f_get_sw(void *ptr, Py_ssize_t size)
1097 {
1098 #ifdef WORDS_BIGENDIAN
1099 return PyFloat_FromDouble(_PyFloat_Unpack4(ptr, 1));
1100 #else
1101 return PyFloat_FromDouble(_PyFloat_Unpack4(ptr, 0));
1102 #endif
1103 }
1104
1105 /*
1106 py_object refcounts:
1107
1108 1. If we have a py_object instance, O_get must Py_INCREF the returned
1109 object, of course. If O_get is called from a function result, no py_object
1110 instance is created - so callproc.c::GetResult has to call Py_DECREF.
1111
1112 2. The memory block in py_object owns a refcount. So, py_object must call
1113 Py_DECREF on destruction. Maybe only when b_needsfree is non-zero.
1114 */
1115 static PyObject *
O_get(void * ptr,Py_ssize_t size)1116 O_get(void *ptr, Py_ssize_t size)
1117 {
1118 PyObject *ob = *(PyObject **)ptr;
1119 if (ob == NULL) {
1120 if (!PyErr_Occurred())
1121 /* Set an error if not yet set */
1122 PyErr_SetString(PyExc_ValueError,
1123 "PyObject is NULL");
1124 return NULL;
1125 }
1126 Py_INCREF(ob);
1127 return ob;
1128 }
1129
1130 static PyObject *
O_set(void * ptr,PyObject * value,Py_ssize_t size)1131 O_set(void *ptr, PyObject *value, Py_ssize_t size)
1132 {
1133 /* Hm, does the memory block need it's own refcount or not? */
1134 *(PyObject **)ptr = value;
1135 Py_INCREF(value);
1136 return value;
1137 }
1138
1139
1140 static PyObject *
c_set(void * ptr,PyObject * value,Py_ssize_t size)1141 c_set(void *ptr, PyObject *value, Py_ssize_t size)
1142 {
1143 if (PyBytes_Check(value) && PyBytes_GET_SIZE(value) == 1) {
1144 *(char *)ptr = PyBytes_AS_STRING(value)[0];
1145 _RET(value);
1146 }
1147 if (PyByteArray_Check(value) && PyByteArray_GET_SIZE(value) == 1) {
1148 *(char *)ptr = PyByteArray_AS_STRING(value)[0];
1149 _RET(value);
1150 }
1151 if (PyLong_Check(value))
1152 {
1153 long longval = PyLong_AsLong(value);
1154 if (longval < 0 || longval >= 256)
1155 goto error;
1156 *(char *)ptr = (char)longval;
1157 _RET(value);
1158 }
1159 error:
1160 PyErr_Format(PyExc_TypeError,
1161 "one character bytes, bytearray or integer expected");
1162 return NULL;
1163 }
1164
1165
1166 static PyObject *
c_get(void * ptr,Py_ssize_t size)1167 c_get(void *ptr, Py_ssize_t size)
1168 {
1169 return PyBytes_FromStringAndSize((char *)ptr, 1);
1170 }
1171
1172 #ifdef CTYPES_UNICODE
1173 /* u - a single wchar_t character */
1174 static PyObject *
u_set(void * ptr,PyObject * value,Py_ssize_t size)1175 u_set(void *ptr, PyObject *value, Py_ssize_t size)
1176 {
1177 Py_ssize_t len;
1178 wchar_t chars[2];
1179 if (!PyUnicode_Check(value)) {
1180 PyErr_Format(PyExc_TypeError,
1181 "unicode string expected instead of %s instance",
1182 value->ob_type->tp_name);
1183 return NULL;
1184 } else
1185 Py_INCREF(value);
1186
1187 len = PyUnicode_AsWideChar(value, chars, 2);
1188 if (len != 1) {
1189 Py_DECREF(value);
1190 PyErr_SetString(PyExc_TypeError,
1191 "one character unicode string expected");
1192 return NULL;
1193 }
1194
1195 *(wchar_t *)ptr = chars[0];
1196 Py_DECREF(value);
1197
1198 _RET(value);
1199 }
1200
1201
1202 static PyObject *
u_get(void * ptr,Py_ssize_t size)1203 u_get(void *ptr, Py_ssize_t size)
1204 {
1205 return PyUnicode_FromWideChar((wchar_t *)ptr, 1);
1206 }
1207
1208 /* U - a unicode string */
1209 static PyObject *
U_get(void * ptr,Py_ssize_t size)1210 U_get(void *ptr, Py_ssize_t size)
1211 {
1212 Py_ssize_t len;
1213 wchar_t *p;
1214
1215 size /= sizeof(wchar_t); /* we count character units here, not bytes */
1216
1217 /* We need 'result' to be able to count the characters with wcslen,
1218 since ptr may not be NUL terminated. If the length is smaller (if
1219 it was actually NUL terminated, we construct a new one and throw
1220 away the result.
1221 */
1222 /* chop off at the first NUL character, if any. */
1223 p = (wchar_t*)ptr;
1224 for (len = 0; len < size; ++len) {
1225 if (!p[len])
1226 break;
1227 }
1228
1229 return PyUnicode_FromWideChar((wchar_t *)ptr, len);
1230 }
1231
1232 static PyObject *
U_set(void * ptr,PyObject * value,Py_ssize_t length)1233 U_set(void *ptr, PyObject *value, Py_ssize_t length)
1234 {
1235 /* It's easier to calculate in characters than in bytes */
1236 length /= sizeof(wchar_t);
1237
1238 if (!PyUnicode_Check(value)) {
1239 PyErr_Format(PyExc_TypeError,
1240 "unicode string expected instead of %s instance",
1241 value->ob_type->tp_name);
1242 return NULL;
1243 }
1244
1245 Py_ssize_t size = PyUnicode_AsWideChar(value, NULL, 0);
1246 if (size < 0) {
1247 return NULL;
1248 }
1249 // PyUnicode_AsWideChar() returns number of wchars including trailing null byte,
1250 // when it is called with NULL.
1251 size--;
1252 assert(size >= 0);
1253 if (size > length) {
1254 PyErr_Format(PyExc_ValueError,
1255 "string too long (%zd, maximum length %zd)",
1256 size, length);
1257 return NULL;
1258 } else if (size < length-1)
1259 /* copy terminating NUL character if there is space */
1260 size += 1;
1261
1262 if (PyUnicode_AsWideChar(value, (wchar_t *)ptr, size) == -1) {
1263 return NULL;
1264 }
1265
1266 Py_INCREF(value);
1267 return value;
1268 }
1269
1270 #endif
1271
1272 static PyObject *
s_get(void * ptr,Py_ssize_t size)1273 s_get(void *ptr, Py_ssize_t size)
1274 {
1275 Py_ssize_t i;
1276 char *p;
1277
1278 p = (char *)ptr;
1279 for (i = 0; i < size; ++i) {
1280 if (*p++ == '\0')
1281 break;
1282 }
1283
1284 return PyBytes_FromStringAndSize((char *)ptr, (Py_ssize_t)i);
1285 }
1286
1287 static PyObject *
s_set(void * ptr,PyObject * value,Py_ssize_t length)1288 s_set(void *ptr, PyObject *value, Py_ssize_t length)
1289 {
1290 char *data;
1291 Py_ssize_t size;
1292
1293 if(!PyBytes_Check(value)) {
1294 PyErr_Format(PyExc_TypeError,
1295 "expected bytes, %s found",
1296 value->ob_type->tp_name);
1297 return NULL;
1298 }
1299
1300 data = PyBytes_AS_STRING(value);
1301 size = strlen(data); /* XXX Why not Py_SIZE(value)? */
1302 if (size < length) {
1303 /* This will copy the terminating NUL character
1304 * if there is space for it.
1305 */
1306 ++size;
1307 } else if (size > length) {
1308 PyErr_Format(PyExc_ValueError,
1309 "bytes too long (%zd, maximum length %zd)",
1310 size, length);
1311 return NULL;
1312 }
1313 /* Also copy the terminating NUL character if there is space */
1314 memcpy((char *)ptr, data, size);
1315
1316 _RET(value);
1317 }
1318
1319 static PyObject *
z_set(void * ptr,PyObject * value,Py_ssize_t size)1320 z_set(void *ptr, PyObject *value, Py_ssize_t size)
1321 {
1322 if (value == Py_None) {
1323 *(char **)ptr = NULL;
1324 Py_INCREF(value);
1325 return value;
1326 }
1327 if (PyBytes_Check(value)) {
1328 *(char **)ptr = PyBytes_AsString(value);
1329 Py_INCREF(value);
1330 return value;
1331 } else if (PyLong_Check(value)) {
1332 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
1333 *(char **)ptr = (char *)PyLong_AsUnsignedLongLongMask(value);
1334 #else
1335 *(char **)ptr = (char *)PyLong_AsUnsignedLongMask(value);
1336 #endif
1337 _RET(value);
1338 }
1339 PyErr_Format(PyExc_TypeError,
1340 "bytes or integer address expected instead of %s instance",
1341 value->ob_type->tp_name);
1342 return NULL;
1343 }
1344
1345 static PyObject *
z_get(void * ptr,Py_ssize_t size)1346 z_get(void *ptr, Py_ssize_t size)
1347 {
1348 /* XXX What about invalid pointers ??? */
1349 if (*(void **)ptr) {
1350 return PyBytes_FromStringAndSize(*(char **)ptr,
1351 strlen(*(char **)ptr));
1352 } else {
1353 Py_RETURN_NONE;
1354 }
1355 }
1356
1357 #ifdef CTYPES_UNICODE
1358 static PyObject *
Z_set(void * ptr,PyObject * value,Py_ssize_t size)1359 Z_set(void *ptr, PyObject *value, Py_ssize_t size)
1360 {
1361 PyObject *keep;
1362 wchar_t *buffer;
1363 Py_ssize_t bsize;
1364
1365 if (value == Py_None) {
1366 *(wchar_t **)ptr = NULL;
1367 Py_INCREF(value);
1368 return value;
1369 }
1370 if (PyLong_Check(value)) {
1371 #if SIZEOF_VOID_P == SIZEOF_LONG_LONG
1372 *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value);
1373 #else
1374 *(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value);
1375 #endif
1376 Py_RETURN_NONE;
1377 }
1378 if (!PyUnicode_Check(value)) {
1379 PyErr_Format(PyExc_TypeError,
1380 "unicode string or integer address expected instead of %s instance",
1381 value->ob_type->tp_name);
1382 return NULL;
1383 }
1384
1385 /* We must create a wchar_t* buffer from the unicode object,
1386 and keep it alive */
1387 buffer = PyUnicode_AsWideCharString(value, &bsize);
1388 if (!buffer)
1389 return NULL;
1390 keep = PyCapsule_New(buffer, CTYPES_CFIELD_CAPSULE_NAME_PYMEM, pymem_destructor);
1391 if (!keep) {
1392 PyMem_Free(buffer);
1393 return NULL;
1394 }
1395 *(wchar_t **)ptr = buffer;
1396 return keep;
1397 }
1398
1399 static PyObject *
Z_get(void * ptr,Py_ssize_t size)1400 Z_get(void *ptr, Py_ssize_t size)
1401 {
1402 wchar_t *p;
1403 p = *(wchar_t **)ptr;
1404 if (p) {
1405 return PyUnicode_FromWideChar(p, wcslen(p));
1406 } else {
1407 Py_RETURN_NONE;
1408 }
1409 }
1410 #endif
1411
1412 #ifdef MS_WIN32
1413 static PyObject *
BSTR_set(void * ptr,PyObject * value,Py_ssize_t size)1414 BSTR_set(void *ptr, PyObject *value, Py_ssize_t size)
1415 {
1416 BSTR bstr;
1417
1418 /* convert value into a PyUnicodeObject or NULL */
1419 if (Py_None == value) {
1420 value = NULL;
1421 } else if (!PyUnicode_Check(value)) {
1422 PyErr_Format(PyExc_TypeError,
1423 "unicode string expected instead of %s instance",
1424 value->ob_type->tp_name);
1425 return NULL;
1426 }
1427
1428 /* create a BSTR from value */
1429 if (value) {
1430 Py_ssize_t wsize;
1431 wchar_t *wvalue = PyUnicode_AsWideCharString(value, &wsize);
1432 if (wvalue == NULL) {
1433 return NULL;
1434 }
1435 if ((unsigned) wsize != wsize) {
1436 PyErr_SetString(PyExc_ValueError, "String too long for BSTR");
1437 PyMem_Free(wvalue);
1438 return NULL;
1439 }
1440 bstr = SysAllocStringLen(wvalue, (unsigned)wsize);
1441 PyMem_Free(wvalue);
1442 } else
1443 bstr = NULL;
1444
1445 /* free the previous contents, if any */
1446 if (*(BSTR *)ptr)
1447 SysFreeString(*(BSTR *)ptr);
1448
1449 /* and store it */
1450 *(BSTR *)ptr = bstr;
1451
1452 /* We don't need to keep any other object */
1453 _RET(value);
1454 }
1455
1456
1457 static PyObject *
BSTR_get(void * ptr,Py_ssize_t size)1458 BSTR_get(void *ptr, Py_ssize_t size)
1459 {
1460 BSTR p;
1461 p = *(BSTR *)ptr;
1462 if (p)
1463 return PyUnicode_FromWideChar(p, SysStringLen(p));
1464 else {
1465 /* Hm, it seems NULL pointer and zero length string are the
1466 same in BSTR, see Don Box, p 81
1467 */
1468 Py_RETURN_NONE;
1469 }
1470 }
1471 #endif
1472
1473 static PyObject *
P_set(void * ptr,PyObject * value,Py_ssize_t size)1474 P_set(void *ptr, PyObject *value, Py_ssize_t size)
1475 {
1476 void *v;
1477 if (value == Py_None) {
1478 *(void **)ptr = NULL;
1479 _RET(value);
1480 }
1481
1482 if (!PyLong_Check(value)) {
1483 PyErr_SetString(PyExc_TypeError,
1484 "cannot be converted to pointer");
1485 return NULL;
1486 }
1487
1488 #if SIZEOF_VOID_P <= SIZEOF_LONG
1489 v = (void *)PyLong_AsUnsignedLongMask(value);
1490 #else
1491 #if SIZEOF_LONG_LONG < SIZEOF_VOID_P
1492 # error "PyLong_AsVoidPtr: sizeof(long long) < sizeof(void*)"
1493 #endif
1494 v = (void *)PyLong_AsUnsignedLongLongMask(value);
1495 #endif
1496
1497 if (PyErr_Occurred())
1498 return NULL;
1499
1500 *(void **)ptr = v;
1501 _RET(value);
1502 }
1503
1504 static PyObject *
P_get(void * ptr,Py_ssize_t size)1505 P_get(void *ptr, Py_ssize_t size)
1506 {
1507 if (*(void **)ptr == NULL) {
1508 Py_RETURN_NONE;
1509 }
1510 return PyLong_FromVoidPtr(*(void **)ptr);
1511 }
1512
1513 static struct fielddesc formattable[] = {
1514 { 's', s_set, s_get, &ffi_type_pointer},
1515 { 'b', b_set, b_get, &ffi_type_schar},
1516 { 'B', B_set, B_get, &ffi_type_uchar},
1517 { 'c', c_set, c_get, &ffi_type_schar},
1518 { 'd', d_set, d_get, &ffi_type_double, d_set_sw, d_get_sw},
1519 { 'g', g_set, g_get, &ffi_type_longdouble},
1520 { 'f', f_set, f_get, &ffi_type_float, f_set_sw, f_get_sw},
1521 { 'h', h_set, h_get, &ffi_type_sshort, h_set_sw, h_get_sw},
1522 { 'H', H_set, H_get, &ffi_type_ushort, H_set_sw, H_get_sw},
1523 { 'i', i_set, i_get, &ffi_type_sint, i_set_sw, i_get_sw},
1524 { 'I', I_set, I_get, &ffi_type_uint, I_set_sw, I_get_sw},
1525 /* XXX Hm, sizeof(int) == sizeof(long) doesn't hold on every platform */
1526 /* As soon as we can get rid of the type codes, this is no longer a problem */
1527 #if SIZEOF_LONG == 4
1528 { 'l', l_set, l_get, &ffi_type_sint32, l_set_sw, l_get_sw},
1529 { 'L', L_set, L_get, &ffi_type_uint32, L_set_sw, L_get_sw},
1530 #elif SIZEOF_LONG == 8
1531 { 'l', l_set, l_get, &ffi_type_sint64, l_set_sw, l_get_sw},
1532 { 'L', L_set, L_get, &ffi_type_uint64, L_set_sw, L_get_sw},
1533 #else
1534 # error
1535 #endif
1536 #if SIZEOF_LONG_LONG == 8
1537 { 'q', q_set, q_get, &ffi_type_sint64, q_set_sw, q_get_sw},
1538 { 'Q', Q_set, Q_get, &ffi_type_uint64, Q_set_sw, Q_get_sw},
1539 #else
1540 # error
1541 #endif
1542 { 'P', P_set, P_get, &ffi_type_pointer},
1543 { 'z', z_set, z_get, &ffi_type_pointer},
1544 #ifdef CTYPES_UNICODE
1545 { 'u', u_set, u_get, NULL}, /* ffi_type set later */
1546 { 'U', U_set, U_get, &ffi_type_pointer},
1547 { 'Z', Z_set, Z_get, &ffi_type_pointer},
1548 #endif
1549 #ifdef MS_WIN32
1550 { 'X', BSTR_set, BSTR_get, &ffi_type_pointer},
1551 #endif
1552 { 'v', vBOOL_set, vBOOL_get, &ffi_type_sshort},
1553 #if SIZEOF__BOOL == 1
1554 { '?', bool_set, bool_get, &ffi_type_uchar}, /* Also fallback for no native _Bool support */
1555 #elif SIZEOF__BOOL == SIZEOF_SHORT
1556 { '?', bool_set, bool_get, &ffi_type_ushort},
1557 #elif SIZEOF__BOOL == SIZEOF_INT
1558 { '?', bool_set, bool_get, &ffi_type_uint, I_set_sw, I_get_sw},
1559 #elif SIZEOF__BOOL == SIZEOF_LONG
1560 { '?', bool_set, bool_get, &ffi_type_ulong, L_set_sw, L_get_sw},
1561 #elif SIZEOF__BOOL == SIZEOF_LONG_LONG
1562 { '?', bool_set, bool_get, &ffi_type_ulong, Q_set_sw, Q_get_sw},
1563 #endif /* SIZEOF__BOOL */
1564 { 'O', O_set, O_get, &ffi_type_pointer},
1565 { 0, NULL, NULL, NULL},
1566 };
1567
1568 /*
1569 Ideas: Implement VARIANT in this table, using 'V' code.
1570 Use '?' as code for BOOL.
1571 */
1572
1573 struct fielddesc *
_ctypes_get_fielddesc(const char * fmt)1574 _ctypes_get_fielddesc(const char *fmt)
1575 {
1576 static int initialized = 0;
1577 struct fielddesc *table = formattable;
1578
1579 if (!initialized) {
1580 initialized = 1;
1581 #ifdef CTYPES_UNICODE
1582 if (sizeof(wchar_t) == sizeof(short))
1583 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sshort;
1584 else if (sizeof(wchar_t) == sizeof(int))
1585 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_sint;
1586 else if (sizeof(wchar_t) == sizeof(long))
1587 _ctypes_get_fielddesc("u")->pffi_type = &ffi_type_slong;
1588 #endif
1589 }
1590
1591 for (; table->code; ++table) {
1592 if (table->code == fmt[0])
1593 return table;
1594 }
1595 return NULL;
1596 }
1597
1598 typedef struct { char c; char x; } s_char;
1599 typedef struct { char c; short x; } s_short;
1600 typedef struct { char c; int x; } s_int;
1601 typedef struct { char c; long x; } s_long;
1602 typedef struct { char c; float x; } s_float;
1603 typedef struct { char c; double x; } s_double;
1604 typedef struct { char c; long double x; } s_long_double;
1605 typedef struct { char c; char *x; } s_char_p;
1606 typedef struct { char c; void *x; } s_void_p;
1607
1608 /*
1609 #define CHAR_ALIGN (sizeof(s_char) - sizeof(char))
1610 #define SHORT_ALIGN (sizeof(s_short) - sizeof(short))
1611 #define LONG_ALIGN (sizeof(s_long) - sizeof(long))
1612 */
1613 #define INT_ALIGN (sizeof(s_int) - sizeof(int))
1614 #define FLOAT_ALIGN (sizeof(s_float) - sizeof(float))
1615 #define DOUBLE_ALIGN (sizeof(s_double) - sizeof(double))
1616 #define LONGDOUBLE_ALIGN (sizeof(s_long_double) - sizeof(long double))
1617
1618 /* #define CHAR_P_ALIGN (sizeof(s_char_p) - sizeof(char*)) */
1619 #define VOID_P_ALIGN (sizeof(s_void_p) - sizeof(void*))
1620
1621 /*
1622 #ifdef HAVE_USABLE_WCHAR_T
1623 typedef struct { char c; wchar_t x; } s_wchar;
1624 typedef struct { char c; wchar_t *x; } s_wchar_p;
1625
1626 #define WCHAR_ALIGN (sizeof(s_wchar) - sizeof(wchar_t))
1627 #define WCHAR_P_ALIGN (sizeof(s_wchar_p) - sizeof(wchar_t*))
1628 #endif
1629 */
1630
1631 typedef struct { char c; long long x; } s_long_long;
1632 #define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(long long))
1633
1634 /* from ffi.h:
1635 typedef struct _ffi_type
1636 {
1637 size_t size;
1638 unsigned short alignment;
1639 unsigned short type;
1640 struct _ffi_type **elements;
1641 } ffi_type;
1642 */
1643
1644 /* align and size are bogus for void, but they must not be zero */
1645 ffi_type ffi_type_void = { 1, 1, FFI_TYPE_VOID };
1646
1647 ffi_type ffi_type_uint8 = { 1, 1, FFI_TYPE_UINT8 };
1648 ffi_type ffi_type_sint8 = { 1, 1, FFI_TYPE_SINT8 };
1649
1650 ffi_type ffi_type_uint16 = { 2, 2, FFI_TYPE_UINT16 };
1651 ffi_type ffi_type_sint16 = { 2, 2, FFI_TYPE_SINT16 };
1652
1653 ffi_type ffi_type_uint32 = { 4, INT_ALIGN, FFI_TYPE_UINT32 };
1654 ffi_type ffi_type_sint32 = { 4, INT_ALIGN, FFI_TYPE_SINT32 };
1655
1656 ffi_type ffi_type_uint64 = { 8, LONG_LONG_ALIGN, FFI_TYPE_UINT64 };
1657 ffi_type ffi_type_sint64 = { 8, LONG_LONG_ALIGN, FFI_TYPE_SINT64 };
1658
1659 ffi_type ffi_type_float = { sizeof(float), FLOAT_ALIGN, FFI_TYPE_FLOAT };
1660 ffi_type ffi_type_double = { sizeof(double), DOUBLE_ALIGN, FFI_TYPE_DOUBLE };
1661
1662 #ifdef ffi_type_longdouble
1663 #undef ffi_type_longdouble
1664 #endif
1665 /* This is already defined on OSX */
1666 ffi_type ffi_type_longdouble = { sizeof(long double), LONGDOUBLE_ALIGN,
1667 FFI_TYPE_LONGDOUBLE };
1668
1669 ffi_type ffi_type_pointer = { sizeof(void *), VOID_P_ALIGN, FFI_TYPE_POINTER };
1670
1671 /*---------------- EOF ----------------*/
1672