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