CharArray_set_value(CDataObject *self, PyObject *value)
{
char *ptr;
- int size;
+ Py_ssize_t size;
if (PyUnicode_Check(value)) {
value = PyUnicode_AsEncodedString(value,
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,
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[] = {
PyObject *typedict;
int length;
- int itemsize, itemalign;
+ Py_ssize_t itemsize, itemalign;
typedict = PyTuple_GetItem(args, 2);
if (!typedict)
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) {
#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) {
/* 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;
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);
static int
_validate_paramflags(PyTypeObject *type, PyObject *paramflags)
{
- int i, len;
+ Py_ssize_t i, len;
StgDictObject *dict;
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;
/* 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;
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
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,
Array_item(PyObject *_self, Py_ssize_t index)
{
CDataObject *self = (CDataObject *)_self;
- int offset, size;
+ Py_ssize_t offset, size;
StgDictObject *stgdict;
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;
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,
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;
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;
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
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)
{
* 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;
else
align = dict->align;
if (align && *poffset % align) {
- int delta = align - (*poffset % align);
+ Py_ssize_t delta = align - (*poffset % align);
*psize += delta;
*poffset += delta;
}
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;
*/
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)
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);
}
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)
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);
}
static PyObject *
-h_set(void *ptr, PyObject *value, unsigned size)
+h_set(void *ptr, PyObject *value, Py_ssize_t size)
{
long val;
short x;
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;
}
static PyObject *
-h_get(void *ptr, unsigned size)
+h_get(void *ptr, Py_ssize_t size)
{
short val;
memcpy(&val, ptr, sizeof(val));
}
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));
}
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;
}
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;
static PyObject *
-H_get(void *ptr, unsigned size)
+H_get(void *ptr, Py_ssize_t size)
{
unsigned short val;
memcpy(&val, ptr, sizeof(val));
}
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));
}
static PyObject *
-i_set(void *ptr, PyObject *value, unsigned size)
+i_set(void *ptr, PyObject *value, Py_ssize_t size)
{
long val;
int x;
}
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;
static PyObject *
-i_get(void *ptr, unsigned size)
+i_get(void *ptr, Py_ssize_t size)
{
int val;
memcpy(&val, ptr, sizeof(val));
}
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));
#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:
}
static PyObject *
-vBOOL_get(void *ptr, unsigned size)
+vBOOL_get(void *ptr, Py_ssize_t size)
{
return PyBool_FromLong((long)*(short int *)ptr);
}
#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:
}
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;
}
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;
static PyObject *
-I_get(void *ptr, unsigned size)
+I_get(void *ptr, Py_ssize_t size)
{
unsigned int val;
memcpy(&val, ptr, sizeof(val));
}
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));
}
static PyObject *
-l_set(void *ptr, PyObject *value, unsigned size)
+l_set(void *ptr, PyObject *value, Py_ssize_t size)
{
long val;
long x;
}
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;
static PyObject *
-l_get(void *ptr, unsigned size)
+l_get(void *ptr, Py_ssize_t size)
{
long val;
memcpy(&val, ptr, sizeof(val));
}
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));
}
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;
}
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;
static PyObject *
-L_get(void *ptr, unsigned size)
+L_get(void *ptr, Py_ssize_t size)
{
unsigned long val;
memcpy(&val, ptr, sizeof(val));
}
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));
#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;
}
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;
}
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));
}
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));
}
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;
}
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;
}
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));
}
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));
static PyObject *
-d_set(void *ptr, PyObject *value, unsigned size)
+d_set(void *ptr, PyObject *value, Py_ssize_t size)
{
double x;
}
static PyObject *
-d_get(void *ptr, unsigned size)
+d_get(void *ptr, Py_ssize_t size)
{
double val;
memcpy(&val, ptr, sizeof(val));
}
static PyObject *
-d_set_sw(void *ptr, PyObject *value, unsigned size)
+d_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
double x;
}
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));
}
static PyObject *
-f_set(void *ptr, PyObject *value, unsigned size)
+f_set(void *ptr, PyObject *value, Py_ssize_t size)
{
float x;
}
static PyObject *
-f_get(void *ptr, unsigned size)
+f_get(void *ptr, Py_ssize_t size)
{
float val;
memcpy(&val, ptr, sizeof(val));
}
static PyObject *
-f_set_sw(void *ptr, PyObject *value, unsigned size)
+f_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
float x;
}
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));
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) {
}
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;
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,
static PyObject *
-c_get(void *ptr, unsigned size)
+c_get(void *ptr, Py_ssize_t size)
{
return PyString_FromStringAndSize((char *)ptr, 1);
}
#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,
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 */
}
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);
#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)
/* 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);
}
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)
}
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;
}
static PyObject *
-z_get(void *ptr, unsigned size)
+z_get(void *ptr, Py_ssize_t size)
{
/* XXX What about invalid pointers ??? */
if (*(void **)ptr) {
#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;
}
static PyObject *
-Z_get(void *ptr, unsigned size)
+Z_get(void *ptr, Py_ssize_t size)
{
wchar_t *p;
p = *(wchar_t **)ptr;
#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;
/* 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;
static PyObject *
-BSTR_get(void *ptr, unsigned size)
+BSTR_get(void *ptr, Py_ssize_t size)
{
BSTR p;
p = *(BSTR *)ptr;
#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) {
}
static PyObject *
-P_get(void *ptr, unsigned size)
+P_get(void *ptr, Py_ssize_t size)
{
if (*(void **)ptr == NULL) {
Py_INCREF(Py_None);
projects / python / commitdiff