static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *value) { 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 += EULER_SIZE; return Euler_ass_item(self, i, value); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength; if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0) return -1; if (step == 1) return Euler_ass_slice(self, start, stop, value); else { PyErr_SetString(PyExc_IndexError, "slice steps not supported with euler"); return -1; } } else { PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name); return -1; } }
static Py_ssize_t BufferAsSubscript(PyObject *self, PyObject* idx, PyObject* val) { if (PyLong_Check(idx)) { long n = PyLong_AsLong(idx); return RBAsItem((BufferObject *)(self), n, val, 1, (Py_ssize_t)((BufferObject *)(self))->buf->b_ml.ml_line_count, NULL); } 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 -1; } return RBAsSlice((BufferObject *)(self), start, stop, val, 1, (PyInt)((BufferObject *)(self))->buf->b_ml.ml_line_count, NULL); } else { PyErr_SetString(PyExc_IndexError, "Index must be int or slice"); return -1; } }
static PyObject* tuplesubscript(PyTupleObject* self, 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 += PyTuple_GET_SIZE(self); return tupleitem(self, 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, PyTuple_GET_SIZE(self), &start, &stop, &step, &slicelength) < 0) { return NULL; } if (slicelength <= 0) { return PyTuple_New(0); } else if (start == 0 && step == 1 && slicelength == PyTuple_GET_SIZE(self) && PyTuple_CheckExact(self)) { Py_INCREF(self); return (PyObject *)self; } else { result = PyTuple_New(slicelength); if (!result) return NULL; src = self->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 { PyErr_Format(PyExc_TypeError, "tuple indices must be integers, not %.200s", Py_TYPE(item)->tp_name); return NULL; } }
static PyObject * buffer_subscript(PyBufferObject *self, PyObject *item) { void *p; Py_ssize_t size; if (!get_buf(self, &p, &size, ANY_BUFFER)) return NULL; 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 += size; return buffer_item(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength, cur, i; if (PySlice_GetIndicesEx((PySliceObject*)item, size, &start, &stop, &step, &slicelength) < 0) { return NULL; } if (slicelength <= 0) return PyString_FromStringAndSize("", 0); else if (step == 1) return PyString_FromStringAndSize((char *)p + start, stop - start); else { PyObject *result; char *source_buf = (char *)p; char *result_buf = (char *)PyMem_Malloc(slicelength); if (result_buf == NULL) return PyErr_NoMemory(); for (cur = start, i = 0; i < slicelength; cur += step, i++) { result_buf[i] = source_buf[cur]; } result = PyString_FromStringAndSize(result_buf, slicelength); PyMem_Free(result_buf); return result; } } else { PyErr_SetString(PyExc_TypeError, "sequence index must be integer"); return NULL; } }
static PyObject * GMPy_XMPZ_Method_SubScript(XMPZ_Object* self, PyObject* item) { CTXT_Object *context = NULL; CHECK_CONTEXT(context); if (PyIndex_Check(item)) { Py_ssize_t i; i = PyIntOrLong_AsSsize_t(item); if (i == -1 && PyErr_Occurred()) { INDEX_ERROR("argument too large to be converted to an index"); return NULL; } if (i < 0) { i += mpz_sizeinbase(self->z, 2); } return PyIntOrLong_FromLong(mpz_tstbit(self->z, i)); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength, cur, i; MPZ_Object *result; #if PY_VERSION_HEX > 0x030200A4 if (PySlice_GetIndicesEx(item, #else if (PySlice_GetIndicesEx((PySliceObject*)item, #endif mpz_sizeinbase(self->z, 2), &start, &stop, &step, &slicelength) < 0) { return NULL; } if ((step < 0 && start < stop) || (step > 0 && start > stop)) { stop = start; } if (!(result = GMPy_MPZ_New(context))) { return NULL; } mpz_set_ui(result->z, 0); if (slicelength > 0) { for (cur = start, i = 0; i < slicelength; cur += step, i++) { if (mpz_tstbit(self->z, cur)) { mpz_setbit(result->z, i); } } } return (PyObject*)result; } else {
static PyObject * mmap_subscript(mmap_object *self, PyObject *item) { CHECK_VALID(NULL); 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 += self->size; if (i < 0 || i >= self->size) { PyErr_SetString(PyExc_IndexError, "mmap index out of range"); return NULL; } return PyLong_FromLong(Py_CHARMASK(self->data[i])); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelen; if (PySlice_GetIndicesEx(item, self->size, &start, &stop, &step, &slicelen) < 0) { return NULL; } if (slicelen <= 0) return PyBytes_FromStringAndSize("", 0); else if (step == 1) return PyBytes_FromStringAndSize(self->data + start, slicelen); else { char *result_buf = (char *)PyMem_Malloc(slicelen); Py_ssize_t cur, i; PyObject *result; if (result_buf == NULL) return PyErr_NoMemory(); for (cur = start, i = 0; i < slicelen; cur += step, i++) { result_buf[i] = self->data[cur]; } result = PyBytes_FromStringAndSize(result_buf, slicelen); PyMem_Free(result_buf); return result; } } else { PyErr_SetString(PyExc_TypeError, "mmap indices must be integers"); return NULL; } }
static PyObj array_subscript(PyObj self, PyObj arg) { Py_ssize_t len = py_array_length(self); if (PyIndex_Check(arg)) { Py_ssize_t i = PyNumber_AsSsize_t(arg, PyExc_IndexError); if (i == -1 && PyErr_Occurred()) return(NULL); if (i < 0) i += py_array_length(self); return(array_item(self, i)); } else if (PySlice_Check(arg)) { Py_ssize_t start, stop, step, slicelength; int r; r = PySlice_GetIndicesEx(arg, len, &start, &stop, &step, &slicelength); if (r < 0) return(NULL); if (step != 1) { /* TODO: implement custom step values for array subscript */ PyErr_Format(PyExc_NotImplementedError, "unsupported step value in array subscript"); return(NULL); } if (slicelength == len && start == 0) { Py_INCREF(self); return(self); } return(array_slice(self, start, stop)); } else { PyErr_Format(PyExc_TypeError, "array indexes must be integers, not %.200s", Py_TYPE(arg)->tp_name); return(NULL); } }
// range can not be directly converted from slice (slice is more complex) // convert from python slice and int (interpreted are slice(i,i+1,1)) triqs::arrays::range range_from_slice(PyObject *ob, long len) { if (PyInt_Check(ob)) { long i = PyInt_AsLong(ob); if ((i < -len) || (i >= len)) TRIQS_RUNTIME_ERROR << "Integer index out of range : expected [0," << len << "], got " << i; if (i < 0) i += len; // std::cerr << " range int "<< i << std::endl; return {i, i + 1, 1}; } Py_ssize_t start, stop, step, slicelength; if (!PySlice_Check(ob) || (PySlice_GetIndicesEx((PySliceObject *)ob, len, &start, &stop, &step, &slicelength) < 0)) TRIQS_RUNTIME_ERROR << "Can not converted the slice to C++"; // std::cerr << "range ( "<< start << " "<< stop << " " << step<<std::endl; return {start, stop, step}; }
static boost::python::list getSlice( Set &s, boost::python::slice sl ) { Py_ssize_t start, stop, step, length; if( PySlice_GetIndicesEx( (PySliceObject *)sl.ptr(), s.size(), &start, &stop, &step, &length ) ) { boost::python::throw_error_already_set(); } boost::python::list result; for( Py_ssize_t i = start; i < stop; i++ ) { result.append( Set::MemberPtr( s.member( i ) ) ); } return result; }
static PyObject * structseq_subscript(PyStructSequence *self, 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 += VISIBLE_SIZE(self); if (i < 0 || i >= VISIBLE_SIZE(self)) { PyErr_SetString(PyExc_IndexError, "tuple index out of range"); return NULL; } Py_INCREF(self->ob_item[i]); return self->ob_item[i]; } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelen, cur, i; PyObject *result; if (PySlice_GetIndicesEx((PySliceObject *)item, VISIBLE_SIZE(self), &start, &stop, &step, &slicelen) < 0) { return NULL; } if (slicelen <= 0) return PyTuple_New(0); result = PyTuple_New(slicelen); if (result == NULL) return NULL; for (cur = start, i = 0; i < slicelen; cur += step, i++) { PyObject *v = self->ob_item[cur]; Py_INCREF(v); PyTuple_SET_ITEM(result, i, v); } return result; } else { PyErr_SetString(PyExc_TypeError, "structseq index must be integer"); return NULL; } }
static PyObject* slice_indices(PySliceObject* self, PyObject* len) { Py_ssize_t ilen, start, stop, step, slicelength; ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError); if (ilen == -1 && PyErr_Occurred()) { return NULL; } if (PySlice_GetIndicesEx(self, ilen, &start, &stop, &step, &slicelength) < 0) { return NULL; } return Py_BuildValue("(nnn)", start, stop, step); }
static PyObject *listvalue_mapping_subscript(PyObject *self, PyObject *key) { CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self)); if (list==NULL) { PyErr_SetString(PyExc_SystemError, "value = CList[i], "BGE_PROXY_ERROR_MSG); return NULL; } if (PyUnicode_Check(key)) { CValue *item = ((CListValue*) list)->FindValue(_PyUnicode_AsString(key)); if (item) { PyObject *pyobj = item->ConvertValueToPython(); if (pyobj) return pyobj; else return item->GetProxy(); } } else if (PyIndex_Check(key)) { Py_ssize_t index = PyLong_AsSsize_t(key); return listvalue_buffer_item(self, index); /* wont add a ref */ } else if (PySlice_Check(key)) { Py_ssize_t start, stop, step, slicelength; if (PySlice_GetIndicesEx(key, list->GetCount(), &start, &stop, &step, &slicelength) < 0) return NULL; if (slicelength <= 0) { return PyList_New(0); } else if (step == 1) { return listvalue_buffer_slice(list, start, stop); } else { PyErr_SetString(PyExc_TypeError, "CList[slice]: slice steps not supported"); return NULL; } } PyErr_Format(PyExc_KeyError, "CList[key]: '%R' key not in list", key); return NULL; }
static PyObject * Pyxmpz_subscript(PyxmpzObject* 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 += mpz_sizeinbase(self->z, 2); return PyIntOrLong_FromLong(mpz_tstbit(self->z, i)); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength, cur, i; PyObject* result; #if PY_VERSION_HEX > 0x030200A4 if (PySlice_GetIndicesEx(item, #else if (PySlice_GetIndicesEx((PySliceObject*)item, #endif mpz_sizeinbase(self->z, 2), &start, &stop, &step, &slicelength) < 0) { return NULL; } if ((step < 0 && start < stop) || (step > 0 && start > stop)) stop = start; if (!(result = (PyObject*)Pympz_new())) return NULL; mpz_set_ui(Pympz_AS_MPZ(result), 0); if (slicelength > 0) { for (cur = start, i = 0; i < slicelength; cur += step, i++) { if (mpz_tstbit(self->z, cur)) { mpz_setbit(Pympz_AS_MPZ(result), i); } } } return result; } else {
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 * 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; } }
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 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 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 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; } }
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 int slot_QPolygonF___setitem__(PyObject *sipSelf,PyObject *sipArgs) { QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF)); if (!sipCpp) return -1; PyObject *sipParseErr = NULL; { int a0; const QPointF* a1; int a1State = 0; if (sipParseArgs(&sipParseErr, sipArgs, "iJ1", &a0, sipType_QPointF, &a1, &a1State)) { int sipIsErr = 0; #line 412 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" int len; len = sipCpp->count(); if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0) sipIsErr = 1; else (*sipCpp)[a0] = *a1; #line 1140 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" sipReleaseType(const_cast<QPointF *>(a1),sipType_QPointF,a1State); if (sipIsErr) return -1; return 0; } } { PyObject * a0; const QPolygonF* a1; if (sipParseArgs(&sipParseErr, sipArgs, "TJ9", &PySlice_Type, &a0, sipType_QPolygonF, &a1)) { int sipIsErr = 0; #line 424 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" SIP_SSIZE_T len, start, stop, step, slicelength, i; len = sipCpp->count(); #if PY_VERSION_HEX >= 0x03020000 if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0) #else if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0) #endif sipIsErr = 1; else { int vlen = a1->count(); if (vlen != slicelength) { sipBadLengthForSlice(vlen, slicelength); sipIsErr = 1; } else { QVector<QPointF>::const_iterator it = a1->begin(); for (i = 0; i < slicelength; ++i) { (*sipCpp)[start] = *it; start += step; ++it; } } } #line 1190 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" if (sipIsErr) return -1; return 0; } } /* Raise an exception if the arguments couldn't be parsed. */ sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___setitem__, NULL); return -1; }
static PyObject *slot_QPolygonF___getitem__(PyObject *sipSelf,PyObject *sipArg) { QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF)); if (!sipCpp) return 0; PyObject *sipParseErr = NULL; { int a0; if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0)) { QPointF*sipRes = 0; int sipIsErr = 0; #line 400 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" SIP_SSIZE_T idx = sipConvertFromSequenceIndex(a0, sipCpp->count()); if (idx < 0) sipIsErr = 1; else sipRes = new QPointF(sipCpp->operator[]((int)idx)); #line 1231 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" if (sipIsErr) return 0; return sipConvertFromType(sipRes,sipType_QPointF,NULL); } } { PyObject * a0; if (sipParseArgs(&sipParseErr, sipArg, "1T", &PySlice_Type, &a0)) { QPolygonF*sipRes = 0; int sipIsErr = 0; #line 491 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" SIP_SSIZE_T len, start, stop, step, slicelength, i; len = sipCpp->count(); #if PY_VERSION_HEX >= 0x03020000 if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0) #else if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0) #endif sipIsErr = 1; else { sipRes = new QPolygonF(); for (i = 0; i < slicelength; ++i) { (*sipRes) += (*sipCpp)[start]; start += step; } } #line 1269 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" if (sipIsErr) return 0; return sipConvertFromType(sipRes,sipType_QPolygonF,NULL); } } /* Raise an exception if the arguments couldn't be parsed. */ sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___getitem__, NULL); return 0; }
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; }
/* 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 int slot_QPolygonF___delitem__(PyObject *sipSelf,PyObject *sipArg) { QPolygonF *sipCpp = reinterpret_cast<QPolygonF *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QPolygonF)); if (!sipCpp) return -1; PyObject *sipParseErr = NULL; { int a0; if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0)) { int sipIsErr = 0; #line 459 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" int len; len = sipCpp->count(); if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0) sipIsErr = 1; else sipCpp->remove(a0); #line 1063 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" if (sipIsErr) return -1; return 0; } } { PyObject * a0; if (sipParseArgs(&sipParseErr, sipArg, "1T", &PySlice_Type, &a0)) { int sipIsErr = 0; #line 471 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\sip/QtGui/qpolygon.sip" SIP_SSIZE_T len, start, stop, step, slicelength, i; len = sipCpp->count(); #if PY_VERSION_HEX >= 0x03020000 if (PySlice_GetIndicesEx(a0, len, &start, &stop, &step, &slicelength) < 0) #else if (PySlice_GetIndicesEx((PySliceObject *)a0, len, &start, &stop, &step, &slicelength) < 0) #endif sipIsErr = 1; else for (i = 0; i < slicelength; ++i) { sipCpp->remove(start); start += step - 1; } #line 1096 "C:\\Users\\marcus\\Downloads\\PyQt-gpl-5.4\\PyQt-gpl-5.4\\QtGui/sipQtGuiQPolygonF.cpp" if (sipIsErr) return -1; return 0; } } /* Raise an exception if the arguments couldn't be parsed. */ sipNoMethod(sipParseErr, sipName_QPolygonF, sipName___delitem__, NULL); return -1; }
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; }
/** * \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; }