LCOV - code coverage report
Current view: | top level - Modules/_ctypes - cfield.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 38 | 634 | 6.0 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 2 | 82 | 2.4 %
|  |  | Branches: | 30 | 329 | 9.1 %

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

Generated by: LCOV version 1.14