/* Retrieve item from external memory list.
*
* XXX: Support slice objects and negative indices?
*/
static PyObject *em_list_getitem(em_list_t *self, PyObject *key)
{
Py_ssize_t index;
PyObject *r = NULL;
/* Python 3 supports only long integers. */
#if PY_MAJOR_VERSION < 3
if(PyInt_CheckExact(key))
{
index = PyInt_AsSsize_t(key);
r = em_list_getitem_internal(self, index);
}
else if(PyLong_CheckExact(key))
#else
if(PyLong_CheckExact(key))
#endif
{
index = PyLong_AsSsize_t(key);
r = em_list_getitem_internal(self, index);
}
else
PyErr_SetString(PyExc_TypeError, "Invalid key object type");
return r;
}
SobolSampler* SobolSampler_New(size_t dims, PyObject* size)
{
size_t _size = 0;
size_t _is_inf = 0;
if (size == Py_None)
{
_size = 1;
_is_inf = 1;
}
else if (PyInt_Check(size) || PyLong_Check(size))
{
_size = PyInt_AsSsize_t(size);
_is_inf = 0;
}
else
{
PyErr_SetString(PyExc_TypeError, "size must be an integer, or None");
return NULL;
}
SobolSampler* s = PyObject_New(SobolSampler, &SobolSamplerType);
if (!s) return NULL;
s->_size = _size;
s->_is_inf = _is_inf;
s->_dims = dims;
s->_rng = gsl_qrng_alloc(gsl_qrng_sobol, dims);
return s;
}
static ssize_t python_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
{
struct pyfuncs *pf = handle->data;
PyObject *pArgs, *pRet, *pValue;
char *pydata;
ssize_t s;
if (!pf->pFuncWrite) {
errno = ENOSYS;
return -1;
}
PY_TUPLE_NEW(2);
PY_ADD_TO_TUPLE(fsp->fh->fd, PyInt_FromSsize_t, 0);
if (!(pValue = PyString_FromStringAndSize(data, n))) {
Py_DECREF(pArgs);
errno = E_INTERNAL;
return -1;
}
PyTuple_SetItem(pArgs, 1, pValue);
PY_CALL_WITH_ARGS(Write);
s = PyInt_AsSsize_t(pRet);
Py_DECREF(pRet);
return s;
}
static PyObject* transfer(PyObject* self, PyObject* arg)
{
PyObject* transferTuple;
if(!PyArg_ParseTuple(arg, "O", &transferTuple)) // "O" - Gets non-NULL borrowed reference to Python argument.
return NULL; // As far as I can tell, it's mostly just copying arg[0] into transferTuple
// and making sure at least one arg has been passed (I think)
if(!PyTuple_Check(transferTuple)) // The only argument we support is a single tuple.
pabort("Only accepts a single tuple as an argument\n");
uint32_t tupleSize = PyTuple_Size(transferTuple);
uint8_t tx[tupleSize];
uint8_t rx[tupleSize];
PyObject* tempItem;
uint16_t i=0;
while(i < tupleSize)
{
tempItem = PyTuple_GetItem(transferTuple, i); //
if(!PyInt_Check(tempItem))
{
pabort("non-integer contained in tuple\n");
}
tx[i] = (uint8_t)PyInt_AsSsize_t(tempItem);
i++;
}
struct spi_ioc_transfer tr = {
.tx_buf = (unsigned long)tx,
.rx_buf = (unsigned long)rx,
.len = tupleSize,
.delay_usecs = delay,
.speed_hz = speed,
.bits_per_word = bits,
.cs_change = 1,
};
ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
if (ret < 1)
pabort("can't send spi message");
transferTuple = PyTuple_New(tupleSize);
for(i=0;i<tupleSize;i++)
PyTuple_SetItem(transferTuple, i, Py_BuildValue("i",rx[i]));
return transferTuple;
}
static PyObject* closeSPI(PyObject* self,PyObject* args)
{
close(fd);
Py_RETURN_NONE;
}
static PyObject* directWrite(PyObject* self, PyObject* arg)
{
PyObject* transferTuple;
unsigned int offset, returnVal ;
if(!PyArg_ParseTuple(arg, "lO", &offset, &transferTuple))
return NULL;
if(!PyTuple_Check(transferTuple))
pabort("Only accepts a single tuple as an argument\n");
uint32_t tupleSize = PyTuple_Size(transferTuple);
uint8_t tx[tupleSize];
PyObject* tempItem;
uint32_t i=0;
while(i < tupleSize)
{
tempItem = PyTuple_GetItem(transferTuple, i); //
if(!PyInt_Check(tempItem))
{
pabort("non-integer contained in tuple\n");
}
tx[i] = (uint8_t)PyInt_AsSsize_t(tempItem);
i++;
}
returnVal = direct_write(offset, tx, tupleSize);
return Py_BuildValue("l", returnVal) ;
}
static int
image_set_int (zbarImage *self,
PyObject *value,
void *closure)
{
unsigned int tmp, val = PyInt_AsSsize_t(value);
if(val == -1 && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "expecting an integer");
return(-1);
}
switch((int)closure) {
case 0:
tmp = zbar_image_get_height(self->zimg);
zbar_image_set_size(self->zimg, val, tmp);
break;
case 1:
tmp = zbar_image_get_width(self->zimg);
zbar_image_set_size(self->zimg, tmp, val);
break;
case 2:
zbar_image_set_sequence(self->zimg, val);
default:
assert(0);
}
return(0);
}
grub_err_t do_pyfs_open(const char *name, grub_off_t *size)
{
PyObject *pyret;
Py_ssize_t pysize;
if (!pyfs_open_callable)
return GRUB_ERR_FILE_NOT_FOUND;
pyret = PyObject_CallFunction(pyfs_open_callable, "s", name);
if (pyret == NULL) {
PyErr_Print();
return grub_error(GRUB_ERR_IO, "Internal error: Failed to call Python open callback, or it threw an exception");
}
if (pyret == Py_None) {
Py_DECREF(pyret);
return GRUB_ERR_BAD_FILE_TYPE;
}
pysize = PyInt_AsSsize_t(pyret);
Py_DECREF(pyret);
if (pysize < 0) {
if (PyErr_Occurred())
PyErr_Print();
return grub_error(GRUB_ERR_IO, "Internal error: Python open callback returned a bad or negative size");
}
*size = (grub_off_t)pysize;
return GRUB_ERR_NONE;
}
/* Insert item in external memory list.
*
* XXX: Support slice objects and negative indices?
*/
static int em_list_setitem(em_list_t *self, PyObject *key, PyObject *value)
{
Py_ssize_t index;
int ret = -1;
/* Python 3 supports only long integers. */
#if PY_MAJOR_VERSION < 3
if(PyInt_CheckExact(key))
{
index = PyInt_AsSsize_t(key);
ret = em_list_setitem_safe(self, index, value);
}
else if(PyLong_CheckExact(key))
#else
if(PyLong_CheckExact(key))
#endif
{
index = PyLong_AsSsize_t(key);
ret = em_list_setitem_safe(self, index, value);
}
else
PyErr_SetString(PyExc_TypeError, "Invalid index type");
return ret;
}
static PyObject *SEQUENCE_REPEAT( ssizeargfunc repeatfunc, PyObject *seq, PyObject *n )
{
if (unlikely( !PyIndex_Check( n ) ))
{
PyErr_Format(
PyExc_TypeError,
"can't multiply sequence by non-int of type '%s'",
Py_TYPE( n )->tp_name
);
return NULL;
}
PyObject *index_value = PyNumber_Index( n );
if (unlikely( index_value == NULL ))
{
return NULL;
}
/* We're done if PyInt_AsSsize_t() returns without error. */
#if PYTHON_VERSION < 300
Py_ssize_t count = PyInt_AsSsize_t( index_value );
#else
Py_ssize_t count = PyLong_AsSsize_t( index_value );
#endif
Py_DECREF( index_value );
if (unlikely( count == -1 )) // Note: -1 is an unlikely repetition count
{
PyObject *exception = GET_ERROR_OCCURRED();
if (unlikely( exception ))
{
if ( !EXCEPTION_MATCH_BOOL_SINGLE( exception, PyExc_OverflowError ) )
{
return NULL;
}
PyErr_Format(
PyExc_OverflowError,
"cannot fit '%s' into an index-sized integer",
Py_TYPE( n )->tp_name
);
return NULL;
}
}
PyObject *result = (*repeatfunc)( seq, count );
if (unlikely( result == NULL ))
{
return NULL;
}
return result;
}
static INLINE Py_ssize_t __pyx_PyIndex_AsSsize_t(PyObject* b) {
Py_ssize_t ival;
PyObject* x = PyNumber_Index(b);
if (!x) return -1;
ival = PyInt_AsSsize_t(x);
Py_DECREF(x);
return ival;
}
/* Implementation of rowe_1 */
static PyObject *__pyx_f_6rowe_1_function(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_f_6rowe_1_function(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_data = 0;
PyObject *__pyx_v_a;
PyObject *__pyx_r;
PyObject *__pyx_1 = 0;
PyObject *__pyx_2 = 0;
int __pyx_3;
Py_ssize_t __pyx_4;
Py_ssize_t __pyx_5;
static char *__pyx_argnames[] = {"data",0};
if (!PyArg_ParseTupleAndKeywords(__pyx_args, __pyx_kwds, "O", __pyx_argnames, &__pyx_v_data)) return 0;
Py_INCREF(__pyx_v_data);
__pyx_v_a = Py_None; Py_INCREF(Py_None);
/* "/Local/Projects/D/Pyrex/Source/Tests/Bugs/other/rowe_1.pyx":7 */
__pyx_1 = PyInt_FromLong(4); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;}
__pyx_2 = PyNumber_Multiply(__pyx_1, __pyx_v_a); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;}
Py_DECREF(__pyx_1); __pyx_1 = 0;
__pyx_3 = PyInt_AsLong(__pyx_2); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;}
Py_DECREF(__pyx_2); __pyx_2 = 0;
blarg(__pyx_3);
/* "/Local/Projects/D/Pyrex/Source/Tests/Bugs/other/rowe_1.pyx":8 */
__pyx_4 = PyInt_AsSsize_t(__pyx_v_a); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;}
__pyx_1 = __Pyx_GetName(__pyx_b, __pyx_n_b); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;}
__pyx_2 = PyNumber_Add(__pyx_v_a, __pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;}
Py_DECREF(__pyx_1); __pyx_1 = 0;
__pyx_5 = PyInt_AsSsize_t(__pyx_2); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;}
Py_DECREF(__pyx_2); __pyx_2 = 0;
__pyx_1 = PySequence_GetSlice(__pyx_v_data, __pyx_4, __pyx_5); if (!__pyx_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;}
__pyx_r = __pyx_1;
__pyx_1 = 0;
goto __pyx_L0;
__pyx_r = Py_None; Py_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1:;
Py_XDECREF(__pyx_1);
Py_XDECREF(__pyx_2);
__Pyx_AddTraceback("rowe_1.function");
__pyx_r = 0;
__pyx_L0:;
Py_DECREF(__pyx_v_a);
Py_DECREF(__pyx_v_data);
return __pyx_r;
}
static PyObject* logiWrite(PyObject* self, PyObject* arg)
{
PyObject* transferTuple;
unsigned int offset, returnVal ;
unsigned char type_size = 1 ;
if(!PyArg_ParseTuple(arg, "lO|b", &offset, &transferTuple, &type_size))
return NULL;
if(!PyTuple_Check(transferTuple))
pabort("Only accepts a single tuple as an argument\n");
if(type_size != 1 && type_size != 2 && type_size != 4)
pabort("type_size argument can only be 1, 2, 4\n");
uint32_t tupleSize = PyTuple_Size(transferTuple);
uint8_t tx[tupleSize*type_size];
PyObject* tempItem;
uint32_t i=0;
while(i < tupleSize)
{
tempItem = PyTuple_GetItem(transferTuple, i); //
if(!PyInt_Check(tempItem))
{
pabort("non-integer contained in tuple\n");
}
switch(type_size){
case 1:
tx[i] = (uint8_t)PyInt_AsSsize_t(tempItem);
break ;
case 2:
((uint16_t*)tx)[i] = (uint16_t)PyInt_AsSsize_t(tempItem);
break ;
case 4:
((uint32_t*)tx)[i] = (uint32_t)PyInt_AsSsize_t(tempItem);
break ;
default:
break ;
}
i++;
}
returnVal = logi_write(tx, tupleSize*type_size, offset);
return Py_BuildValue("l", returnVal) ;
}
static PyObject*
_split_u_list(PyObject* self, PyObject* arg) {
size_t sLen = 0, splitterLen = 1, maxsplit = 1, index = 0;
Py_UNICODE *src = NULL, *s, *ss, *sEnd = NULL, *sPrev = NULL;
Py_UNICODE defaultSplitter = ',', *splitter = &defaultSplitter, *sp, *spEnd = splitter + splitterLen;
PyObject *list;
PyTupleObject* argTuple = (PyTupleObject*) arg;
if (PyUnicode_CheckExact(argTuple->ob_item[0])) {
src = PyUnicode_AS_UNICODE(argTuple->ob_item[0]);
sLen = PyUnicode_GET_SIZE(argTuple->ob_item[0]);
} else {
return NULL;
}
maxsplit = PyInt_AsSsize_t(argTuple->ob_item[1]);
if (!maxsplit || maxsplit > 100) {
return NULL;
}
if (argTuple->ob_size > 2) {
if (PyUnicode_CheckExact(argTuple->ob_item[2])) {
splitter = PyUnicode_AS_UNICODE(argTuple->ob_item[2]);
splitterLen = PyUnicode_GET_SIZE(argTuple->ob_item[2]);
spEnd = splitter + splitterLen;
} else {
return NULL;
}
}
sPrev = s = src, sEnd = src + sLen;
list = TYPE_NEW(maxsplit);
while (s < sEnd) {
if (*s == *splitter) {
if (splitterLen > 1) {
sp = splitter, ss = s;
while (*++sp == *++ss);
if (sp >= spEnd) {
ADD_U;
if (index >= maxsplit) return list;
sPrev = s + splitterLen;
s += splitterLen;
continue;
}
} else {
ADD_U;
if (index >= maxsplit) return list;
sPrev = s + 1;
}
}
s++;
}
if (index < maxsplit) {
ADD_U;
}
Py_SIZE(list) = index;
return list;
}
size_t modena_model_outputs_argPos(const modena_model_t *m, const char *name)
{
PyObject *pRet = PyObject_CallMethod(m->pModel, "outputs_argPos", NULL);
if(!pRet){ Modena_PyErr_Print(); }
size_t ret = PyInt_AsSsize_t(pRet);
Py_DECREF(pRet);
return ret;
}
void modena_substitute_model_calculate_maps
(
modena_substitute_model_t *sm,
modena_model_t *parent
)
{
PyObject *pMaps = PyObject_CallMethod
(
parent->pModel, "calculate_maps", "(O)", sm->model->pModel
);
if(!pMaps){ Modena_PyErr_Print(); }
PyObject *pMapOutputs = PyTuple_GET_ITEM(pMaps, 0); // Borrowed ref
if(!pMapOutputs){ Modena_PyErr_Print(); }
PyObject *pSeq = PySequence_Fast(pMapOutputs, "expected a sequence");
sm->map_outputs_size = PySequence_Size(pMapOutputs);
sm->map_outputs = malloc(sm->map_outputs_size*sizeof(double));
size_t i;
for(i = 0; i < sm->map_outputs_size; i++)
{
sm->map_outputs[i] = PyInt_AsSsize_t(PyList_GET_ITEM(pSeq, i));
parent->argPos_used[sm->map_outputs[i]] = true;
}
sm->map_outputs_size /= 2;
Py_DECREF(pSeq);
Py_DECREF(pMapOutputs);
if(PyErr_Occurred()){ Modena_PyErr_Print(); }
PyObject *pMapInputs = PyTuple_GET_ITEM(pMaps, 1); // Borrowed ref
if(!pMapInputs){ Modena_PyErr_Print(); }
pSeq = PySequence_Fast(pMapInputs, "expected a sequence");
sm->map_inputs_size = PySequence_Size(pMapInputs);
sm->map_inputs = malloc(sm->map_inputs_size*sizeof(double));
for(i = 0; i < sm->map_inputs_size; i++)
{
sm->map_inputs[i] = PyInt_AsSsize_t(PyList_GET_ITEM(pSeq, i));
}
sm->map_inputs_size /= 2;
Py_DECREF(pSeq);
Py_DECREF(pMapInputs);
if(PyErr_Occurred()){ Modena_PyErr_Print(); }
Py_DECREF(pMaps);
}
//Py Conversion Functions with overloads
int Pywrap::py_extractInt(PyObject *results) const
{
if(PyInt_Check(results))
{
return PyInt_AsSsize_t(results);
}
std::cout << "Warning: PyObject is not Integer. Undefined behavior may occur! Warning in script: " << path
<< std::endl;
return 0;
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
PyNumberMethods *m;
const char *name = NULL;
PyObject *res = NULL;
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(x) || PyLong_Check(x))
#else
if (PyLong_Check(x))
#endif
return Py_INCREF(x), x;
m = Py_TYPE(x)->tp_as_number;
#if PY_VERSION_HEX < 0x03000000
if (m && m->nb_int) {
name = "int";
res = PyNumber_Int(x);
}
else if (m && m->nb_long) {
name = "long";
res = PyNumber_Long(x);
}
#else
if (m && m->nb_int) {
name = "int";
res = PyNumber_Long(x);
}
#endif
if (res) {
#if PY_VERSION_HEX < 0x03000000
if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
if (!PyLong_Check(res)) {
#endif
PyErr_Format(PyExc_TypeError,
"__%s__ returned non-%s (type %.200s)",
name, name, Py_TYPE(res)->tp_name);
Py_DECREF(res);
return NULL;
}
}
else if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,
"an integer is required");
}
return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
Py_ssize_t ival;
PyObject* x = PyNumber_Index(b);
if (!x) return -1;
ival = PyInt_AsSsize_t(x);
Py_DECREF(x);
return ival;
}
static int
Row_setattro(PyObject* o, PyObject *name, PyObject* v)
{
Row* self = (Row*)o;
PyObject* index = PyDict_GetItem(self->map_name_to_index, name);
if (index)
return Row_ass_item(self, PyInt_AsSsize_t(index), v);
return PyObject_GenericSetAttr(o, name, v);
}
/* Constructor */
PyObject *
Image_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
ImageObject *self = (ImageObject*) type->tp_alloc(type, 0);
if (self != NULL)
{
PyObject *input = NULL;
if (PyArg_ParseTuple(args, "|O", &input))
{
if (input != NULL)
{
try
{
PyObject *pyStr;
// If the input object is a tuple, consider it (index, filename)
if (PyTuple_Check(input))
{
// Get the index and filename from the Python tuple object
size_t index = PyInt_AsSsize_t(PyTuple_GetItem(input, 0));
const char * filename = PyString_AsString(PyTuple_GetItem(input, 1));
// Now read using both of index and filename
self->image = new ImageGeneric();
self->image->read(filename, DATA, index);
}
else if ((pyStr = PyObject_Str(input)) != NULL)
{
self->image = new ImageGeneric(PyString_AsString(pyStr));
//todo: add copy constructor
}
else
{
PyErr_SetString(PyExc_TypeError,
"Image_new: Expected string, FileName or tuple as first argument");
return NULL;
}
}
catch (XmippError &xe)
{
PyErr_SetString(PyXmippError, xe.msg.c_str());
return NULL;
}
}
else
self->image = new ImageGeneric();
}
else
return NULL;
}
return (PyObject *) self;
}//function Image_new
PyObject *
dealloc_cpt(PyObject *self, PyObject *args) {
PyObject *pycpt; // addr of cpt as a python int
if (!PyArg_ParseTuple(args, "O", &pycpt)) {
return NULL;
}
CPT *cpt = (CPT*) PyInt_AsSsize_t(pycpt);
_dealloc_cpt(cpt);
Py_RETURN_NONE;
}
/** Helper to verify current reference count and avoid memory leaks */
size_t PythonTotalRefCount()
{
#ifdef Py_DEBUG
#pragma message("Open3DMotion MESSAGE: Debug build selected. Ensure that a custom build of python shared library is used (one built with Py_DEBUG defined).")
PyObject* borrowed_count_function = PySys_GetObject("gettotalrefcount");
PyObject* py_count = PyObject_CallObject(borrowed_count_function, NULL);
size_t count = PyInt_AsSsize_t(py_count);
Py_DECREF(py_count);
return count;
#else
return 0;
#endif
}
static int
image_set_size (zbarImage *self,
PyObject *value,
void *closure)
{
if(!value) {
PyErr_SetString(PyExc_TypeError, "cannot delete size attribute");
return(-1);
}
int rc = -1;
PyObject *wobj = NULL, *hobj = NULL;
if(!PySequence_Check(value) ||
PySequence_Size(value) != 2)
goto error;
wobj = PySequence_GetItem(value, 0);
hobj = PySequence_GetItem(value, 1);
if(!wobj || !hobj)
goto error;
int width = PyInt_AsSsize_t(wobj);
if(width == -1 && PyErr_Occurred())
goto error;
int height = PyInt_AsSsize_t(hobj);
if(height == -1 && PyErr_Occurred())
goto error;
zbar_image_set_size(self->zimg, width, height);
rc = 0;
error:
Py_XDECREF(wobj);
Py_XDECREF(hobj);
if(rc)
PyErr_SetString(PyExc_ValueError,
"size must be a sequence of two ints");
return(rc);
}
static int
array_power_is_scalar(PyObject *o2, double* exp)
{
PyObject *temp;
const int optimize_fpexps = 1;
if (PyInt_Check(o2)) {
*exp = (double)PyInt_AsLong(o2);
return 1;
}
if (optimize_fpexps && PyFloat_Check(o2)) {
*exp = PyFloat_AsDouble(o2);
return 1;
}
if ((PyArray_IsZeroDim(o2) &&
((PyArray_ISINTEGER(o2) ||
(optimize_fpexps && PyArray_ISFLOAT(o2))))) ||
PyArray_IsScalar(o2, Integer) ||
(optimize_fpexps && PyArray_IsScalar(o2, Floating))) {
temp = o2->ob_type->tp_as_number->nb_float(o2);
if (temp != NULL) {
*exp = PyFloat_AsDouble(o2);
Py_DECREF(temp);
return 1;
}
}
#if (PY_VERSION_HEX >= 0x02050000)
if (PyIndex_Check(o2)) {
PyObject* value = PyNumber_Index(o2);
Py_ssize_t val;
if (value==NULL) {
if (PyErr_Occurred()) {
PyErr_Clear();
}
return 0;
}
val = PyInt_AsSsize_t(value);
if (val == -1 && PyErr_Occurred()) {
PyErr_Clear();
return 0;
}
*exp = (double) val;
return 1;
}
#endif
return 0;
}
static PyObject *
enum_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
enumobject *en;
PyObject *seq = NULL;
PyObject *start = NULL;
static char *kwlist[] = {"sequence", "start", 0};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:enumerate", kwlist,
&seq, &start))
return NULL;
en = (enumobject *)type->tp_alloc(type, 0);
if (en == NULL)
return NULL;
if (start != NULL) {
start = PyNumber_Index(start);
if (start == NULL) {
Py_DECREF(en);
return NULL;
}
assert(PyInt_Check(start) || PyLong_Check(start));
en->en_index = PyInt_AsSsize_t(start);
if (en->en_index == -1 && PyErr_Occurred()) {
PyErr_Clear();
en->en_index = PY_SSIZE_T_MAX;
en->en_longindex = start;
} else {
en->en_longindex = NULL;
Py_DECREF(start);
}
} else {
en->en_index = 0;
en->en_longindex = NULL;
}
en->en_sit = PyObject_GetIter(seq);
if (en->en_sit == NULL) {
Py_DECREF(en);
return NULL;
}
en->en_result = PyTuple_Pack(2, Py_None, Py_None);
if (en->en_result == NULL) {
Py_DECREF(en);
return NULL;
}
return (PyObject *)en;
}
static off_t python_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
{
struct pyfuncs *pf = handle->data;
PyObject *pArgs, *pRet, *pValue;
off_t o;
PY_TUPLE_NEW(3);
PY_ADD_TO_TUPLE(fsp->fh->fd, PyInt_FromSsize_t, 0);
PY_ADD_TO_TUPLE(offset, PyInt_FromSize_t, 1);
PY_ADD_TO_TUPLE(whence, PyInt_FromSize_t, 2);
PY_CALL_WITH_ARGS(LSeek);
o = PyInt_AsSsize_t(pRet);
Py_DECREF(pRet);
return o;
}
/* write */
PyObject *
Image_write(PyObject *obj, PyObject *args, PyObject *kwargs)
{
ImageObject *self = (ImageObject*) obj;
if (self != NULL)
{
PyObject *input = NULL;
if (PyArg_ParseTuple(args, "O", &input))
{
try
{
PyObject *pyStr;
// If the input object is a tuple, consider it (index, filename)
if (PyTuple_Check(input))
{
// Get the index and filename from the Python tuple object
size_t index = PyInt_AsSsize_t(PyTuple_GetItem(input, 0));
const char * filename = PyString_AsString(PyTuple_GetItem(input, 1));
// Now read using both of index and filename
bool isStack = (index > 0);
WriteMode writeMode = isStack ? WRITE_REPLACE : WRITE_OVERWRITE;
self->image->write(filename, index, isStack, writeMode);
Py_RETURN_NONE;
}
if ((pyStr = PyObject_Str(input)) != NULL)
{
self->image->write(PyString_AsString(input));
Py_RETURN_NONE;
}
else
{
PyErr_SetString(PyExc_TypeError,
"Image_write: Expected an string or FileName as first argument");
}
}
catch (XmippError &xe)
{
PyErr_SetString(PyXmippError, xe.msg.c_str());
}
}
}
return NULL;
}//function Image_write
/* read */
PyObject *
Image_read(PyObject *obj, PyObject *args, PyObject *kwargs)
{
ImageObject *self = (ImageObject*) obj;
if (self != NULL)
{
int datamode = DATA;
PyObject *input = NULL;
if (PyArg_ParseTuple(args, "O|i", &input, &datamode))
{
try
{
PyObject *pyStr;
// If the input object is a tuple, consider it (index, filename)
if (PyTuple_Check(input))
{
// Get the index and filename from the Python tuple object
size_t index = PyInt_AsSsize_t(PyTuple_GetItem(input, 0));
const char * filename = PyString_AsString(PyTuple_GetItem(input, 1));
// Now read using both of index and filename
self->image->read(filename,(DataMode)datamode, index);
Py_RETURN_NONE;
}
else if ((pyStr = PyObject_Str(input)) != NULL)
{
self->image->read(PyString_AsString(pyStr),(DataMode)datamode);
Py_RETURN_NONE;
}
else
{
PyErr_SetString(PyExc_TypeError,
"Image_write: Expected an string or FileName as first argument");
}
}
catch (XmippError &xe)
{
PyErr_SetString(PyXmippError, xe.msg.c_str());
}
}
}
return NULL;
}//function Image_read
ssize_t skull_module_unpack (void* md, skull_txn_t* txn,
const void* data, size_t data_len)
{
PyGILState_STATE state = PyGILState_Ensure();
module_data_t* mdata = (module_data_t*)md;
// Prepare args
PyObject* pyArgs = PyTuple_New(4);
PyObject* pyModuleName = PyString_FromString(mdata->name);
PyObject* pyEntryName = PyString_FromString(MODULE_UNPACK_FUNCNAME);
PyObject* pyTxn = PyCapsule_New(txn, "skull_txn", NULL);
PyObject* pyData = PyString_FromStringAndSize((const char*)data,
(Py_ssize_t)data_len);
PyTuple_SetItem(pyArgs, 0, pyModuleName);
PyTuple_SetItem(pyArgs, 1, pyEntryName);
PyTuple_SetItem(pyArgs, 2, pyTxn);
PyTuple_SetItem(pyArgs, 3, pyData);
// Call user module_unpack
PyObject* pyConsumed = PyObject_CallObject(mdata->pyExecutorFunc, pyArgs);
// Set to -1 by default, so if error occurred, like un-handled excpetions,
// then the entity will be destroyed soon
ssize_t consumed = -1;
if (!pyConsumed) {
if (PyErr_Occurred()) PyErr_Print();
} else {
if (PyInt_Check(pyConsumed)) {
consumed = PyInt_AsSsize_t(pyConsumed);
} else if (PyLong_Check(pyConsumed)) {
consumed = PyLong_AsSsize_t(pyConsumed);
} else {
fprintf(stderr, "Error: Cannot parse the pyConsumed object");
_PyObject_Dump(pyConsumed);
}
}
Py_XDECREF(pyConsumed);
Py_DECREF(pyArgs);
PyGILState_Release(state);
return consumed;
}
void encode_object(PyObject *arg) {
Py_ssize_t size, i;
char *p;
if (PyString_CheckExact(arg)) {
uint8_t *s, *sEnd;
*d++ = '"';
ENCODE_STR(arg, s, sEnd)
*d++ = '"';
} else if (PyUnicode_CheckExact(arg)) {
*d++ = '"';
Py_UNICODE *u, *uEnd;
ENCODE_UNICODE(arg, u, uEnd)
*d++ = '"';
} else if (PyInt_CheckExact(arg) || PyLong_CheckExact(arg)) {
i = PyInt_AsSsize_t(arg);
uint64_t val = i < 0 ? *d++ = '-', (uint64_t)(~i + 1) : i;
ITOA(val)
} else if (PyList_CheckExact(arg)) {
// [ changed, idx ]
static cbret_t py_as_cbret(PyObject *py_ret)
{
cbret_t ret;
if ( PySequence_Check(py_ret) )
{
{
newref_t item(PySequence_GetItem(py_ret, 0));
if ( item.o != NULL && PyInt_Check(item.o) )
ret.changed = cbres_t(PyInt_AsLong(item.o));
}
if ( ret.changed != NOTHING_CHANGED )
{
newref_t item(PySequence_GetItem(py_ret, 1));
if ( item.o != NULL && PyInt_Check(item.o) )
ret.idx = ssize_t(PyInt_AsSsize_t(item.o));
}
}
return ret;
}
