static int BPy_IDArray_ass_subscript(BPy_IDArray *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 += self->prop->len;
return BPy_IDArray_SetItem(self, i, value);
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx(item, self->prop->len, &start, &stop, &step, &slicelength) < 0)
return -1;
if (step == 1)
return BPy_IDArray_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
PyObject* igraphmodule_EdgeSeq_get_attribute_values_mapping(igraphmodule_EdgeSeqObject *self, PyObject *o) {
Py_ssize_t index;
/* Handle integer indices according to the sequence protocol */
if (PyIndex_Check(o)) {
index = PyNumber_AsSsize_t(o, 0);
return igraphmodule_EdgeSeq_sq_item(self, index);
}
/* Handle strings according to the mapping protocol */
if (PyBaseString_Check(o))
return igraphmodule_EdgeSeq_get_attribute_values(self, o);
/* Handle iterables and slices by calling the select() method */
if (PySlice_Check(o) || PyObject_HasAttrString(o, "__iter__")) {
PyObject *result, *args;
args = Py_BuildValue("(O)", o);
if (!args)
return NULL;
result = igraphmodule_EdgeSeq_select(self, args);
Py_DECREF(args);
return result;
}
/* Handle everything else according to the mapping protocol */
return igraphmodule_EdgeSeq_get_attribute_values(self, o);
}
NUITKA_MAY_BE_UNUSED static Py_ssize_t CONVERT_TO_INDEX( PyObject *value )
{
assertObject( value );
#if PYTHON_VERSION < 300
if ( PyInt_Check( value ) )
{
return PyInt_AS_LONG( value );
}
else
#endif
if ( PyIndex_Check( value ) )
{
Py_ssize_t result = PyNumber_AsSsize_t( value, NULL );
if (unlikely( result == -1 ))
{
THROW_IF_ERROR_OCCURED();
}
return result;
}
else
{
PyErr_Format( PyExc_TypeError, "slice indices must be integers or None or have an __index__ method" );
throw PythonException();
}
}
Box* tupleMul(BoxedTuple* self, Box* rhs) {
Py_ssize_t n;
if (PyIndex_Check(rhs)) {
n = PyNumber_AsSsize_t(rhs, PyExc_OverflowError);
if (n == -1 && PyErr_Occurred())
throwCAPIException();
} else {
raiseExcHelper(TypeError, "can't multiply sequence by non-int of type '%s'", getTypeName(rhs));
}
int s = self->size();
if (n < 0)
n = 0;
if ((s == 0 || n == 1) && PyTuple_CheckExact(self)) {
return self;
} else {
BoxedTuple* rtn = BoxedTuple::create(n * s);
int rtn_i = 0;
for (int i = 0; i < n; ++i) {
memmove(&rtn->elts[rtn_i], &self->elts[0], sizeof(Box*) * s);
rtn_i += s;
}
return rtn;
}
}
static PyObject *Euler_subscript(EulerObject *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 += EULER_SIZE;
return Euler_item(self, i);
} else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((void *)item, EULER_SIZE, &start, &stop, &step, &slicelength) < 0)
return NULL;
if (slicelength <= 0) {
return PyTuple_New(0);
}
else if (step == 1) {
return Euler_slice(self, start, stop);
}
else {
PyErr_SetString(PyExc_TypeError, "slice steps not supported with eulers");
return NULL;
}
}
else {
PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
static PyObject *
Affine_subscript(polypaths_planar_overrideAffineObject *self, PyObject *item)
{
Py_ssize_t i;
PyObject *t, *s;
assert(polypaths_planar_overrideAffine_Check(self));
if (PyIndex_Check(item)) {
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) {
return NULL;
}
if (i < 0) {
i += Affine_len((PyObject *)self);
}
return Affine_getitem(self, i);
} else if (PySlice_Check(item)) {
/* We cheat a bit here by constructing a tuple from ourself and
slicing that, which is convenient since slicing a transform
results in a tuple. Not the most efficient, but I don't expect
transform slicing to be a common, performance sensitive operation
*/
t = PySequence_Tuple((PyObject *)self);
if (t == NULL) {
return NULL;
}
s = PyObject_GetItem(t, item);
Py_DECREF(t);
return s;
}
PyErr_Format(PyExc_TypeError,
"Affine indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return NULL;
}
static PyObject *KX_PythonSeq_subscript(PyObject *self, PyObject *key)
{
PyObjectPlus *self_plus= BGE_PROXY_REF(((KX_PythonSeq *)self)->base);
if (self_plus==NULL) {
PyErr_SetString(PyExc_SystemError, "val = seq[key], KX_PythonSeq: " BGE_PROXY_ERROR_MSG);
return NULL;
}
if (PyIndex_Check(key)) {
return KX_PythonSeq_getIndex(self, PyLong_AsSsize_t(key));
}
else if ( PyUnicode_Check(key) ) {
const char *name = _PyUnicode_AsString(key);
PyObjectPlus *ret = KX_PythonSeq_subscript__internal(self, name);
if (ret) {
return ret->GetProxy();
} else {
PyErr_Format( PyExc_KeyError, "requested item \"%s\" does not exist", name);
return NULL;
}
}
else {
PyErr_SetString( PyExc_TypeError, "expected a string or an index" );
return NULL;
}
}
static int Color_ass_subscript(ColorObject *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 += COLOR_SIZE;
return Color_ass_item(self, i, value);
}
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 -1;
if (step == 1)
return Color_ass_slice(self, start, stop, value);
else {
PyErr_SetString(PyExc_IndexError,
"slice steps not supported with color");
return -1;
}
}
else {
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
Py_TYPE(item)->tp_name);
return -1;
}
}
static PyObject *bpy_bmdeformvert_subscript(BPy_BMDeformVert *self, PyObject *key)
{
if (PyIndex_Check(key)) {
int i;
i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) {
return NULL;
}
else {
MDeformWeight *dw = defvert_find_index(self->data, i);
if (dw == NULL) {
PyErr_SetString(PyExc_KeyError, "BMDeformVert[key] = x: "
"key not found");
return NULL;
}
else {
return PyFloat_FromDouble(dw->weight);
}
}
}
else {
PyErr_Format(PyExc_TypeError,
"BMDeformVert keys must be integers, not %.200s",
Py_TYPE(key)->tp_name);
return NULL;
}
}
static int PyPointlessVector_check_index(PyPointlessVector* self, PyObject* item, Py_ssize_t* i)
{
// if this is not an index: throw an exception
if (!PyIndex_Check(item)) {
PyErr_Format(PyExc_TypeError, "PointlessVector: integer indexes please, got <%s>\n", item->ob_type->tp_name);
return 0;
}
// if index value is not an integer: throw an exception
*i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (*i == -1 && PyErr_Occurred())
return 0;
// if index is negative, it is relative to vector end
if (*i < 0)
*i += PyPointlessVector_length(self);
// if it is out of bounds: throw an exception
if (!(0 <= *i && *i < PyPointlessVector_length(self))) {
PyErr_SetString(PyExc_IndexError, "index is out of bounds");
return 0;
}
return 1;
}
static PyObject *t_sequence_map_get(t_sequence* 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 NULL;
value = t_sequence_seq_get(self, i);
}
else if ((!(self->itemvalue.flags & V_PURE)) ||
(!((self->sequence->ob_type->tp_as_mapping &&
self->sequence->ob_type->tp_as_mapping->mp_subscript) ||
(PyObject_HasAttr(self->sequence, __getitem___NAME)))))
{
int size = PySequence_Size(self->sequence);
PyObject *values;
if (size < 0)
return NULL;
values = t_sequence_seq_getslice(self, 0, size);
if (!values)
return NULL;
value = PyObject_GetItem(values, item);
Py_DECREF(values);
}
else
value = PyObject_GetItem(self->sequence, item);
return value;
}
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;
}
/*
* Implement mapping assignment sub-script for the type.
*/
static int sipArray_ass_subscript(PyObject *self, PyObject *key,
PyObject *value)
{
sipArrayObject *array = (sipArrayObject *)self;
SIP_SSIZE_T start, len;
void *value_data;
if (check_writable(array) < 0)
return -1;
if (PyIndex_Check(key))
{
start = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (start == -1 && PyErr_Occurred())
return -1;
if (start < 0)
start += array->len;
if (check_index(array, start) < 0)
return -1;
if ((value_data = get_value(array, value)) == NULL)
return -1;
len = 1;
}
else if (PySlice_Check(key))
{
Py_ssize_t stop, step;
if (sipConvertFromSliceObject(key, array->len, &start, &stop, &step, &len) < 0)
return -1;
if (step != 1)
{
PyErr_SetNone(PyExc_NotImplementedError);
return -1;
}
if ((value_data = get_slice(array, value, len)) == NULL)
return -1;
}
else
{
bad_key(key);
return -1;
}
memmove(element(array, start), value_data, len * array->stride);
return 0;
}
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 *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, PyObject *key)
{
/* don't need error check here */
if (PyUnicode_Check(key)) {
return bpy_bmlayercollection_subscript_str(self, _PyUnicode_AsString(key));
}
else if (PyIndex_Check(key)) {
Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return NULL;
return bpy_bmlayercollection_subscript_int(self, i);
}
else if (PySlice_Check(key)) {
PySliceObject *key_slice = (PySliceObject *)key;
Py_ssize_t step = 1;
if (key_slice->step != Py_None && !_PyEval_SliceIndex(key, &step)) {
return NULL;
}
else if (step != 1) {
PyErr_SetString(PyExc_TypeError,
"BMLayerCollection[slice]: slice steps not supported");
return NULL;
}
else if (key_slice->start == Py_None && key_slice->stop == Py_None) {
return bpy_bmlayercollection_subscript_slice(self, 0, PY_SSIZE_T_MAX);
}
else {
Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX;
/* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */
if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) return NULL;
if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) return NULL;
if (start < 0 || stop < 0) {
/* only get the length for negative values */
Py_ssize_t len = bpy_bmlayercollection_length(self);
if (start < 0) start += len;
if (stop < 0) stop += len;
}
if (stop - start <= 0) {
return PyTuple_New(0);
}
else {
return bpy_bmlayercollection_subscript_slice(self, start, stop);
}
}
}
else {
PyErr_SetString(PyExc_AttributeError,
"BMLayerCollection[key]: invalid key, key must be an int");
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 *bserobj_getattrro(PyObject *o, PyObject *name) {
bserObject *obj = (bserObject*)o;
Py_ssize_t i, n;
PyObject *name_bytes = NULL;
PyObject *ret = NULL;
const char *namestr;
if (PyIndex_Check(name)) {
i = PyNumber_AsSsize_t(name, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) {
goto bail;
}
ret = PySequence_GetItem(obj->values, i);
goto bail;
}
// We can be passed in Unicode objects here -- we don't support anything other
// than UTF-8 for keys.
if (PyUnicode_Check(name)) {
name_bytes = PyUnicode_AsUTF8String(name);
if (name_bytes == NULL) {
goto bail;
}
namestr = PyBytes_AsString(name_bytes);
} else {
namestr = PyBytes_AsString(name);
}
if (namestr == NULL) {
goto bail;
}
// hack^Wfeature to allow mercurial to use "st_size" to reference "size"
if (!strncmp(namestr, "st_", 3)) {
namestr += 3;
}
n = PyTuple_GET_SIZE(obj->keys);
for (i = 0; i < n; i++) {
const char *item_name = NULL;
PyObject *key = PyTuple_GET_ITEM(obj->keys, i);
item_name = PyBytes_AsString(key);
if (!strcmp(item_name, namestr)) {
ret = PySequence_GetItem(obj->values, i);
goto bail;
}
}
PyErr_Format(PyExc_AttributeError,
"bserobject has no attribute '%.400s'", namestr);
bail:
Py_XDECREF(name_bytes);
return ret;
}
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_Unpack(item, &start, &stop, &step) < 0) {
return NULL;
}
slicelen = PySlice_AdjustIndices(self->size, &start, &stop, step);
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 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* Row_subscript(PyObject* o, PyObject* key)
{
Row* row = (Row*)o;
if (PyIndex_Check(key))
{
Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
return 0;
if (i < 0)
i += row->cValues;
if (i < 0 || i >= row->cValues)
return PyErr_Format(PyExc_IndexError, "row index out of range index=%d len=%d", (int)i, (int)row->cValues);
Py_INCREF(row->apValues[i]);
return row->apValues[i];
}
if (PySlice_Check(key))
{
Py_ssize_t start, stop, step, slicelength;
#if PY_VERSION_HEX >= 0x03020000
if (PySlice_GetIndicesEx(key, row->cValues, &start, &stop, &step, &slicelength) < 0)
return 0;
#else
if (PySlice_GetIndicesEx((PySliceObject*)key, row->cValues, &start, &stop, &step, &slicelength) < 0)
return 0;
#endif
if (slicelength <= 0)
return PyTuple_New(0);
if (start == 0 && step == 1 && slicelength == row->cValues)
{
Py_INCREF(o);
return o;
}
Object result(PyTuple_New(slicelength));
if (!result)
return 0;
for (Py_ssize_t i = 0, index = start; i < slicelength; i++, index += step)
{
PyTuple_SET_ITEM(result.Get(), i, row->apValues[index]);
Py_INCREF(row->apValues[index]);
}
return result.Detach();
}
return PyErr_Format(PyExc_TypeError, "row indices must be integers, not %.200s", Py_TYPE(key)->tp_name);
}
Box* tupleGetitem(BoxedTuple* self, Box* slice) {
assert(self->cls == tuple_cls);
if (PyIndex_Check(slice)) {
Py_ssize_t i = PyNumber_AsSsize_t(slice, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
throwCAPIException();
return tupleGetitemUnboxed(self, i);
} else if (slice->cls == slice_cls)
return tupleGetitemSlice(self, static_cast<BoxedSlice*>(slice));
else
raiseExcHelper(TypeError, "tuple indices must be integers, not %s", getTypeName(slice));
}
static PyObject*
evaluate_slice_index(PyObject *v)
{
if (PyIndex_Check(v)) {
return PyNumber_Index(v);
}
else {
PyErr_SetString(PyExc_TypeError,
"slice indices must be integers or "
"None or have an __index__ method");
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);
}
}
static int bpy_bmdeformvert_ass_subscript(BPy_BMDeformVert *self, PyObject *key, PyObject *value)
{
if (PyIndex_Check(key)) {
int i;
i = PyNumber_AsSsize_t(key, PyExc_IndexError);
if (i == -1 && PyErr_Occurred()) {
return -1;
}
if (value) {
/* dvert[group_index] = 0.5 */
if (i < 0) {
PyErr_SetString(PyExc_KeyError, "BMDeformVert[key] = x: "
"weight keys can't be negative");
return -1;
}
else {
MDeformWeight *dw = defvert_verify_index(self->data, i);
const float f = PyFloat_AsDouble(value);
if (f == -1 && PyErr_Occurred()) { // parsed key not a number
PyErr_SetString(PyExc_TypeError,
"BMDeformVert[key] = x: "
"assigned value not a number");
return -1;
}
dw->weight = clamp_f(f, 0.0f, 1.0f);
}
}
else {
/* del dvert[group_index] */
MDeformWeight *dw = defvert_find_index(self->data, i);
if (dw == NULL) {
PyErr_SetString(PyExc_KeyError, "del BMDeformVert[key]: "
"key not found");
}
defvert_remove_group(self->data, dw);
}
return 0;
}
else {
PyErr_Format(PyExc_TypeError,
"BMDeformVert keys must be integers, not %.200s",
Py_TYPE(key)->tp_name);
return -1;
}
}
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 *
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;
}
}
void GetIndexOrName(PyObject *item, std::wstring& name, Py_ssize_t& i)
{
name.clear();
i = -1;
#ifndef IS_PY3K
if (PyString_Check(item))
{
char* s = PyString_AsString(item);
DWORD len = lstrlenA(s) + 1;
wchar_t* w = new wchar_t[len];
if (::MultiByteToWideChar(CP_ACP, 0, s, len, w, len) != len)
{
delete [] w;
throw MI::Exception(L"MultiByteToWideChar failed");
}
name.assign(w, len);
delete[] w;
}
else
#endif
if (PyUnicode_Check(item))
{
Py_ssize_t len = PyUnicode_GetSize(item) + 1;
wchar_t* w = new wchar_t[len];
if (PyUnicode_AsWideChar((PYUNICODEASVARCHARARG1TYPE*)item, w, len) < 0)
{
delete[] w;
throw MI::Exception(L"PyUnicode_AsWideChar failed");
}
name.assign(w, len);
delete[] w;
}
else if (PyIndex_Check(item))
{
i = PyNumber_AsSsize_t(item, PyExc_IndexError);
if (i == -1 && PyErr_Occurred())
throw MI::Exception(L"Index error");
}
else
throw MI::Exception(L"Invalid name or index");
}
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 int
PY_pdbdata_mp_ass_subscript(PyObject *_self, PyObject *key, PyObject *value)
{
int ierr;
Py_ssize_t nitems;
void *vr;
PY_pdbdata *self;
ierr = -1;
self = (PY_pdbdata *) _self;
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 {
vr = ((char *) self->data) + i * self->dp->size;
ierr = _PP_rd_syment(value, self->fileinfo, self->type, NULL, 1, vr);
}
} else if (PySlice_Check(key)) {
PyErr_SetString(PyExc_NotImplementedError, "Using slices for assignment to pdbdata");
} else {
PyErr_Format(PyExc_TypeError,
"pdbdata indices must be integers, not %.200s",
key->ob_type->tp_name);
}
return ierr;
}
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 {
