static PyObject *
range_subscript(rangeobject* self, PyObject* item)
{
if (PyIndex_Check(item)) {
PyObject *i, *result;
i = PyNumber_Index(item);
if (!i)
return NULL;
result = compute_range_item(self, i);
Py_DECREF(i);
return result;
}
if (PySlice_Check(item)) {
return compute_slice(self, item);
}
PyErr_Format(PyExc_TypeError,
"range indices must be integers or slices, not %.200s",
item->ob_type->tp_name);
return NULL;
}
static PyObject *
RangeSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return RangeItem(self,_idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return RangeSlice(self,start,stop+1);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
return NULL;
}
}
static Py_ssize_t
RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val)
{
if (PyLong_Check(idx)) {
long n = PyLong_AsLong(idx);
return RangeAsItem(self, n, val);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return -1;
}
return RangeAsSlice(self, start, stop, val);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return -1;
}
}
static PyObject *
BufferSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return BufferItem(self,_idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject *)idx,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return BufferSlice(self,start,stop+1);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or slice");
return NULL;
}
}
static PyObject *
RangeSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return RangeItem((RangeObject *)(self), _idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
((RangeObject *)(self))->end-((RangeObject *)(self))->start+1,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return RangeSlice((RangeObject *)(self), start, stop);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return NULL;
}
}
/*
* Implement mapping sub-script for the type.
*/
static PyObject *sipArray_subscript(PyObject *self, PyObject *key)
{
sipArrayObject *array = (sipArrayObject *)self;
if (PyIndex_Check(key))
{
Py_ssize_t idx = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (idx == -1 && PyErr_Occurred())
return NULL;
if (idx < 0)
idx += array->len;
return sipArray_item(self, idx);
}
if (PySlice_Check(key))
{
Py_ssize_t start, stop, step, slicelength;
if (sipConvertFromSliceObject(key, array->len, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (step != 1)
{
PyErr_SetNone(PyExc_NotImplementedError);
return NULL;
}
return make_array(element(array->data, start), array->td,
array->format, array->stride, slicelength,
(array->flags & ~SIP_OWNS_MEMORY), array->owner);
}
bad_key(key);
return NULL;
}
static PyObject*
path_subscript(PyPathObject* self, PyObject* item) {
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
return path_getitem(self, i);
}
if (PySlice_Check(item)) {
int len = 4;
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((PyObject*)item, len, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
double *xy = alloc_array(0);
return (PyObject*) path_new(0, xy, 0);
}
else if (step == 1) {
return path_getslice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
"Path indices must be integers, not %.200s",
#ifdef PY3
Py_TYPE(&item)->tp_name);
#else
item->ob_type->tp_name);
#endif
return NULL;
}
}
static int pyjlist_set_subscript(PyObject* self, PyObject* item, PyObject* value) {
if(PyInt_Check(item)) {
long i = PyInt_AS_LONG(item);
if (i < 0)
i += (long) PyObject_Size(self);
return pyjlist_setitem(self, (Py_ssize_t) i, value);
}
else if(PyLong_Check(item)) {
long i = PyLong_AsLong(item);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += (long) PyObject_Size(self);
return pyjlist_setitem(self, (Py_ssize_t) i, value);
} else if(PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
/*
* ignore compile warning on the next line, they fixed the
* method signature in python 3.2
*/
if(PySlice_GetIndicesEx(item, PyObject_Size(self), &start, &stop, &step, &slicelength) < 0) {
// error will already be set
return -1;
}
if(slicelength <= 0) {
return 0;
} else if(step != 1) {
PyErr_SetString(PyExc_TypeError, "pyjlist slices must have step of 1");
return -1;
} else {
return pyjlist_setslice(self, start, stop, value);
}
} else {
PyErr_SetString(PyExc_TypeError, "list indices must be integers, longs, or slices");
return -1;
}
}
static void
base_set_item(Container& container, PyObject* i, PyObject* v)
{
if (PySlice_Check(i))
{
slice_handler::base_set_slice(container,
reinterpret_cast<PySliceObject*>(i), v);
}
else
{
extract<Data&> elem(v);
// try if elem is an exact Data
if (elem.check())
{
DerivedPolicies::
set_item(container,
DerivedPolicies::
convert_index(container, i), elem());
}
else
{
// try to convert elem to Data
extract<Data> elem(v);
if (elem.check())
{
DerivedPolicies::
set_item(container,
DerivedPolicies::
convert_index(container, i), elem());
}
else
{
PyErr_SetString(PyExc_TypeError, "Invalid assignment");
throw_error_already_set();
}
}
}
}
static PyObject *Color_subscript(ColorObject *self, PyObject *item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0)
i += COLOR_SIZE;
return Color_item(self, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((void *)item, COLOR_SIZE, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
return PyTuple_New(0);
}
else if (step == 1) {
return Color_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with color");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
}
static PyObject *
BufferSubscript(PyObject *self, PyObject* idx)
{
if (PyLong_Check(idx)) {
long _idx = PyLong_AsLong(idx);
return BufferItem((BufferObject *)(self), _idx);
} else if (PySlice_Check(idx)) {
Py_ssize_t start, stop, step, slicelen;
if (CheckBuffer((BufferObject *) self))
return NULL;
if (PySlice_GetIndicesEx((PySliceObject_T *)idx,
(Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count,
&start, &stop,
&step, &slicelen) < 0) {
return NULL;
}
return BufferSlice((BufferObject *)(self), start, stop);
} else {
RAISE_INVALID_INDEX_TYPE(idx);
return NULL;
}
}
/**
* \ingroup python_interface_edgeseq
* \brief Selects a subset of the edge sequence based on some criteria
*/
PyObject* igraphmodule_EdgeSeq_select(igraphmodule_EdgeSeqObject *self, PyObject *args) {
igraphmodule_EdgeSeqObject *result;
igraphmodule_GraphObject *gr;
long i, j, n, m;
gr=self->gref;
result=igraphmodule_EdgeSeq_copy(self);
if (result == 0)
return NULL;
/* First, filter by positional arguments */
n = PyTuple_Size(args);
for (i=0; i<n; i++) {
PyObject *item = PyTuple_GET_ITEM(args, i);
if (item == Py_None) {
/* None means: select nothing */
igraph_es_destroy(&result->es);
igraph_es_none(&result->es);
/* We can simply bail out here */
return (PyObject*)result;
} else if (PyCallable_Check(item)) {
/* Call the callable for every edge in the current sequence to
* determine what's up */
igraph_bool_t was_excluded = 0;
igraph_vector_t v;
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
m = PySequence_Size((PyObject*)result);
for (j=0; j<m; j++) {
PyObject *edge = PySequence_GetItem((PyObject*)result, j);
PyObject *call_result;
if (edge == 0) {
Py_DECREF(result);
igraph_vector_destroy(&v);
return NULL;
}
call_result = PyObject_CallFunctionObjArgs(item, edge, NULL);
if (call_result == 0) {
Py_DECREF(edge); Py_DECREF(result);
igraph_vector_destroy(&v);
return NULL;
}
if (PyObject_IsTrue(call_result))
igraph_vector_push_back(&v,
igraphmodule_Edge_get_index_long((igraphmodule_EdgeObject*)edge));
else was_excluded=1;
Py_DECREF(call_result);
Py_DECREF(edge);
}
if (was_excluded) {
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return NULL;
}
}
igraph_vector_destroy(&v);
} else if (PyInt_Check(item)) {
/* Integers are treated specially: from now on, all remaining items
* in the argument list must be integers and they will be used together
* to restrict the edge set. Integers are interpreted as indices on the
* edge set and NOT on the original, untouched edge sequence of the
* graph */
igraph_vector_t v, v2;
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_vector_init(&v2, 0)) {
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_es_as_vector(&gr->g, self->es, &v2)) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
igraphmodule_handle_igraph_error();
return 0;
}
m = igraph_vector_size(&v2);
for (; i<n; i++) {
PyObject *item2 = PyTuple_GET_ITEM(args, i);
long idx;
if (!PyInt_Check(item2)) {
Py_DECREF(result);
PyErr_SetString(PyExc_TypeError, "edge indices expected");
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
idx = PyInt_AsLong(item2);
if (idx >= m || idx < 0) {
PyErr_SetString(PyExc_ValueError, "edge index out of range");
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
}
igraph_vector_destroy(&v2);
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return NULL;
}
igraph_vector_destroy(&v);
} else {
/* Iterators and everything that was not handled directly */
PyObject *iter, *item2;
igraph_vector_t v, v2;
/* Allocate stuff */
if (igraph_vector_init(&v, 0)) {
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_vector_init(&v2, 0)) {
igraph_vector_destroy(&v);
igraphmodule_handle_igraph_error();
return 0;
}
if (igraph_es_as_vector(&gr->g, self->es, &v2)) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
igraphmodule_handle_igraph_error();
return 0;
}
m = igraph_vector_size(&v2);
/* Create an appropriate iterator */
if (PySlice_Check(item)) {
/* Create an iterator from the slice (which is not iterable by default )*/
Py_ssize_t start, stop, step, sl;
PyObject* range;
igraph_bool_t ok;
/* Casting to void* because Python 2.x expects PySliceObject*
* but Python 3.x expects PyObject* */
ok = (PySlice_GetIndicesEx((void*)item, igraph_vector_size(&v2),
&start, &stop, &step, &sl) == 0);
if (ok) {
range = igraphmodule_PyRange_create(start, stop, step);
ok = (range != 0);
}
if (ok) {
iter = PyObject_GetIter(range);
Py_DECREF(range);
ok = (iter != 0);
}
if (!ok) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
PyErr_SetString(PyExc_TypeError, "error while converting slice to iterator");
Py_DECREF(result);
return 0;
}
} else {
/* Simply create the iterator corresponding to the object */
iter = PyObject_GetIter(item);
}
/* Did we manage to get an iterator? */
if (iter == 0) {
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
PyErr_SetString(PyExc_TypeError, "invalid edge filter among positional arguments");
Py_DECREF(result);
return 0;
}
/* Do the iteration */
while ((item2=PyIter_Next(iter)) != 0) {
if (PyInt_Check(item2)) {
long idx = PyInt_AsLong(item2);
Py_DECREF(item2);
if (idx >= m || idx < 0) {
PyErr_SetString(PyExc_ValueError, "edge index out of range");
Py_DECREF(result);
Py_DECREF(iter);
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
if (igraph_vector_push_back(&v, VECTOR(v2)[idx])) {
Py_DECREF(result);
Py_DECREF(iter);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
igraph_vector_destroy(&v2);
return NULL;
}
} else {
/* We simply ignore elements that we don't know */
Py_DECREF(item2);
}
}
/* Deallocate stuff */
igraph_vector_destroy(&v2);
Py_DECREF(iter);
if (PyErr_Occurred()) {
igraph_vector_destroy(&v);
Py_DECREF(result);
return 0;
}
igraph_es_destroy(&result->es);
if (igraph_es_vector_copy(&result->es, &v)) {
Py_DECREF(result);
igraphmodule_handle_igraph_error();
igraph_vector_destroy(&v);
return NULL;
}
igraph_vector_destroy(&v);
}
}
return (PyObject*)result;
}
PyObject* row_subscript(Row* self, PyObject* idx)
{
long _idx;
char* key;
int nitems, i;
char* compare_key;
char* p1;
char* p2;
PyObject* item;
if (PyInt_Check(idx)) {
_idx = PyInt_AsLong(idx);
item = PyTuple_GetItem(self->data, _idx);
Py_XINCREF(item);
return item;
} else if (PyLong_Check(idx)) {
_idx = PyLong_AsLong(idx);
item = PyTuple_GetItem(self->data, _idx);
Py_XINCREF(item);
return item;
} else if (PyString_Check(idx)) {
key = PyString_AsString(idx);
nitems = PyTuple_Size(self->description);
for (i = 0; i < nitems; i++) {
compare_key = PyString_AsString(PyTuple_GET_ITEM(PyTuple_GET_ITEM(self->description, i), 0));
if (!compare_key) {
return NULL;
}
p1 = key;
p2 = compare_key;
while (1) {
if ((*p1 == (char)0) || (*p2 == (char)0)) {
break;
}
if ((*p1 | 0x20) != (*p2 | 0x20)) {
break;
}
p1++;
p2++;
}
if ((*p1 == (char)0) && (*p2 == (char)0)) {
/* found item */
item = PyTuple_GetItem(self->data, i);
Py_INCREF(item);
return item;
}
}
PyErr_SetString(PyExc_IndexError, "No item with that key");
return NULL;
} else if (PySlice_Check(idx)) {
PyErr_SetString(PyExc_ValueError, "slices not implemented, yet");
return NULL;
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or string");
return NULL;
}
}
static PyObject *
BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
{
PyObject *processors, *values;
PyObject *processor, *value, *processed_value;
PyObject *row, *record, *result, *indexobject;
PyObject *exc_module, *exception, *cstr_obj;
#if PY_MAJOR_VERSION >= 3
PyObject *bytes;
#endif
char *cstr_key;
long index;
int key_fallback = 0;
int tuple_check = 0;
#if PY_MAJOR_VERSION < 3
if (PyInt_CheckExact(key)) {
index = PyInt_AS_LONG(key);
}
#endif
if (PyLong_CheckExact(key)) {
index = PyLong_AsLong(key);
if ((index == -1) && PyErr_Occurred())
/* -1 can be either the actual value, or an error flag. */
return NULL;
} else if (PySlice_Check(key)) {
values = PyObject_GetItem(self->row, key);
if (values == NULL)
return NULL;
processors = PyObject_GetItem(self->processors, key);
if (processors == NULL) {
Py_DECREF(values);
return NULL;
}
result = BaseRowProxy_processvalues(values, processors, 1);
Py_DECREF(values);
Py_DECREF(processors);
return result;
} else {
record = PyDict_GetItem((PyObject *)self->keymap, key);
if (record == NULL) {
record = PyObject_CallMethod(self->parent, "_key_fallback",
"O", key);
if (record == NULL)
return NULL;
key_fallback = 1;
}
indexobject = PyTuple_GetItem(record, 2);
if (indexobject == NULL)
return NULL;
if (key_fallback) {
Py_DECREF(record);
}
if (indexobject == Py_None) {
exc_module = PyImport_ImportModule("sqlalchemy.exc");
if (exc_module == NULL)
return NULL;
exception = PyObject_GetAttrString(exc_module,
"InvalidRequestError");
Py_DECREF(exc_module);
if (exception == NULL)
return NULL;
// wow. this seems quite excessive.
cstr_obj = PyObject_Str(key);
if (cstr_obj == NULL)
return NULL;
/*
FIXME: raise encoding error exception (in both versions below)
if the key contains non-ascii chars, instead of an
InvalidRequestError without any message like in the
python version.
*/
#if PY_MAJOR_VERSION >= 3
bytes = PyUnicode_AsASCIIString(cstr_obj);
if (bytes == NULL)
return NULL;
cstr_key = PyBytes_AS_STRING(bytes);
#else
cstr_key = PyString_AsString(cstr_obj);
#endif
if (cstr_key == NULL) {
Py_DECREF(cstr_obj);
return NULL;
}
Py_DECREF(cstr_obj);
PyErr_Format(exception,
"Ambiguous column name '%.200s' in result set! "
"try 'use_labels' option on select statement.", cstr_key);
return NULL;
}
#if PY_MAJOR_VERSION >= 3
index = PyLong_AsLong(indexobject);
#else
index = PyInt_AsLong(indexobject);
#endif
if ((index == -1) && PyErr_Occurred())
/* -1 can be either the actual value, or an error flag. */
return NULL;
}
processor = PyList_GetItem(self->processors, index);
if (processor == NULL)
return NULL;
row = self->row;
if (PyTuple_CheckExact(row)) {
value = PyTuple_GetItem(row, index);
tuple_check = 1;
}
else {
value = PySequence_GetItem(row, index);
tuple_check = 0;
}
if (value == NULL)
return NULL;
if (processor != Py_None) {
processed_value = PyObject_CallFunctionObjArgs(processor, value, NULL);
if (!tuple_check) {
Py_DECREF(value);
}
return processed_value;
} else {
if (tuple_check) {
Py_INCREF(value);
}
return value;
}
}
static PyObject *
record_subscript(ApgRecordObject* o, PyObject* item)
{
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
if (i < 0) {
i += Py_SIZE(o);
}
return record_item(o, i);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
PyObject* result;
PyObject* it;
PyObject **src, **dest;
if (PySlice_GetIndicesEx(
item,
Py_SIZE(o),
&start, &stop, &step, &slicelength) < 0)
{
return NULL;
}
if (slicelength <= 0) {
return PyTuple_New(0);
}
else {
result = PyTuple_New(slicelength);
if (!result) return NULL;
src = o->ob_item;
dest = ((PyTupleObject *)result)->ob_item;
for (cur = start, i = 0; i < slicelength; cur += step, i++) {
it = src[cur];
Py_INCREF(it);
dest[i] = it;
}
return result;
}
}
else {
PyObject *mapped;
mapped = PyObject_GetItem(o->mapping, item);
if (mapped != NULL) {
Py_ssize_t i;
PyObject *result;
if (!PyIndex_Check(mapped)) {
Py_DECREF(mapped);
goto noitem;
}
i = PyNumber_AsSsize_t(mapped, PyExc_IndexError);
Py_DECREF(mapped);
if (i < 0) {
if (PyErr_Occurred()) {
PyErr_Clear();
}
goto noitem;
}
result = record_item(o, i);
if (result == NULL) {
PyErr_Clear();
goto noitem;
}
return result;
}
else {
goto noitem;
}
}
noitem:
_PyErr_SetKeyError(item);
return NULL;
}
/*
* Implement mapping assignment sub-script for the type.
*/
static int sipVoidPtr_ass_subscript(PyObject *self, PyObject *key,
PyObject *value)
{
sipVoidPtrObject *v;
Py_ssize_t start, size;
#if PY_VERSION_HEX >= 0x02060000
Py_buffer value_view;
#else
Py_ssize_t value_size;
void *value_ptr;
#endif
if (check_rw(self) < 0 || check_size(self) < 0)
return -1;
v = (sipVoidPtrObject *)self;
if (PyIndex_Check(key))
{
start = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (start == -1 && PyErr_Occurred())
return -1;
if (start < 0)
start += v->size;
if (check_index(self, start) < 0)
return -1;
size = 1;
}
else if (PySlice_Check(key))
{
Py_ssize_t stop, step;
if (sipConvertFromSliceObject(key, v->size, &start, &stop, &step, &size) < 0)
return -1;
if (step != 1)
{
PyErr_SetNone(PyExc_NotImplementedError);
return -1;
}
}
else
{
bad_key(key);
return -1;
}
#if PY_VERSION_HEX >= 0x02060000
if (PyObject_GetBuffer(value, &value_view, PyBUF_CONTIG_RO) < 0)
return -1;
/* We could allow any item size... */
if (value_view.itemsize != 1)
{
PyErr_Format(PyExc_TypeError, "'%s' must have an item size of 1",
Py_TYPE(value_view.obj)->tp_name);
PyBuffer_Release(&value_view);
return -1;
}
if (check_slice_size(size, value_view.len) < 0)
{
PyBuffer_Release(&value_view);
return -1;
}
memmove((char *)v->voidptr + start, value_view.buf, size);
PyBuffer_Release(&value_view);
#else
if ((value_size = get_value_data(value, &value_ptr)) < 0)
return -1;
if (check_slice_size(size, value_size) < 0)
return -1;
memmove((char *)v->voidptr + start, value_ptr, size);
#endif
return 0;
}
CvRect PySlice_to_CvRect(CvArr * src, PyObject * idx_object){
CvSize sz = cvGetSize(src);
//printf("Size %dx%d\n", sz.height, sz.width);
int lower[2], upper[2];
Py_ssize_t len, start, stop, step, slicelength;
if(PyInt_Check(idx_object) || PyLong_Check(idx_object)){
// if array is a row vector, assume index into columns
if(sz.height>1){
lower[0] = PyLong_AsIndex( idx_object, sz.height );
upper[0] = lower[0] + 1;
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[0] = 0;
upper[0] = sz.height;
lower[1] = PyLong_AsIndex( idx_object, sz.width );
upper[1] = lower[1]+1;
}
}
// 1. Slice
else if(PySlice_Check(idx_object)){
len = sz.height;
if(PySlice_GetIndicesEx( (PySliceObject*)idx_object, len, &start, &stop, &step, &slicelength )!=0){
printf("Error in PySlice_GetIndicesEx: returning NULL");
PyErr_SetString(PyExc_Exception, "Error");
return cvRect(0,0,0,0);
}
// if array is a row vector, assume index bounds are into columns
if(sz.height>1){
lower[0] = (int) start; // use c convention of start index = 0
upper[0] = (int) stop; // use c convention
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[1] = (int) start; // use c convention of start index = 0
upper[1] = (int) stop; // use c convention
lower[0] = 0;
upper[0] = sz.height;
}
}
// 2. Tuple
else if(PyTuple_Check(idx_object)){
//printf("PyTuple{\n");
if(PyObject_Length(idx_object)!=2){
//printf("Expected a sequence of length 2: returning NULL");
PyErr_SetString(PyExc_ValueError, "Expected a sequence with 2 elements");
return cvRect(0,0,0,0);
}
for(int i=0; i<2; i++){
PyObject *o = PyTuple_GetItem(idx_object, i);
// 2a. Slice -- same as above
if(PySlice_Check(o)){
//printf("PySlice\n");
len = (i==0 ? sz.height : sz.width);
if(PySlice_GetIndicesEx( (PySliceObject*)o, len, &start, &stop, &step, &slicelength )!=0){
PyErr_SetString(PyExc_Exception, "Error");
printf("Error in PySlice_GetIndicesEx: returning NULL");
return cvRect(0,0,0,0);
}
//printf("PySlice_GetIndecesEx(%d, %d, %d, %d, %d)\n", len, start, stop, step, slicelength);
lower[i] = start;
upper[i] = stop;
}
// 2b. Integer
else if(PyInt_Check(o) || PyLong_Check(o)){
//printf("PyInt\n");
lower[i] = PyLong_AsIndex(o, i==0 ? sz.height : sz.width);
upper[i] = lower[i]+1;
}
else {
PyErr_SetString(PyExc_TypeError, "Expected a sequence of slices or integers");
printf("Expected a slice or int as sequence item: returning NULL");
return cvRect(0,0,0,0);
}
}
}
else {
PyErr_SetString( PyExc_TypeError, "Expected a slice or sequence");
printf("Expected a slice or sequence: returning NULL");
return cvRect(0,0,0,0);
}
//lower[0] = MAX(0, lower[0]);
//lower[1] = MAX(0, lower[1]);
//upper[0] = MIN(sz.height, upper[0]);
//upper[1] = MIN(sz.width, upper[1]);
//printf("Slice=%d %d %d %d\n", lower[0], upper[0], lower[1], upper[1]);
return cvRect(lower[1],lower[0], upper[1]-lower[1], upper[0]-lower[0]);
}
static int
buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
{
PyBufferProcs *pb;
void *ptr1, *ptr2;
Py_ssize_t selfsize;
Py_ssize_t othersize;
if ( self->b_readonly ) {
PyErr_SetString(PyExc_TypeError,
"buffer is read-only");
return -1;
}
pb = value ? value->ob_type->tp_as_buffer : NULL;
if ( pb == NULL ||
pb->bf_getreadbuffer == NULL ||
pb->bf_getsegcount == NULL )
{
PyErr_BadArgument();
return -1;
}
if ( (*pb->bf_getsegcount)(value, NULL) != 1 )
{
/* ### use a different exception type/message? */
PyErr_SetString(PyExc_TypeError,
"single-segment buffer object expected");
return -1;
}
if (!get_buf(self, &ptr1, &selfsize, ANY_BUFFER))
return -1;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += selfsize;
return buffer_ass_item(self, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((PySliceObject *)item, selfsize,
&start, &stop, &step, &slicelength) < 0)
return -1;
if ((othersize = (*pb->bf_getreadbuffer)(value, 0, &ptr2)) < 0)
return -1;
if (othersize != slicelength) {
PyErr_SetString(
PyExc_TypeError,
"right operand length must match slice length");
return -1;
}
if (slicelength == 0)
return 0;
else if (step == 1) {
memcpy((char *)ptr1 + start, ptr2, slicelength);
return 0;
}
else {
Py_ssize_t cur, i;
for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
((char *)ptr1)[cur] = ((char *)ptr2)[i];
}
return 0;
}
} else {
PyErr_SetString(PyExc_TypeError,
"buffer indices must be integers");
return -1;
}
}
static PyObject *
BaseRowProxy_subscript(BaseRowProxy *self, PyObject *key)
{
PyObject *processors, *values;
PyObject *processor, *value, *processed_value;
PyObject *row, *record, *result, *indexobject;
PyObject *exc_module, *exception;
char *cstr_key;
long index;
int key_fallback = 0;
int tuple_check = 0;
if (PyInt_CheckExact(key)) {
index = PyInt_AS_LONG(key);
} else if (PyLong_CheckExact(key)) {
index = PyLong_AsLong(key);
if ((index == -1) && PyErr_Occurred())
/* -1 can be either the actual value, or an error flag. */
return NULL;
} else if (PySlice_Check(key)) {
values = PyObject_GetItem(self->row, key);
if (values == NULL)
return NULL;
processors = PyObject_GetItem(self->processors, key);
if (processors == NULL) {
Py_DECREF(values);
return NULL;
}
result = BaseRowProxy_processvalues(values, processors, 1);
Py_DECREF(values);
Py_DECREF(processors);
return result;
} else {
record = PyDict_GetItem((PyObject *)self->keymap, key);
if (record == NULL) {
record = PyObject_CallMethod(self->parent, "_key_fallback",
"O", key);
if (record == NULL)
return NULL;
key_fallback = 1;
}
indexobject = PyTuple_GetItem(record, 2);
if (indexobject == NULL)
return NULL;
if (key_fallback) {
Py_DECREF(record);
}
if (indexobject == Py_None) {
exc_module = PyImport_ImportModule("sqlalchemy.exc");
if (exc_module == NULL)
return NULL;
exception = PyObject_GetAttrString(exc_module,
"InvalidRequestError");
Py_DECREF(exc_module);
if (exception == NULL)
return NULL;
cstr_key = PyString_AsString(key);
if (cstr_key == NULL)
return NULL;
PyErr_Format(exception,
"Ambiguous column name '%.200s' in result set! "
"try 'use_labels' option on select statement.", cstr_key);
return NULL;
}
index = PyInt_AsLong(indexobject);
if ((index == -1) && PyErr_Occurred())
/* -1 can be either the actual value, or an error flag. */
return NULL;
}
processor = PyList_GetItem(self->processors, index);
if (processor == NULL)
return NULL;
row = self->row;
if (PyTuple_CheckExact(row)) {
value = PyTuple_GetItem(row, index);
tuple_check = 1;
}
else {
value = PySequence_GetItem(row, index);
tuple_check = 0;
}
if (value == NULL)
return NULL;
if (processor != Py_None) {
processed_value = PyObject_CallFunctionObjArgs(processor, value, NULL);
if (!tuple_check) {
Py_DECREF(value);
}
return processed_value;
} else {
if (tuple_check) {
Py_INCREF(value);
}
return value;
}
}
PyObject* pysqlite_row_subscript(pysqlite_Row* self, PyObject* idx)
{
Py_ssize_t _idx;
char* key;
Py_ssize_t nitems, i;
char* compare_key;
char* p1;
char* p2;
PyObject* item;
if (PyLong_Check(idx)) {
_idx = PyNumber_AsSsize_t(idx, PyExc_IndexError);
if (_idx == -1 && PyErr_Occurred())
return NULL;
if (_idx < 0)
_idx += PyTuple_GET_SIZE(self->data);
item = PyTuple_GetItem(self->data, _idx);
Py_XINCREF(item);
return item;
#if PY_MAJOR_VERSION < 3
} else if (PyString_Check(idx)) {
key = PyString_AsString(idx);
#else
} else if (PyUnicode_Check(idx)) {
key = _PyUnicode_AsString(idx);
#endif
if (key == NULL)
return NULL;
nitems = PyTuple_Size(self->description);
for (i = 0; i < nitems; i++) {
PyObject *obj;
obj = PyTuple_GET_ITEM(self->description, i);
obj = PyTuple_GET_ITEM(obj, 0);
#if PY_MAJOR_VERSION < 3
compare_key = PyString_AsString(obj);
#else
compare_key = _PyUnicode_AsString(obj);
#endif
if (!compare_key) {
return NULL;
}
p1 = key;
p2 = compare_key;
while (1) {
if ((*p1 == (char)0) || (*p2 == (char)0)) {
break;
}
if ((*p1 | 0x20) != (*p2 | 0x20)) {
break;
}
p1++;
p2++;
}
if ((*p1 == (char)0) && (*p2 == (char)0)) {
/* found item */
item = PyTuple_GetItem(self->data, i);
Py_INCREF(item);
return item;
}
}
PyErr_SetString(PyExc_IndexError, "No item with that key");
return NULL;
} else if (PySlice_Check(idx)) {
return PyObject_GetItem(self->data, idx);
} else {
PyErr_SetString(PyExc_IndexError, "Index must be int or string");
return NULL;
}
}
static int
pr_ass_sub(PyGimpPixelRgn *self, PyObject *v, PyObject *w)
{
GimpPixelRgn *pr = &(self->pr);
PyObject *x, *y;
const guchar *buf;
Py_ssize_t len, x1, x2, xs, y1, y2, ys;
if (w == NULL) {
PyErr_SetString(PyExc_TypeError, "can't delete subscripts");
return -1;
}
if (!PyString_Check(w)) {
PyErr_SetString(PyExc_TypeError, "must assign string to subscript");
return -1;
}
if (!PyTuple_Check(v) || PyTuple_Size(v) != 2) {
PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
return -1;
}
if (!PyArg_ParseTuple(v, "OO", &x, &y))
return -1;
buf = (const guchar *)PyString_AsString(w);
len = PyString_Size(w);
if (!buf || len > INT_MAX) {
return -1;
}
if (PyInt_Check(x)) {
x1 = PyInt_AsSsize_t(x);
if (x1 < pr->x || x1 >= pr->x + pr->w) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return -1;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_pixel(pr, buf, x1, y1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return -1;
}
if (y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (y2 - y1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_col(pr, buf, x1, y1, y2 - y1);
} else {
PyErr_SetString(PyExc_IndexError,"invalid y subscript");
return -1;
}
} else if (PySlice_Check(x)) {
if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w,
&x1, &x2, &xs) ||
x1 >= x2 || xs != 1) {
PyErr_SetString(PyExc_IndexError, "invalid x slice");
return -1;
}
if(x1 == 0)
x1 = pr->x;
if(x1 < pr->x || x2 < pr->x) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return -1;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (x2 - x1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_row(pr, buf, x1, y1, x2 - x1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject *)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return -1;
}
if (y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return -1;
}
if (len != pr->bpp * (x2 - x1) * (y2 - y1)) {
PyErr_SetString(PyExc_TypeError, "string is wrong length");
return -1;
}
gimp_pixel_rgn_set_rect(pr, buf, x1, y1, x2 - x1, y2 - y1);
} else {
PyErr_SetString(PyExc_IndexError,"invalid y subscript");
return -1;
}
} else {
PyErr_SetString(PyExc_TypeError, "invalid x subscript");
return -1;
}
return 0;
}
static int
mmap_ass_subscript(mmap_object *self, PyObject *item, PyObject *value)
{
CHECK_VALID(-1);
if (!is_writable(self))
return -1;
if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
Py_ssize_t v;
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0)
i += self->size;
if (i < 0 || i >= self->size) {
PyErr_SetString(PyExc_IndexError,
"mmap index out of range");
return -1;
}
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
"mmap doesn't support item deletion");
return -1;
}
if (!PyIndex_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"mmap item value must be an int");
return -1;
}
v = PyNumber_AsSsize_t(value, PyExc_TypeError);
if (v == -1 && PyErr_Occurred())
return -1;
if (v < 0 || v > 255) {
PyErr_SetString(PyExc_ValueError,
"mmap item value must be "
"in range(0, 256)");
return -1;
}
self->data[i] = (char) v;
return 0;
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelen;
Py_buffer vbuf;
if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
return -1;
}
slicelen = PySlice_AdjustIndices(self->size, &start, &stop, step);
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
"mmap object doesn't support slice deletion");
return -1;
}
if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)
return -1;
if (vbuf.len != slicelen) {
PyErr_SetString(PyExc_IndexError,
"mmap slice assignment is wrong size");
PyBuffer_Release(&vbuf);
return -1;
}
if (slicelen == 0) {
}
else if (step == 1) {
memcpy(self->data + start, vbuf.buf, slicelen);
}
else {
Py_ssize_t cur, i;
for (cur = start, i = 0;
i < slicelen;
cur += step, i++)
{
self->data[cur] = ((char *)vbuf.buf)[i];
}
}
PyBuffer_Release(&vbuf);
return 0;
}
else {
PyErr_SetString(PyExc_TypeError,
"mmap indices must be integer");
return -1;
}
}
/* This function is based on list_ass_subscript from Python source listobject.c.
But it uses LDAPValueList's setslice and setitem functions instead of memory opertation.
It is probably a much more slower, but cleaner solution.
*/
static int
LVL_ass_subscript(LDAPValueList *self, PyObject *item, PyObject *value) {
size_t cur;
Py_ssize_t i;
Py_ssize_t start, stop, step, slicelength;
PyObject *seq;
PyObject **seqitems;
if (PyIndex_Check(item)) {
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) return -1;
if (i < 0) i += PyList_GET_SIZE(self);
return LVL_ass_item(self, i, value);
} else if (PySlice_Check(item)) {
if (PySlice_GetIndicesEx(item, Py_SIZE(self), &start, &stop, &step, &slicelength) < 0) {
return -1;
}
if (step == 1) return LDAPValueList_SetSlice(self, start, stop, value);
/* Make sure s[5:2] = [..] inserts at the right place:
before 5, not before 2. */
if ((step < 0 && start < stop) || (step > 0 && start > stop)) {
stop = start;
}
if (value == NULL) {
/* delete slice */
if (slicelength <= 0) return 0;
if (step < 0) {
stop = start + 1;
start = stop + step*(slicelength - 1) - 1;
step = -step;
}
for (cur = start, i = 0; cur < (size_t)stop; cur += step, i++) {
if (LDAPValueList_SetSlice(self, cur-i, cur+1-i, (PyObject *)NULL) != 0) {
return -1;
}
}
return 0;
} else {
/* assign slice */
/* protect against a[::-1] = a */
if (self == (LDAPValueList*)value) {
seq = PyList_GetSlice(value, 0, PyList_GET_SIZE(value));
} else {
seq = PySequence_Fast(value, "must assign iterable to extended slice");
}
if (!seq) return -1;
if (PySequence_Fast_GET_SIZE(seq) != slicelength) {
PyErr_Format(PyExc_ValueError, "attempt to assign sequence of size %zd to extended slice of "
"size %zd", PySequence_Fast_GET_SIZE(seq), slicelength);
Py_DECREF(seq);
return -1;
}
if (!slicelength) {
Py_DECREF(seq);
return 0;
}
seqitems = PySequence_Fast_ITEMS(seq);
for (cur = start, i = 0; i < slicelength; cur += (size_t)step, i++) {
if (LDAPValueList_SetItem(self, cur, seqitems[i]) != 0) {
return -1;
}
}
Py_DECREF(seq);
return 0;
}
} else {
PyErr_Format(PyExc_TypeError, "list indices must be integers, not %.200s", item->ob_type->tp_name);
return -1;
}
}
static PyObject *PY_pdbdata_mp_subscript(PyObject *_self, PyObject *key)
{Py_ssize_t nitems;
PY_pdbdata *self;
PyObject *rv = NULL;
PP_form *form;
self = (PY_pdbdata *) _self;
/* find length of available data */
if (self->data == NULL)
nitems = 0;
else if (self->dims == NULL)
nitems = 1;
else
nitems = self->dims->number;
if (PyIndex_Check(key)) {
Py_ssize_t i;
i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i < 0)
i += nitems;
if (i >= nitems) {
if (indexerr == NULL)
indexerr = PY_STRING_STRING("pdbdata index out of range");
PyErr_SetObject(PyExc_IndexError, indexerr);
}
else {
form = &PP_global_form;
/* special case indexing a scalar item */
if (nitems == 1 && form->scalar_kind == AS_PDBDATA) {
Py_INCREF(self);
rv = (PyObject *) self;
} else {
void *vr;
vr = ((char *) self->data) + i * self->dp->size;
rv = PP_form_object(vr, self->type, 1, NULL,
self->dp, self->fileinfo, self->dpobj,
(PyObject *) self, form);
}
}
} else if (PySlice_Check(key)) {
Py_ssize_t start, stop, step, length;
void *vr;
dimdes *dims;
if (PySlice_GetIndicesEx(
#if PY_MAJOR_VERSION >= 3
key,
#else
(PySliceObject*)key,
#endif
nitems, &start, &stop,
&step, &length) == 0) {
form = &PP_global_form;
vr = ((char *) self->data) + start * self->dp->size;
dims = _PD_mk_dimensions(0, length);
SC_mark(dims, 1);
rv = PP_form_object(vr, self->type, length, dims,
self->dp, self->fileinfo, self->dpobj,
(PyObject *) self, form);
_PD_rl_dimensions(dims);
}
} else {
PyErr_Format(PyExc_TypeError,
"pdbdata indices must be integers, not %.200s",
key->ob_type->tp_name);
}
return rv;
}
static PyObject *
pr_subscript(PyGimpPixelRgn *self, PyObject *key)
{
GimpPixelRgn *pr = &(self->pr);
PyObject *x, *y;
Py_ssize_t x1, y1, x2, y2, xs, ys;
PyObject *ret;
if (!PyTuple_Check(key) || PyTuple_Size(key) != 2) {
PyErr_SetString(PyExc_TypeError, "subscript must be a 2-tuple");
return NULL;
}
if (!PyArg_ParseTuple(key, "OO", &x, &y))
return NULL;
if (PyInt_Check(x)) {
x1 = PyInt_AsSsize_t(x);
if (x1 < pr->x || x1 >= pr->x + pr->w) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return NULL;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp);
gimp_pixel_rgn_get_pixel(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return NULL;
}
if(y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp * (y2 - y1));
gimp_pixel_rgn_get_col(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1, y2-y1);
}
else {
PyErr_SetString(PyExc_TypeError, "invalid y subscript");
return NULL;
}
} else if (PySlice_Check(x)) {
if (PySlice_GetIndices((PySliceObject *)x, pr->x + pr->w,
&x1, &x2, &xs) ||
x1 >= x2 || xs != 1) {
PyErr_SetString(PyExc_IndexError, "invalid x slice");
return NULL;
}
if (x1 == 0)
x1 = pr->x;
if(x1 < pr->x || x2 < pr->x) {
PyErr_SetString(PyExc_IndexError, "x subscript out of range");
return NULL;
}
if (PyInt_Check(y)) {
y1 = PyInt_AsSsize_t(y);
if (y1 < pr->y || y1 >= pr->y + pr->h) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL, pr->bpp * (x2 - x1));
gimp_pixel_rgn_get_row(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1, x2 - x1);
} else if (PySlice_Check(y)) {
if (PySlice_GetIndices((PySliceObject*)y, pr->y + pr->h,
&y1, &y2, &ys) ||
y1 >= y2 || ys != 1) {
PyErr_SetString(PyExc_IndexError, "invalid y slice");
return NULL;
}
if(y1 == 0)
y1 = pr->y;
if(y1 < pr->y || y2 < pr->y) {
PyErr_SetString(PyExc_IndexError, "y subscript out of range");
return NULL;
}
ret = PyString_FromStringAndSize(NULL,
pr->bpp * (x2 - x1) * (y2 - y1));
gimp_pixel_rgn_get_rect(pr, (guchar*)PyString_AS_STRING(ret),
x1, y1, x2 - x1, y2 - y1);
}
else {
PyErr_SetString(PyExc_TypeError, "invalid y subscript");
return NULL;
}
} else {
PyErr_SetString(PyExc_TypeError, "invalid x subscript");
return NULL;
}
return ret;
}
