/Modules/_ctypes/cfield.c

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