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