]> granicus.if.org Git - python/commitdiff
[ 1715718 ] x64 clean compile patch for _ctypes, by Kristj?n Valur
authorThomas Heller <theller@ctypes.org>
Fri, 8 Jun 2007 18:20:09 +0000 (18:20 +0000)
committerThomas Heller <theller@ctypes.org>
Fri, 8 Jun 2007 18:20:09 +0000 (18:20 +0000)
with small modifications.

Modules/_ctypes/_ctypes.c
Modules/_ctypes/callbacks.c
Modules/_ctypes/callproc.c
Modules/_ctypes/cfield.c
Modules/_ctypes/ctypes.h
Modules/_ctypes/stgdict.c

index 80a0891ee01a3f306a07a990ee49d8cac6e55eb6..838dcafdca9d93b62bfe2e7ae810fb7e6006434e 100644 (file)
@@ -789,7 +789,7 @@ static int
 CharArray_set_value(CDataObject *self, PyObject *value)
 {
        char *ptr;
-       int size;
+       Py_ssize_t size;
 
        if (PyUnicode_Check(value)) {
                value = PyUnicode_AsEncodedString(value,
@@ -844,7 +844,7 @@ WCharArray_get_value(CDataObject *self)
 static int
 WCharArray_set_value(CDataObject *self, PyObject *value)
 {
-       int result = 0;
+       Py_ssize_t result = 0;
 
        if (PyString_Check(value)) {
                value = PyUnicode_FromEncodedObject(value,
@@ -868,14 +868,12 @@ WCharArray_set_value(CDataObject *self, PyObject *value)
        result = PyUnicode_AsWideChar((PyUnicodeObject *)value,
                                      (wchar_t *)self->b_ptr,
                                      self->b_size/sizeof(wchar_t));
-       if (result >= 0 && (unsigned)result < self->b_size/sizeof(wchar_t))
+       if (result >= 0 && (size_t)result < self->b_size/sizeof(wchar_t))
                ((wchar_t *)self->b_ptr)[result] = (wchar_t)0;
-       if (result > 0)
-               result = 0;
   done:
        Py_DECREF(value);
 
-       return result;
+       return result >= 0 ? 0 : -1;
 }
 
 static PyGetSetDef WCharArray_getsets[] = {
@@ -966,7 +964,7 @@ ArrayType_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
        PyObject *typedict;
        int length;
 
-       int itemsize, itemalign;
+       Py_ssize_t itemsize, itemalign;
 
        typedict = PyTuple_GetItem(args, 2);
        if (!typedict)
@@ -1737,8 +1735,8 @@ static PyObject *
 converters_from_argtypes(PyObject *ob)
 {
        PyObject *converters;
-       int i;
-       int nArgs;
+       Py_ssize_t i;
+       Py_ssize_t nArgs;
 
        ob = PySequence_Tuple(ob); /* new reference */
        if (!ob) {
@@ -2591,18 +2589,18 @@ static PyGetSetDef CFuncPtr_getsets[] = {
 #ifdef MS_WIN32
 static PPROC FindAddress(void *handle, char *name, PyObject *type)
 {
+#ifdef MS_WIN64
+       /* win64 has no stdcall calling conv, so it should
+          also not have the name mangling of it.
+       */
+       return (PPROC)GetProcAddress(handle, name);
+#else
        PPROC address;
        char *mangled_name;
        int i;
        StgDictObject *dict;
 
        address = (PPROC)GetProcAddress(handle, name);
-#ifdef _WIN64
-       /* win64 has no stdcall calling conv, so it should
-          also not have the name mangling of it.
-       */
-       return address;
-#else
        if (address)
                return address;
        if (((size_t)name & ~0xFFFF) == 0) {
@@ -2634,7 +2632,7 @@ static PPROC FindAddress(void *handle, char *name, PyObject *type)
 
 /* Return 1 if usable, 0 else and exception set. */
 static int
-_check_outarg_type(PyObject *arg, int index)
+_check_outarg_type(PyObject *arg, Py_ssize_t index)
 {
        StgDictObject *dict;
 
@@ -2655,7 +2653,7 @@ _check_outarg_type(PyObject *arg, int index)
 
        PyErr_Format(PyExc_TypeError,
                     "'out' parameter %d must be a pointer type, not %s",
-                    index,
+                    Py_SAFE_DOWNCAST(index, Py_ssize_t, int),
                     PyType_Check(arg) ?
                     ((PyTypeObject *)arg)->tp_name :
                     arg->ob_type->tp_name);
@@ -2666,7 +2664,7 @@ _check_outarg_type(PyObject *arg, int index)
 static int
 _validate_paramflags(PyTypeObject *type, PyObject *paramflags)
 {
-       int i, len;
+       Py_ssize_t i, len;
        StgDictObject *dict;
        PyObject *argtypes;
 
@@ -3051,12 +3049,12 @@ _build_callargs(CFuncPtrObject *self, PyObject *argtypes,
        PyObject *paramflags = self->paramflags;
        PyObject *callargs;
        StgDictObject *dict;
-       int i, len;
+       Py_ssize_t i, len;
        int inargs_index = 0;
        /* It's a little bit difficult to determine how many arguments the
        function call requires/accepts.  For simplicity, we count the consumed
        args and compare this to the number of supplied args. */
-       int actual_args;
+       Py_ssize_t actual_args;
 
        *poutmask = 0;
        *pinoutmask = 0;
@@ -3093,7 +3091,7 @@ _build_callargs(CFuncPtrObject *self, PyObject *argtypes,
                /* This way seems to be ~2 us faster than the PyArg_ParseTuple
                   calls below. */
                /* We HAVE already checked that the tuple can be parsed with "i|zO", so... */
-               int tsize = PyTuple_GET_SIZE(item);
+               Py_ssize_t tsize = PyTuple_GET_SIZE(item);
                flag = PyInt_AS_LONG(PyTuple_GET_ITEM(item, 0));
                name = tsize > 1 ? PyString_AS_STRING(PyTuple_GET_ITEM(item, 1)) : NULL;
                defval = tsize > 2 ? PyTuple_GET_ITEM(item, 2) : NULL;
@@ -3339,8 +3337,10 @@ CFuncPtr_call(CFuncPtrObject *self, PyObject *inargs, PyObject *kwds)
                return NULL;
 
        if (converters) {
-               int required = PyTuple_GET_SIZE(converters);
-               int actual = PyTuple_GET_SIZE(callargs);
+               int required = Py_SAFE_DOWNCAST(PyTuple_GET_SIZE(converters),
+                                               Py_ssize_t, int);
+               int actual = Py_SAFE_DOWNCAST(PyTuple_GET_SIZE(callargs),
+                                             Py_ssize_t, int);
 
                if ((dict->flags & FUNCFLAG_CDECL) == FUNCFLAG_CDECL) {
                        /* For cdecl functions, we allow more actual arguments
@@ -3679,8 +3679,8 @@ static PyTypeObject Union_Type = {
 static int
 Array_init(CDataObject *self, PyObject *args, PyObject *kw)
 {
-       int i;
-       int n;
+       Py_ssize_t i;
+       Py_ssize_t n;
 
        if (!PyTuple_Check(args)) {
                PyErr_SetString(PyExc_TypeError,
@@ -3701,7 +3701,7 @@ static PyObject *
 Array_item(PyObject *_self, Py_ssize_t index)
 {
        CDataObject *self = (CDataObject *)_self;
-       int offset, size;
+       Py_ssize_t offset, size;
        StgDictObject *stgdict;
 
 
@@ -3773,7 +3773,7 @@ static int
 Array_ass_item(PyObject *_self, Py_ssize_t index, PyObject *value)
 {
        CDataObject *self = (CDataObject *)_self;
-       int size, offset;
+       Py_ssize_t size, offset;
        StgDictObject *stgdict;
        char *ptr;
 
@@ -3802,7 +3802,7 @@ static int
 Array_ass_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *value)
 {
        CDataObject *self = (CDataObject *)_self;
-       int i, len;
+       Py_ssize_t i, len;
 
        if (value == NULL) {
                PyErr_SetString(PyExc_TypeError,
@@ -4164,7 +4164,7 @@ static PyObject *
 Pointer_item(PyObject *_self, Py_ssize_t index)
 {
        CDataObject *self = (CDataObject *)_self;
-       int size;
+       Py_ssize_t size;
        Py_ssize_t offset;
        StgDictObject *stgdict, *itemdict;
        PyObject *proto;
@@ -4195,7 +4195,7 @@ static int
 Pointer_ass_item(PyObject *_self, Py_ssize_t index, PyObject *value)
 {
        CDataObject *self = (CDataObject *)_self;
-       int size;
+       Py_ssize_t size;
        Py_ssize_t offset;
        StgDictObject *stgdict, *itemdict;
        PyObject *proto;
@@ -4629,9 +4629,10 @@ cast(void *ptr, PyObject *src, PyObject *ctype)
 static PyObject *
 wstring_at(const wchar_t *ptr, int size)
 {
-       if (size == -1)
-               size = wcslen(ptr);
-       return PyUnicode_FromWideChar(ptr, size);
+       Py_ssize_t ssize = size;
+       if (ssize == -1)
+               ssize = wcslen(ptr);
+       return PyUnicode_FromWideChar(ptr, ssize);
 }
 #endif
 
@@ -4831,7 +4832,7 @@ PyObject *My_PyUnicode_FromWideChar(register const wchar_t *w,
     return (PyObject *)unicode;
 }
 
-int My_PyUnicode_AsWideChar(PyUnicodeObject *unicode,
+Py_ssize_t My_PyUnicode_AsWideChar(PyUnicodeObject *unicode,
                            register wchar_t *w,
                            Py_ssize_t size)
 {
index b243361bef74f1a2866a419f043eac2f1a531ee2..c57dc07be2fafdfcc73d108ca7b8a6a71c34f080 100644 (file)
@@ -123,10 +123,10 @@ static void _CallPythonObject(void *mem,
                              PyObject *converters,
                              void **pArgs)
 {
-       int i;
+       Py_ssize_t i;
        PyObject *result;
        PyObject *arglist = NULL;
-       int nArgs;
+       Py_ssize_t nArgs;
 #ifdef WITH_THREAD
        PyGILState_STATE state = PyGILState_Ensure();
 #endif
@@ -264,7 +264,7 @@ ffi_info *AllocFunctionCallback(PyObject *callable,
 {
        int result;
        ffi_info *p;
-       int nArgs, i;
+       Py_ssize_t nArgs, i;
        ffi_abi cc;
 
        nArgs = PySequence_Size(converters);
@@ -307,7 +307,8 @@ ffi_info *AllocFunctionCallback(PyObject *callable,
        if (is_cdecl == 0)
                cc = FFI_STDCALL;
 #endif
-       result = ffi_prep_cif(&p->cif, cc, nArgs,
+       result = ffi_prep_cif(&p->cif, cc,
+                             Py_SAFE_DOWNCAST(nArgs, Py_ssize_t, int),
                              GetType(restype),
                              &p->atypes[0]);
        if (result != FFI_OK) {
index a8d4ce16017f163d38d77b8c92028c7e13f19368..91141e86f8181140410efb6b1426d94d4658132d 100644 (file)
@@ -361,13 +361,13 @@ PyCArg_repr(PyCArgObject *self)
        case 'z':
        case 'Z':
        case 'P':
-               sprintf(buffer, "<cparam '%c' (%08lx)>",
-                       self->tag, (long)self->value.p);
+               sprintf(buffer, "<cparam '%c' (%p)>",
+                       self->tag, self->value.p);
                break;
 
        default:
-               sprintf(buffer, "<cparam '%c' at %08lx>",
-                       self->tag, (long)self);
+               sprintf(buffer, "<cparam '%c' at %p>",
+                       self->tag, self);
                break;
        }
        return PyString_FromString(buffer);
@@ -464,7 +464,7 @@ struct argument {
 /*
  * Convert a single Python object into a PyCArgObject and return it.
  */
-static int ConvParam(PyObject *obj, int index, struct argument *pa)
+static int ConvParam(PyObject *obj, Py_ssize_t index, struct argument *pa)
 {
        StgDictObject *dict;
        pa->keep = NULL; /* so we cannot forget it later */
@@ -572,7 +572,8 @@ static int ConvParam(PyObject *obj, int index, struct argument *pa)
                        return result;
                }
                PyErr_Format(PyExc_TypeError,
-                            "Don't know how to convert parameter %d", index);
+                            "Don't know how to convert parameter %d", 
+                            Py_SAFE_DOWNCAST(index, Py_ssize_t, int));
                return -1;
        }
 }
@@ -912,7 +913,7 @@ PyObject *_CallProc(PPROC pProc,
                    PyObject *restype,
                    PyObject *checker)
 {
-       int i, n, argcount, argtype_count;
+       Py_ssize_t i, n, argcount, argtype_count;
        void *resbuf;
        struct argument *args, *pa;
        ffi_type **atypes;
@@ -1002,7 +1003,10 @@ PyObject *_CallProc(PPROC pProc,
        }
 
        if (-1 == _call_function_pointer(flags, pProc, avalues, atypes,
-                                        rtype, resbuf, argcount))
+                                        rtype, resbuf,
+                                        Py_SAFE_DOWNCAST(argcount,
+                                                         Py_ssize_t,
+                                                         int)))
                goto cleanup;
 
 #ifdef WORDS_BIGENDIAN
@@ -1358,10 +1362,10 @@ sizeof_func(PyObject *self, PyObject *obj)
 
        dict = PyType_stgdict(obj);
        if (dict)
-               return PyInt_FromLong(dict->size);
+               return PyInt_FromSsize_t(dict->size);
 
        if (CDataObject_Check(obj))
-               return PyInt_FromLong(((CDataObject *)obj)->b_size);
+               return PyInt_FromSsize_t(((CDataObject *)obj)->b_size);
        PyErr_SetString(PyExc_TypeError,
                        "this type has no size");
        return NULL;
@@ -1379,11 +1383,11 @@ align_func(PyObject *self, PyObject *obj)
 
        dict = PyType_stgdict(obj);
        if (dict)
-               return PyInt_FromLong(dict->align);
+               return PyInt_FromSsize_t(dict->align);
 
        dict = PyObject_stgdict(obj);
        if (dict)
-               return PyInt_FromLong(dict->align);
+               return PyInt_FromSsize_t(dict->align);
 
        PyErr_SetString(PyExc_TypeError,
                        "no alignment info");
index 6b0a526aca30dd46f3bec13447246d6e7839ed0e..b5f1b8a2111724eebbc8a592ad5b0038ee57d22e 100644 (file)
@@ -35,14 +35,14 @@ CField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  * prev_desc points to the type of the previous bitfield, if any.
  */
 PyObject *
-CField_FromDesc(PyObject *desc, int index,
-               int *pfield_size, int bitsize, int *pbitofs,
-               int *psize, int *poffset, int *palign,
+CField_FromDesc(PyObject *desc, Py_ssize_t index,
+               Py_ssize_t *pfield_size, int bitsize, int *pbitofs,
+               Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,
                int pack, int big_endian)
 {
        CFieldObject *self;
        PyObject *proto;
-       int size, align, length;
+       Py_ssize_t size, align, length;
        SETFUNC setfunc = NULL;
        GETFUNC getfunc = NULL;
        StgDictObject *dict;
@@ -147,7 +147,7 @@ CField_FromDesc(PyObject *desc, int index,
                else
                        align = dict->align;
                if (align && *poffset % align) {
-                       int delta = align - (*poffset % align);
+                       Py_ssize_t delta = align - (*poffset % align);
                        *psize += delta;
                        *poffset += delta;
                }
@@ -268,8 +268,8 @@ static PyObject *
 CField_repr(CFieldObject *self)
 {
        PyObject *result;
-       int bits = self->size >> 16;
-       int size = self->size & 0xFFFF;
+       Py_ssize_t bits = self->size >> 16;
+       Py_ssize_t size = self->size & 0xFFFF;
        const char *name;
 
        name = ((PyTypeObject *)self->proto)->tp_name;
@@ -519,7 +519,7 @@ get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
  */
 
 static PyObject *
-b_set(void *ptr, PyObject *value, unsigned size)
+b_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        if (get_long(value, &val) < 0)
@@ -530,7 +530,7 @@ b_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-b_get(void *ptr, unsigned size)
+b_get(void *ptr, Py_ssize_t size)
 {
        signed char val = *(signed char *)ptr;
        GET_BITFIELD(val, size);
@@ -538,7 +538,7 @@ b_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-B_set(void *ptr, PyObject *value, unsigned size)
+B_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        if (get_ulong(value, &val) < 0)
@@ -550,7 +550,7 @@ B_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-B_get(void *ptr, unsigned size)
+B_get(void *ptr, Py_ssize_t size)
 {
        unsigned char val = *(unsigned char *)ptr;
        GET_BITFIELD(val, size);
@@ -558,7 +558,7 @@ B_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-h_set(void *ptr, PyObject *value, unsigned size)
+h_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        short x;
@@ -572,7 +572,7 @@ h_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-h_set_sw(void *ptr, PyObject *value, unsigned size)
+h_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        short field;
@@ -587,7 +587,7 @@ h_set_sw(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-h_get(void *ptr, unsigned size)
+h_get(void *ptr, Py_ssize_t size)
 {
        short val;
        memcpy(&val, ptr, sizeof(val));
@@ -596,7 +596,7 @@ h_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-h_get_sw(void *ptr, unsigned size)
+h_get_sw(void *ptr, Py_ssize_t size)
 {
        short val;
        memcpy(&val, ptr, sizeof(val));
@@ -606,7 +606,7 @@ h_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-H_set(void *ptr, PyObject *value, unsigned size)
+H_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned short x;
@@ -619,7 +619,7 @@ H_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-H_set_sw(void *ptr, PyObject *value, unsigned size)
+H_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned short field;
@@ -635,7 +635,7 @@ H_set_sw(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-H_get(void *ptr, unsigned size)
+H_get(void *ptr, Py_ssize_t size)
 {
        unsigned short val;
        memcpy(&val, ptr, sizeof(val));
@@ -644,7 +644,7 @@ H_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-H_get_sw(void *ptr, unsigned size)
+H_get_sw(void *ptr, Py_ssize_t size)
 {
        unsigned short val;
        memcpy(&val, ptr, sizeof(val));
@@ -654,7 +654,7 @@ H_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-i_set(void *ptr, PyObject *value, unsigned size)
+i_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        int x;
@@ -667,7 +667,7 @@ i_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-i_set_sw(void *ptr, PyObject *value, unsigned size)
+i_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        int field;
@@ -683,7 +683,7 @@ i_set_sw(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-i_get(void *ptr, unsigned size)
+i_get(void *ptr, Py_ssize_t size)
 {
        int val;
        memcpy(&val, ptr, sizeof(val));
@@ -692,7 +692,7 @@ i_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-i_get_sw(void *ptr, unsigned size)
+i_get_sw(void *ptr, Py_ssize_t size)
 {
        int val;
        memcpy(&val, ptr, sizeof(val));
@@ -704,7 +704,7 @@ i_get_sw(void *ptr, unsigned size)
 #ifdef MS_WIN32
 /* short BOOL - VARIANT_BOOL */
 static PyObject *
-vBOOL_set(void *ptr, PyObject *value, unsigned size)
+vBOOL_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        switch (PyObject_IsTrue(value)) {
        case -1:
@@ -719,7 +719,7 @@ vBOOL_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-vBOOL_get(void *ptr, unsigned size)
+vBOOL_get(void *ptr, Py_ssize_t size)
 {
        return PyBool_FromLong((long)*(short int *)ptr);
 }
@@ -734,7 +734,7 @@ vBOOL_get(void *ptr, unsigned size)
 #endif
 
 static PyObject *
-t_set(void *ptr, PyObject *value, unsigned size)
+t_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        switch (PyObject_IsTrue(value)) {
        case -1:
@@ -749,13 +749,13 @@ t_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-t_get(void *ptr, unsigned size)
+t_get(void *ptr, Py_ssize_t size)
 {
        return PyBool_FromLong((long)*(BOOL_TYPE *)ptr);
 }
 
 static PyObject *
-I_set(void *ptr, PyObject *value, unsigned size)
+I_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned int x;
@@ -768,7 +768,7 @@ I_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-I_set_sw(void *ptr, PyObject *value, unsigned size)
+I_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned int field;
@@ -783,7 +783,7 @@ I_set_sw(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-I_get(void *ptr, unsigned size)
+I_get(void *ptr, Py_ssize_t size)
 {
        unsigned int val;
        memcpy(&val, ptr, sizeof(val));
@@ -792,7 +792,7 @@ I_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-I_get_sw(void *ptr, unsigned size)
+I_get_sw(void *ptr, Py_ssize_t size)
 {
        unsigned int val;
        memcpy(&val, ptr, sizeof(val));
@@ -802,7 +802,7 @@ I_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-l_set(void *ptr, PyObject *value, unsigned size)
+l_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        long x;
@@ -815,7 +815,7 @@ l_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-l_set_sw(void *ptr, PyObject *value, unsigned size)
+l_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        long val;
        long field;
@@ -831,7 +831,7 @@ l_set_sw(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-l_get(void *ptr, unsigned size)
+l_get(void *ptr, Py_ssize_t size)
 {
        long val;
        memcpy(&val, ptr, sizeof(val));
@@ -840,7 +840,7 @@ l_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-l_get_sw(void *ptr, unsigned size)
+l_get_sw(void *ptr, Py_ssize_t size)
 {
        long val;
        memcpy(&val, ptr, sizeof(val));
@@ -850,7 +850,7 @@ l_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-L_set(void *ptr, PyObject *value, unsigned size)
+L_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned long x;
@@ -863,7 +863,7 @@ L_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-L_set_sw(void *ptr, PyObject *value, unsigned size)
+L_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned long val;
        unsigned long field;
@@ -879,7 +879,7 @@ L_set_sw(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-L_get(void *ptr, unsigned size)
+L_get(void *ptr, Py_ssize_t size)
 {
        unsigned long val;
        memcpy(&val, ptr, sizeof(val));
@@ -888,7 +888,7 @@ L_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-L_get_sw(void *ptr, unsigned size)
+L_get_sw(void *ptr, Py_ssize_t size)
 {
        unsigned long val;
        memcpy(&val, ptr, sizeof(val));
@@ -899,7 +899,7 @@ L_get_sw(void *ptr, unsigned size)
 
 #ifdef HAVE_LONG_LONG
 static PyObject *
-q_set(void *ptr, PyObject *value, unsigned size)
+q_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        PY_LONG_LONG val;
        PY_LONG_LONG x;
@@ -912,7 +912,7 @@ q_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-q_set_sw(void *ptr, PyObject *value, unsigned size)
+q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        PY_LONG_LONG val;
        PY_LONG_LONG field;
@@ -927,7 +927,7 @@ q_set_sw(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-q_get(void *ptr, unsigned size)
+q_get(void *ptr, Py_ssize_t size)
 {
        PY_LONG_LONG val;
        memcpy(&val, ptr, sizeof(val));
@@ -936,7 +936,7 @@ q_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-q_get_sw(void *ptr, unsigned size)
+q_get_sw(void *ptr, Py_ssize_t size)
 {
        PY_LONG_LONG val;
        memcpy(&val, ptr, sizeof(val));
@@ -946,7 +946,7 @@ q_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-Q_set(void *ptr, PyObject *value, unsigned size)
+Q_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned PY_LONG_LONG val;
        unsigned PY_LONG_LONG x;
@@ -959,7 +959,7 @@ Q_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-Q_set_sw(void *ptr, PyObject *value, unsigned size)
+Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        unsigned PY_LONG_LONG val;
        unsigned PY_LONG_LONG field;
@@ -974,7 +974,7 @@ Q_set_sw(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-Q_get(void *ptr, unsigned size)
+Q_get(void *ptr, Py_ssize_t size)
 {
        unsigned PY_LONG_LONG val;
        memcpy(&val, ptr, sizeof(val));
@@ -983,7 +983,7 @@ Q_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-Q_get_sw(void *ptr, unsigned size)
+Q_get_sw(void *ptr, Py_ssize_t size)
 {
        unsigned PY_LONG_LONG val;
        memcpy(&val, ptr, sizeof(val));
@@ -1000,7 +1000,7 @@ Q_get_sw(void *ptr, unsigned size)
 
 
 static PyObject *
-d_set(void *ptr, PyObject *value, unsigned size)
+d_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        double x;
 
@@ -1016,7 +1016,7 @@ d_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-d_get(void *ptr, unsigned size)
+d_get(void *ptr, Py_ssize_t size)
 {
        double val;
        memcpy(&val, ptr, sizeof(val));
@@ -1024,7 +1024,7 @@ d_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-d_set_sw(void *ptr, PyObject *value, unsigned size)
+d_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        double x;
 
@@ -1046,7 +1046,7 @@ d_set_sw(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-d_get_sw(void *ptr, unsigned size)
+d_get_sw(void *ptr, Py_ssize_t size)
 {
 #ifdef WORDS_BIGENDIAN
        return PyFloat_FromDouble(_PyFloat_Unpack8(ptr, 1));
@@ -1056,7 +1056,7 @@ d_get_sw(void *ptr, unsigned size)
 }
 
 static PyObject *
-f_set(void *ptr, PyObject *value, unsigned size)
+f_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        float x;
 
@@ -1072,7 +1072,7 @@ f_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-f_get(void *ptr, unsigned size)
+f_get(void *ptr, Py_ssize_t size)
 {
        float val;
        memcpy(&val, ptr, sizeof(val));
@@ -1080,7 +1080,7 @@ f_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-f_set_sw(void *ptr, PyObject *value, unsigned size)
+f_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
 {
        float x;
 
@@ -1102,7 +1102,7 @@ f_set_sw(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-f_get_sw(void *ptr, unsigned size)
+f_get_sw(void *ptr, Py_ssize_t size)
 {
 #ifdef WORDS_BIGENDIAN
        return PyFloat_FromDouble(_PyFloat_Unpack4(ptr, 1));
@@ -1122,7 +1122,7 @@ f_get_sw(void *ptr, unsigned size)
   Py_DECREF on destruction.  Maybe only when b_needsfree is non-zero.
 */
 static PyObject *
-O_get(void *ptr, unsigned size)
+O_get(void *ptr, Py_ssize_t size)
 {
        PyObject *ob = *(PyObject **)ptr;
        if (ob == NULL) {
@@ -1137,7 +1137,7 @@ O_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-O_set(void *ptr, PyObject *value, unsigned size)
+O_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        /* Hm, does the memory block need it's own refcount or not? */
        *(PyObject **)ptr = value;
@@ -1147,7 +1147,7 @@ O_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-c_set(void *ptr, PyObject *value, unsigned size)
+c_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        if (!PyString_Check(value) || (1 != PyString_Size(value))) {
                PyErr_Format(PyExc_TypeError,
@@ -1160,7 +1160,7 @@ c_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-c_get(void *ptr, unsigned size)
+c_get(void *ptr, Py_ssize_t size)
 {
        return PyString_FromStringAndSize((char *)ptr, 1);
 }
@@ -1168,9 +1168,9 @@ c_get(void *ptr, unsigned size)
 #ifdef CTYPES_UNICODE
 /* u - a single wchar_t character */
 static PyObject *
-u_set(void *ptr, PyObject *value, unsigned size)
+u_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
-       int len;
+       Py_ssize_t len;
 
        if (PyString_Check(value)) {
                value = PyUnicode_FromEncodedObject(value,
@@ -1202,17 +1202,17 @@ u_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-u_get(void *ptr, unsigned size)
+u_get(void *ptr, Py_ssize_t size)
 {
        return PyUnicode_FromWideChar((wchar_t *)ptr, 1);
 }
 
 /* U - a unicode string */
 static PyObject *
-U_get(void *ptr, unsigned size)
+U_get(void *ptr, Py_ssize_t size)
 {
        PyObject *result;
-       unsigned int len;
+       Py_ssize_t len;
        Py_UNICODE *p;
 
        size /= sizeof(wchar_t); /* we count character units here, not bytes */
@@ -1240,9 +1240,9 @@ U_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-U_set(void *ptr, PyObject *value, unsigned length)
+U_set(void *ptr, PyObject *value, Py_ssize_t length)
 {
-       unsigned int size;
+       Py_ssize_t size;
 
        /* It's easier to calculate in characters than in bytes */
        length /= sizeof(wchar_t);
@@ -1277,9 +1277,10 @@ U_set(void *ptr, PyObject *value, unsigned length)
 #endif
 
 static PyObject *
-s_get(void *ptr, unsigned size)
+s_get(void *ptr, Py_ssize_t size)
 {
        PyObject *result;
+       size_t slen;
 
        result = PyString_FromString((char *)ptr);
        if (!result)
@@ -1287,7 +1288,8 @@ s_get(void *ptr, unsigned size)
        /* chop off at the first NUL character, if any.
         * On error, result will be deallocated and set to NULL.
         */
-       size = min(size, strlen(PyString_AS_STRING(result)));
+       slen = strlen(PyString_AS_STRING(result));
+       size = min(size, (Py_ssize_t)slen);
        if (result->ob_refcnt == 1) {
                /* shorten the result */
                _PyString_Resize(&result, size);
@@ -1298,10 +1300,10 @@ s_get(void *ptr, unsigned size)
 }
 
 static PyObject *
-s_set(void *ptr, PyObject *value, unsigned length)
+s_set(void *ptr, PyObject *value, Py_ssize_t length)
 {
        char *data;
-       unsigned size;
+       Py_ssize_t size;
 
        data = PyString_AsString(value);
        if (!data)
@@ -1324,7 +1326,7 @@ s_set(void *ptr, PyObject *value, unsigned length)
 }
 
 static PyObject *
-z_set(void *ptr, PyObject *value, unsigned size)
+z_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        if (value == Py_None) {
                *(char **)ptr = NULL;
@@ -1358,7 +1360,7 @@ z_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-z_get(void *ptr, unsigned size)
+z_get(void *ptr, Py_ssize_t size)
 {
        /* XXX What about invalid pointers ??? */
        if (*(void **)ptr) {
@@ -1379,7 +1381,7 @@ z_get(void *ptr, unsigned size)
 
 #ifdef CTYPES_UNICODE
 static PyObject *
-Z_set(void *ptr, PyObject *value, unsigned size)
+Z_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        if (value == Py_None) {
                *(wchar_t **)ptr = NULL;
@@ -1447,7 +1449,7 @@ Z_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-Z_get(void *ptr, unsigned size)
+Z_get(void *ptr, Py_ssize_t size)
 {
        wchar_t *p;
        p = *(wchar_t **)ptr;
@@ -1470,7 +1472,7 @@ Z_get(void *ptr, unsigned size)
 
 #ifdef MS_WIN32
 static PyObject *
-BSTR_set(void *ptr, PyObject *value, unsigned size)
+BSTR_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        BSTR bstr;
 
@@ -1494,8 +1496,13 @@ BSTR_set(void *ptr, PyObject *value, unsigned size)
 
        /* create a BSTR from value */
        if (value) {
+               Py_ssize_t size = PyUnicode_GET_SIZE(value);
+               if ((unsigned) size != size) {
+                       PyErr_SetString(PyExc_ValueError, "String too long for BSTR");
+                       return NULL;
+               }
                bstr = SysAllocStringLen(PyUnicode_AS_UNICODE(value),
-                                        PyUnicode_GET_SIZE(value));
+                                        (unsigned)size);
                Py_DECREF(value);
        } else
                bstr = NULL;
@@ -1513,7 +1520,7 @@ BSTR_set(void *ptr, PyObject *value, unsigned size)
 
 
 static PyObject *
-BSTR_get(void *ptr, unsigned size)
+BSTR_get(void *ptr, Py_ssize_t size)
 {
        BSTR p;
        p = *(BSTR *)ptr;
@@ -1530,7 +1537,7 @@ BSTR_get(void *ptr, unsigned size)
 #endif
 
 static PyObject *
-P_set(void *ptr, PyObject *value, unsigned size)
+P_set(void *ptr, PyObject *value, Py_ssize_t size)
 {
        void *v;
        if (value == Py_None) {
@@ -1563,7 +1570,7 @@ P_set(void *ptr, PyObject *value, unsigned size)
 }
 
 static PyObject *
-P_get(void *ptr, unsigned size)
+P_get(void *ptr, Py_ssize_t size)
 {
        if (*(void **)ptr == NULL) {
                Py_INCREF(Py_None);
index 5fb603075d3363606872c1088e79c8469d880b97..f1c174a15d06171f45695ef058fa4228319cce11 100644 (file)
@@ -4,6 +4,7 @@
 
 #if (PY_VERSION_HEX < 0x02050000)
 typedef int Py_ssize_t;
+#define PyInt_FromSsize_t PyInt_FromLong
 #endif
 
 #ifndef MS_WIN32
@@ -31,8 +32,8 @@ typedef int Py_ssize_t;
 
 typedef struct tagPyCArgObject PyCArgObject;
 typedef struct tagCDataObject CDataObject;
-typedef PyObject *(* GETFUNC)(void *, unsigned size);
-typedef PyObject *(* SETFUNC)(void *, PyObject *value, unsigned size);
+typedef PyObject *(* GETFUNC)(void *, Py_ssize_t size);
+typedef PyObject *(* SETFUNC)(void *, PyObject *value, Py_ssize_t size);
 typedef PyCArgObject *(* PARAMFUNC)(CDataObject *obj);
 
 /* A default buffer in CDataObject, which can be used for small C types.  If
@@ -137,9 +138,9 @@ extern struct fielddesc *getentry(char *fmt);
 
 
 extern PyObject *
-CField_FromDesc(PyObject *desc, int index,
-               int *pfield_size, int bitsize, int *pbitofs,
-               int *psize, int *poffset, int *palign,
+CField_FromDesc(PyObject *desc, Py_ssize_t index,
+               Py_ssize_t *pfield_size, int bitsize, int *pbitofs,
+               Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,
                int pack, int is_big_endian);
 
 extern PyObject *CData_AtAddress(PyObject *type, void *buf);
@@ -310,7 +311,7 @@ struct tagPyCArgObject {
                void *p;
        } value;
        PyObject *obj;
-       int size; /* for the 'V' tag */
+       Py_ssize_t size; /* for the 'V' tag */
 };
 
 extern PyTypeObject PyCArg_Type;
@@ -387,7 +388,7 @@ extern char *conversion_mode_errors;
 #  define PyUnicode_AsWideChar My_PyUnicode_AsWideChar
 
 extern PyObject *My_PyUnicode_FromWideChar(const wchar_t *, Py_ssize_t);
-extern int My_PyUnicode_AsWideChar(PyUnicodeObject *, wchar_t *, Py_ssize_t);
+extern Py_ssize_t My_PyUnicode_AsWideChar(PyUnicodeObject *, wchar_t *, Py_ssize_t);
 
 #endif
 
index 5651d6260a52ffa46933a92557b28a0520169cc7..5815fea81e2928b0c55645973edaa269ff8d9d0e 100644 (file)
@@ -50,7 +50,7 @@ int
 StgDict_clone(StgDictObject *dst, StgDictObject *src)
 {
        char *d, *s;
-       int size;
+       Py_ssize_t size;
 
        StgDict_clear(dst);
        PyMem_Free(dst->ffi_type_pointer.elements);
@@ -289,13 +289,13 @@ int
 StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
 {
        StgDictObject *stgdict, *basedict;
-       int len, offset, size, align, i;
-       int union_size, total_align;
-       int field_size = 0;
+       Py_ssize_t len, offset, size, align, i;
+       Py_ssize_t union_size, total_align;
+       Py_ssize_t field_size = 0;
        int bitofs;
        PyObject *isPacked;
        int pack = 0;
-       int ffi_ofs;
+       Py_ssize_t ffi_ofs;
        int big_endian;
 
        /* HACK Alert: I cannot be bothered to fix ctypes.com, so there has to
@@ -484,7 +484,9 @@ StructUnionType_update_stgdict(PyObject *type, PyObject *fields, int isStruct)
        /* Adjust the size according to the alignment requirements */
        size = ((size + total_align - 1) / total_align) * total_align;
 
-       stgdict->ffi_type_pointer.alignment = total_align;
+       stgdict->ffi_type_pointer.alignment = Py_SAFE_DOWNCAST(total_align,
+                                                              Py_ssize_t,
+                                                              unsigned short);
        stgdict->ffi_type_pointer.size = size;
 
        stgdict->size = size;