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