static PyObject *
P_set(void *ptr, PyObject *value, Py_ssize_t size)
{
void *v;
if (value == Py_None) {
*(void **)ptr = NULL;
_RET(value);
}
if (!PyLong_Check(value) && !PyLong_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"cannot be converted to pointer");
return NULL;
}
#if SIZEOF_VOID_P <= SIZEOF_LONG
v = (void *)PyLong_AsUnsignedLongMask(value);
#else
#ifndef HAVE_LONG_LONG
# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
#elif SIZEOF_LONG_LONG < SIZEOF_VOID_P
# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
#endif
v = (void *)PyLong_AsUnsignedLongLongMask(value);
#endif
if (PyErr_Occurred())
return NULL;
*(void **)ptr = v;
_RET(value);
}
static PyObject *
z_set(void *ptr, PyObject *value, Py_ssize_t size)
{
if (value == Py_None) {
*(char **)ptr = NULL;
Py_INCREF(value);
return value;
}
if (PyBytes_Check(value)) {
*(char **)ptr = PyBytes_AsString(value);
Py_INCREF(value);
return value;
} else if (PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
*(char **)ptr = (char *)PyLong_AsUnsignedLongLongMask(value);
#else
*(char **)ptr = (char *)PyLong_AsUnsignedLongMask(value);
#endif
_RET(value);
}
PyErr_Format(PyExc_TypeError,
"string or integer address expected instead of %s instance",
value->ob_type->tp_name);
return NULL;
}
static PyObject *
fs_dir_iterate (Filesystem *self,
PyObject *args,
PyObject *kwargs)
{
errcode_t ret;
WalkData wdata;
PyObject *py_func, *py_data = NULL, *py_dir = NULL;
uint64_t dir;
int flags = OCFS2_DIRENT_FLAG_EXCLUDE_DOTS;
static char *kwlist[] = { "callback", "data", "dir", "flags", NULL };
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O|OOi:dir_iterate", kwlist,
&py_func, &py_data, &py_dir, &flags))
return NULL;
if (!PyCallable_Check (py_func))
{
PyErr_SetString (PyExc_TypeError, "callback must be a callable object");
return NULL;
}
if (py_dir == NULL || py_dir == Py_None)
dir = self->fs->fs_root_blkno;
else if (DirEntry_Check (py_dir))
dir = ((DirEntry *) py_dir)->dentry.inode;
else if (PyInt_Check (py_dir))
dir = PyInt_AsUnsignedLongMask (py_dir);
else if (PyLong_Check (py_dir))
dir = PyLong_AsUnsignedLongLongMask (py_dir);
else
{
PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer");
return NULL;
}
Py_INCREF (py_func);
wdata.func = py_func;
Py_XINCREF (py_data);
wdata.data = py_data;
wdata.fs = self;
/* XXX: handle errors */
ret = ocfs2_dir_iterate (self->fs, dir, flags, NULL, walk_dirs, &wdata);
Py_DECREF (py_func);
Py_XDECREF (py_data);
Py_INCREF (Py_None);
return Py_None;
}
static PyObject *
Z_set(void *ptr, PyObject *value, Py_ssize_t size)
{
if (value == Py_None) {
*(wchar_t **)ptr = NULL;
Py_INCREF(value);
return value;
}
if (PyLong_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value);
#else
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value);
#endif
Py_INCREF(Py_None);
return Py_None;
}
if (!PyUnicode_Check(value)) {
PyErr_Format(PyExc_TypeError,
"unicode string or integer address expected instead of %s instance",
value->ob_type->tp_name);
return NULL;
} else
Py_INCREF(value);
#if Py_UNICODE_SIZE == SIZEOF_WCHAR_T
/* We can copy directly. Hm, are unicode objects always NUL
terminated in Python, internally?
*/
*(wchar_t **)ptr = (wchar_t *) PyUnicode_AS_UNICODE(value);
return value;
#else
{
/* We must create a wchar_t* buffer from the unicode object,
and keep it alive */
PyObject *keep;
wchar_t *buffer;
buffer = PyUnicode_AsWideCharString(value, NULL);
if (!buffer) {
Py_DECREF(value);
return NULL;
}
keep = PyCapsule_New(buffer, CTYPES_CFIELD_CAPSULE_NAME_PYMEM, pymem_destructor);
if (!keep) {
Py_DECREF(value);
PyMem_Free(buffer);
return NULL;
}
*(wchar_t **)ptr = (wchar_t *)buffer;
Py_DECREF(value);
return keep;
}
#endif
}
static int
get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
{
unsigned PY_LONG_LONG x;
if (PyFloat_Check(v)) {
PyErr_SetString(PyExc_TypeError,
"int expected instead of float");
return -1;
}
x = PyLong_AsUnsignedLongLongMask(v);
if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())
return -1;
*p = x;
return 0;
}
static PyObject *
Z_set(void *ptr, PyObject *value, Py_ssize_t size)
{
PyObject *keep;
wchar_t *buffer;
if (value == Py_None) {
*(wchar_t **)ptr = NULL;
Py_INCREF(value);
return value;
}
if (PyLong_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value);
#else
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value);
#endif
Py_INCREF(Py_None);
return Py_None;
}
if (!PyUnicode_Check(value)) {
PyErr_Format(PyExc_TypeError,
"unicode string or integer address expected instead of %s instance",
value->ob_type->tp_name);
return NULL;
}
/* We must create a wchar_t* buffer from the unicode object,
and keep it alive */
buffer = PyUnicode_AsWideCharString(value, NULL);
if (!buffer)
return NULL;
keep = PyCapsule_New(buffer, CTYPES_CFIELD_CAPSULE_NAME_PYMEM, pymem_destructor);
if (!keep) {
PyMem_Free(buffer);
return NULL;
}
*(wchar_t **)ptr = buffer;
return keep;
}
static PyObject *
fs_dir_scan (Filesystem *self,
PyObject *args,
PyObject *kwargs)
{
errcode_t ret;
PyObject *py_dir = NULL;
uint64_t dir;
int flags = OCFS2_DIR_SCAN_FLAG_EXCLUDE_DOTS;
ocfs2_dir_scan *scan;
static char *kwlist[] = { "dir", "flags", NULL };
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"|Oi:dir_scan", kwlist,
&py_dir, &flags))
return NULL;
if (py_dir == NULL || py_dir == Py_None)
dir = self->fs->fs_root_blkno;
else if (DirEntry_Check (py_dir))
dir = ((DirEntry *) py_dir)->dentry.inode;
else if (PyInt_Check (py_dir))
dir = PyInt_AsUnsignedLongMask (py_dir);
else if (PyLong_Check (py_dir))
dir = PyLong_AsUnsignedLongLongMask (py_dir);
else
{
PyErr_SetString (PyExc_TypeError, "dir must be DirEntry or integer");
return NULL;
}
CHECK_ERROR (ocfs2_open_dir_scan (self->fs, dir, flags, &scan));
return dir_scan_iter_new (self, scan);
}
static int ffiobj_init(PyObject *self, PyObject *args, PyObject *kwds)
{
FFIObject *ffi;
static char *keywords[] = {"module_name", "_version", "_types",
"_globals", "_struct_unions", "_enums",
"_typenames", "_includes", NULL};
char *ffiname = "?", *types = NULL, *building = NULL;
Py_ssize_t version = -1;
Py_ssize_t types_len = 0;
PyObject *globals = NULL, *struct_unions = NULL, *enums = NULL;
PyObject *typenames = NULL, *includes = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"|sns#O!O!O!O!O!:FFI", keywords,
&ffiname, &version, &types, &types_len,
&PyTuple_Type, &globals,
&PyTuple_Type, &struct_unions,
&PyTuple_Type, &enums,
&PyTuple_Type, &typenames,
&PyTuple_Type, &includes))
return -1;
ffi = (FFIObject *)self;
if (ffi->ctx_is_nonempty) {
PyErr_SetString(PyExc_ValueError,
"cannot call FFI.__init__() more than once");
return -1;
}
ffi->ctx_is_nonempty = 1;
if (version == -1 && types_len == 0)
return 0;
if (version < CFFI_VERSION_MIN || version > CFFI_VERSION_MAX) {
PyErr_Format(PyExc_ImportError,
"cffi out-of-line Python module '%s' has unknown "
"version %p", ffiname, (void *)version);
return -1;
}
if (types_len > 0) {
/* unpack a string of 4-byte entries into an array of _cffi_opcode_t */
_cffi_opcode_t *ntypes;
Py_ssize_t i, n = types_len / 4;
building = PyMem_Malloc(n * sizeof(_cffi_opcode_t));
if (building == NULL)
goto error;
ntypes = (_cffi_opcode_t *)building;
for (i = 0; i < n; i++) {
ntypes[i] = cdl_opcode(types);
types += 4;
}
ffi->types_builder.ctx.types = ntypes;
ffi->types_builder.ctx.num_types = n;
building = NULL;
}
if (globals != NULL) {
/* unpack a tuple alternating strings and ints, each two together
describing one global_s entry with no specified address or size.
The int is only used with integer constants. */
struct _cffi_global_s *nglobs;
cdl_intconst_t *nintconsts;
Py_ssize_t i, n = PyTuple_GET_SIZE(globals) / 2;
i = n * (sizeof(struct _cffi_global_s) + sizeof(cdl_intconst_t));
building = PyMem_Malloc(i);
if (building == NULL)
goto error;
memset(building, 0, i);
nglobs = (struct _cffi_global_s *)building;
nintconsts = (cdl_intconst_t *)(nglobs + n);
for (i = 0; i < n; i++) {
char *g = PyBytes_AS_STRING(PyTuple_GET_ITEM(globals, i * 2));
nglobs[i].type_op = cdl_opcode(g); g += 4;
nglobs[i].name = g;
if (_CFFI_GETOP(nglobs[i].type_op) == _CFFI_OP_CONSTANT_INT ||
_CFFI_GETOP(nglobs[i].type_op) == _CFFI_OP_ENUM) {
PyObject *o = PyTuple_GET_ITEM(globals, i * 2 + 1);
nglobs[i].address = &_cdl_realize_global_int;
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(o)) {
nintconsts[i].neg = PyInt_AS_LONG(o) <= 0;
nintconsts[i].value = (long long)PyInt_AS_LONG(o);
}
else
#endif
{
nintconsts[i].neg = PyObject_RichCompareBool(o, Py_False,
Py_LE);
nintconsts[i].value = PyLong_AsUnsignedLongLongMask(o);
if (PyErr_Occurred())
goto error;
}
}
}
ffi->types_builder.ctx.globals = nglobs;
ffi->types_builder.ctx.num_globals = n;
building = NULL;
}
if (struct_unions != NULL) {
/* unpack a tuple of struct/unions, each described as a sub-tuple;
the item 0 of each sub-tuple describes the struct/union, and
the items 1..N-1 describe the fields, if any */
struct _cffi_struct_union_s *nstructs;
struct _cffi_field_s *nfields;
Py_ssize_t i, n = PyTuple_GET_SIZE(struct_unions);
Py_ssize_t nf = 0; /* total number of fields */
for (i = 0; i < n; i++) {
nf += PyTuple_GET_SIZE(PyTuple_GET_ITEM(struct_unions, i)) - 1;
}
i = (n * sizeof(struct _cffi_struct_union_s) +
nf * sizeof(struct _cffi_field_s));
building = PyMem_Malloc(i);
if (building == NULL)
goto error;
memset(building, 0, i);
nstructs = (struct _cffi_struct_union_s *)building;
nfields = (struct _cffi_field_s *)(nstructs + n);
nf = 0;
for (i = 0; i < n; i++) {
/* 'desc' is the tuple of strings (desc_struct, desc_field_1, ..) */
PyObject *desc = PyTuple_GET_ITEM(struct_unions, i);
Py_ssize_t j, nf1 = PyTuple_GET_SIZE(desc) - 1;
char *s = PyBytes_AS_STRING(PyTuple_GET_ITEM(desc, 0));
/* 's' is the first string, describing the struct/union */
nstructs[i].type_index = cdl_4bytes(s); s += 4;
nstructs[i].flags = cdl_4bytes(s); s += 4;
nstructs[i].name = s;
if (nstructs[i].flags & (_CFFI_F_OPAQUE | _CFFI_F_EXTERNAL)) {
nstructs[i].size = (size_t)-1;
nstructs[i].alignment = -1;
nstructs[i].first_field_index = -1;
nstructs[i].num_fields = 0;
assert(nf1 == 0);
}
else {
nstructs[i].size = (size_t)-2;
nstructs[i].alignment = -2;
nstructs[i].first_field_index = nf;
nstructs[i].num_fields = nf1;
}
for (j = 0; j < nf1; j++) {
char *f = PyBytes_AS_STRING(PyTuple_GET_ITEM(desc, j + 1));
/* 'f' is one of the other strings beyond the first one,
describing one field each */
nfields[nf].field_type_op = cdl_opcode(f); f += 4;
nfields[nf].field_offset = (size_t)-1;
if (_CFFI_GETOP(nfields[nf].field_type_op) != _CFFI_OP_NOOP) {
nfields[nf].field_size = cdl_4bytes(f); f += 4;
}
else {
nfields[nf].field_size = (size_t)-1;
}
nfields[nf].name = f;
nf++;
}
}
ffi->types_builder.ctx.struct_unions = nstructs;
ffi->types_builder.ctx.fields = nfields;
ffi->types_builder.ctx.num_struct_unions = n;
building = NULL;
}
if (enums != NULL) {
/* unpack a tuple of strings, each of which describes one enum_s
entry */
struct _cffi_enum_s *nenums;
Py_ssize_t i, n = PyTuple_GET_SIZE(enums);
i = n * sizeof(struct _cffi_enum_s);
building = PyMem_Malloc(i);
if (building == NULL)
goto error;
memset(building, 0, i);
nenums = (struct _cffi_enum_s *)building;
for (i = 0; i < n; i++) {
char *e = PyBytes_AS_STRING(PyTuple_GET_ITEM(enums, i));
/* 'e' is a string describing the enum */
nenums[i].type_index = cdl_4bytes(e); e += 4;
nenums[i].type_prim = cdl_4bytes(e); e += 4;
nenums[i].name = e; e += strlen(e) + 1;
nenums[i].enumerators = e;
}
ffi->types_builder.ctx.enums = nenums;
ffi->types_builder.ctx.num_enums = n;
building = NULL;
}
if (typenames != NULL) {
/* unpack a tuple of strings, each of which describes one typename_s
entry */
struct _cffi_typename_s *ntypenames;
Py_ssize_t i, n = PyTuple_GET_SIZE(typenames);
i = n * sizeof(struct _cffi_typename_s);
building = PyMem_Malloc(i);
if (building == NULL)
goto error;
memset(building, 0, i);
ntypenames = (struct _cffi_typename_s *)building;
for (i = 0; i < n; i++) {
char *t = PyBytes_AS_STRING(PyTuple_GET_ITEM(typenames, i));
/* 't' is a string describing the typename */
ntypenames[i].type_index = cdl_4bytes(t); t += 4;
ntypenames[i].name = t;
}
ffi->types_builder.ctx.typenames = ntypenames;
ffi->types_builder.ctx.num_typenames = n;
building = NULL;
}
if (includes != NULL) {
PyObject *included_libs;
included_libs = PyTuple_New(PyTuple_GET_SIZE(includes));
if (included_libs == NULL)
return -1;
Py_INCREF(includes);
ffi->types_builder.included_ffis = includes;
ffi->types_builder.included_libs = included_libs;
}
/* Above, we took directly some "char *" strings out of the strings,
typically from somewhere inside tuples. Keep them alive by
incref'ing the whole input arguments. */
Py_INCREF(args);
Py_XINCREF(kwds);
ffi->types_builder._keepalive1 = args;
ffi->types_builder._keepalive2 = kwds;
return 0;
error:
if (building != NULL)
PyMem_Free(building);
if (!PyErr_Occurred())
PyErr_NoMemory();
return -1;
}
static char *
convertsimple(PyObject *arg, char **p_format, va_list *p_va, char *msgbuf,
size_t bufsize, PyObject **freelist)
{
char *format = *p_format;
char c = *format++;
#ifdef Py_USING_UNICODE
PyObject *uarg;
#endif
switch (c) {
case 'b': { /* unsigned byte -- very short int */
char *p = va_arg(*p_va, char *);
long ival;
if (float_argument_error(arg))
return converterr("integer<b>", arg, msgbuf, bufsize);
ival = PyInt_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<b>", arg, msgbuf, bufsize);
else if (ival < 0) {
PyErr_SetString(PyExc_OverflowError,
"unsigned byte integer is less than minimum");
return converterr("integer<b>", arg, msgbuf, bufsize);
}
else if (ival > UCHAR_MAX) {
PyErr_SetString(PyExc_OverflowError,
"unsigned byte integer is greater than maximum");
return converterr("integer<b>", arg, msgbuf, bufsize);
}
else
*p = (unsigned char) ival;
break;
}
case 'B': {/* byte sized bitfield - both signed and unsigned
values allowed */
char *p = va_arg(*p_va, char *);
long ival;
if (float_argument_error(arg))
return converterr("integer<B>", arg, msgbuf, bufsize);
ival = PyInt_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<B>", arg, msgbuf, bufsize);
else
*p = (unsigned char) ival;
break;
}
case 'h': {/* signed short int */
short *p = va_arg(*p_va, short *);
long ival;
if (float_argument_error(arg))
return converterr("integer<h>", arg, msgbuf, bufsize);
ival = PyInt_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<h>", arg, msgbuf, bufsize);
else if (ival < SHRT_MIN) {
PyErr_SetString(PyExc_OverflowError,
"signed short integer is less than minimum");
return converterr("integer<h>", arg, msgbuf, bufsize);
}
else if (ival > SHRT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"signed short integer is greater than maximum");
return converterr("integer<h>", arg, msgbuf, bufsize);
}
else
*p = (short) ival;
break;
}
case 'H': { /* short int sized bitfield, both signed and
unsigned allowed */
unsigned short *p = va_arg(*p_va, unsigned short *);
long ival;
if (float_argument_error(arg))
return converterr("integer<H>", arg, msgbuf, bufsize);
ival = PyInt_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<H>", arg, msgbuf, bufsize);
else
*p = (unsigned short) ival;
break;
}
case 'i': {/* signed int */
int *p = va_arg(*p_va, int *);
long ival;
if (float_argument_error(arg))
return converterr("integer<i>", arg, msgbuf, bufsize);
ival = PyInt_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<i>", arg, msgbuf, bufsize);
else if (ival > INT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"signed integer is greater than maximum");
return converterr("integer<i>", arg, msgbuf, bufsize);
}
else if (ival < INT_MIN) {
PyErr_SetString(PyExc_OverflowError,
"signed integer is less than minimum");
return converterr("integer<i>", arg, msgbuf, bufsize);
}
else
*p = ival;
break;
}
case 'I': { /* int sized bitfield, both signed and
unsigned allowed */
unsigned int *p = va_arg(*p_va, unsigned int *);
unsigned int ival;
if (float_argument_error(arg))
return converterr("integer<I>", arg, msgbuf, bufsize);
ival = PyInt_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<I>", arg, msgbuf, bufsize);
else
*p = ival;
break;
}
case 'l': {/* long int */
long *p = va_arg(*p_va, long *);
long ival;
if (float_argument_error(arg))
return converterr("integer<l>", arg, msgbuf, bufsize);
ival = PyInt_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<l>", arg, msgbuf, bufsize);
else
*p = ival;
break;
}
case 'k': { /* long sized bitfield */
unsigned long *p = va_arg(*p_va, unsigned long *);
unsigned long ival;
if (PyInt_Check(arg))
ival = PyInt_AsUnsignedLongMask(arg);
else if (PyLong_Check(arg))
ival = PyLong_AsUnsignedLongMask(arg);
else
return converterr("integer<k>", arg, msgbuf, bufsize);
*p = ival;
break;
}
#ifdef HAVE_LONG_LONG
case 'L': {/* PY_LONG_LONG */
PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
PY_LONG_LONG ival = PyLong_AsLongLong( arg );
if( ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
return converterr("long<L>", arg, msgbuf, bufsize);
} else {
*p = ival;
}
break;
}
case 'K': { /* long long sized bitfield */
unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
unsigned PY_LONG_LONG ival;
if (PyInt_Check(arg))
ival = PyInt_AsUnsignedLongMask(arg);
else if (PyLong_Check(arg))
ival = PyLong_AsUnsignedLongLongMask(arg);
else
return converterr("integer<K>", arg, msgbuf, bufsize);
*p = ival;
break;
}
#endif
case 'f': {/* float */
float *p = va_arg(*p_va, float *);
double dval = PyFloat_AsDouble(arg);
if (PyErr_Occurred())
return converterr("float<f>", arg, msgbuf, bufsize);
else
*p = (float) dval;
break;
}
case 'd': {/* double */
double *p = va_arg(*p_va, double *);
double dval = PyFloat_AsDouble(arg);
if (PyErr_Occurred())
return converterr("float<d>", arg, msgbuf, bufsize);
else
*p = dval;
break;
}
#ifndef WITHOUT_COMPLEX
case 'D': {/* complex double */
Py_complex *p = va_arg(*p_va, Py_complex *);
Py_complex cval;
cval = PyComplex_AsCComplex(arg);
if (PyErr_Occurred())
return converterr("complex<D>", arg, msgbuf, bufsize);
else
*p = cval;
break;
}
#endif /* WITHOUT_COMPLEX */
case 'c': {/* char */
char *p = va_arg(*p_va, char *);
if (PyString_Check(arg) && PyString_Size(arg) == 1)
*p = PyString_AS_STRING(arg)[0];
else
return converterr("char", arg, msgbuf, bufsize);
break;
}
case 's': {/* string */
if (*format == '#') {
void **p = (void **)va_arg(*p_va, char **);
int *q = va_arg(*p_va, int *);
if (PyString_Check(arg)) {
*p = PyString_AS_STRING(arg);
*q = PyString_GET_SIZE(arg);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
uarg = UNICODE_DEFAULT_ENCODING(arg);
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
*p = PyString_AS_STRING(uarg);
*q = PyString_GET_SIZE(uarg);
}
#endif
else { /* any buffer-like object */
char *buf;
int count = convertbuffer(arg, p, &buf);
if (count < 0)
return converterr(buf, arg, msgbuf, bufsize);
*q = count;
}
format++;
} else {
char **p = va_arg(*p_va, char **);
if (PyString_Check(arg))
*p = PyString_AS_STRING(arg);
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(arg)) {
uarg = UNICODE_DEFAULT_ENCODING(arg);
if (uarg == NULL)
return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
*p = PyString_AS_STRING(uarg);
}
#endif
else
return converterr("string", arg, msgbuf, bufsize);
if ((int)strlen(*p) != PyString_Size(arg))
return converterr("string without null bytes",
arg, msgbuf, bufsize);
}
break;
}
static PyObject *qdbusargument_add(QDBusArgument *arg, PyObject *obj, int mtype)
{
int iserr = 0;
if (PyLong_CheckExact(obj)
#if PY_MAJOR_VERSION < 3
|| PyInt_CheckExact(obj)
#endif
)
{
if (mtype == QMetaType::UChar || mtype == QMetaType::UShort || mtype == QMetaType::UInt || mtype == QMetaType::ULongLong)
{
// Handle the unsigned values.
#if defined(HAVE_LONG_LONG)
unsigned PY_LONG_LONG v = PyLong_AsUnsignedLongLongMask(obj);
#else
unsigned long v = PyLong_AsUnsignedLongMask(obj);
#endif
switch (mtype)
{
case QMetaType::UChar:
*arg << (uchar)v;
break;
case QMetaType::UShort:
*arg << (ushort)v;
break;
case QMetaType::UInt:
*arg << (uint)v;
break;
case QMetaType::ULongLong:
*arg << (qulonglong)v;
break;
}
}
else if (mtype == QMetaType::Short || mtype == QMetaType::Int || mtype == QMetaType::LongLong)
{
// Handle the signed values.
#if defined(HAVE_LONG_LONG)
PY_LONG_LONG v = PyLong_AsLongLong(obj);
#else
long v = PyLong_AsLong(obj);
#endif
switch (mtype)
{
case QMetaType::Short:
*arg << (short)v;
break;
case QMetaType::Int:
*arg << (int)v;
break;
case QMetaType::LongLong:
*arg << (qlonglong)v;
break;
}
}
else
{
PyErr_Format(PyExc_ValueError,
"%d is an invalid QMetaType::Type for an interger object",
mtype);
iserr = 1;
}
}
else if (mtype == QMetaType::QStringList)
{
// A QStringList has to be handled explicitly to prevent it being seen
// as a vialiant list.
int value_state;
QStringList *qsl = reinterpret_cast<QStringList *>(
sipForceConvertToType(obj, sipType_QStringList, 0,
SIP_NOT_NONE, &value_state, &iserr));
if (!iserr)
{
arg->beginArray(QMetaType::QString);
for (int i = 0; i < qsl->count(); ++i)
*arg << qsl->at(i);
arg->endArray();
sipReleaseType(qsl, sipType_QStringList, value_state);
}
}
else
{
int value_state;
QVariant *qv = reinterpret_cast<QVariant *>(
sipForceConvertToType(obj, sipType_QVariant, 0, SIP_NOT_NONE,
&value_state, &iserr));
if (!iserr)
{
// This is an internal method. If it proves to be a problem then we
// will have to handle each type explicitly.
arg->appendVariant(*qv);
sipReleaseType(qv, sipType_QVariant, value_state);
}
}
if (iserr)
return 0;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
Z_set(void *ptr, PyObject *value, Py_ssize_t size)
{
if (value == Py_None) {
*(wchar_t **)ptr = NULL;
Py_INCREF(value);
return value;
}
if (PyLong_Check(value) || PyLong_Check(value)) {
#if SIZEOF_VOID_P == SIZEOF_LONG_LONG
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongLongMask(value);
#else
*(wchar_t **)ptr = (wchar_t *)PyLong_AsUnsignedLongMask(value);
#endif
Py_INCREF(Py_None);
return Py_None;
}
if (PyBytes_Check(value)) {
value = PyUnicode_FromEncodedObject(value,
_ctypes_conversion_encoding,
_ctypes_conversion_errors);
if (!value)
return NULL;
} else if (!PyUnicode_Check(value)) {
PyErr_Format(PyExc_TypeError,
"unicode string or integer address expected instead of %s instance",
value->ob_type->tp_name);
return NULL;
} else
Py_INCREF(value);
#ifdef HAVE_USABLE_WCHAR_T
/* HAVE_USABLE_WCHAR_T means that Py_UNICODE and wchar_t is the same
type. So we can copy directly. Hm, are unicode objects always NUL
terminated in Python, internally?
*/
*(wchar_t **)ptr = PyUnicode_AS_UNICODE(value);
return value;
#else
{
/* We must create a wchar_t* buffer from the unicode object,
and keep it alive */
PyObject *keep;
wchar_t *buffer;
int size = PyUnicode_GET_SIZE(value);
size += 1; /* terminating NUL */
size *= sizeof(wchar_t);
buffer = (wchar_t *)PyMem_Malloc(size);
if (!buffer) {
Py_DECREF(value);
return PyErr_NoMemory();
}
memset(buffer, 0, size);
keep = PyCapsule_New(buffer, CTYPES_CFIELD_CAPSULE_NAME_PYMEM, pymem_destructor);
if (!keep) {
Py_DECREF(value);
PyMem_Free(buffer);
return NULL;
}
*(wchar_t **)ptr = (wchar_t *)buffer;
if (-1 == PyUnicode_AsWideChar((PyUnicodeObject *)value,
buffer, PyUnicode_GET_SIZE(value))) {
Py_DECREF(value);
Py_DECREF(keep);
return NULL;
}
Py_DECREF(value);
return keep;
}
#endif
}
