Modules/_ctypes/cfield.c

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