archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

formatting edits only to use more consisted style

Browse Source
This commit is contained in:
Campbell Barton
2011-12-26 12:26:11 +00:00
parent f48fb385ea
commit e17fd46c71
18 changed files with 1841 additions and 1824 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
source/blender/python/intern/bpy_rna_array.c
View File

@@ -55,14 +55,14 @@ typedef void (*RNA_SetIndexFunc)(PointerRNA *, PropertyRNA *, int index, void *)
*/
/*
arr[2]= x
arr[2] = x
py_to_array_index(arraydim=0, arrayoffset=0, index=2)
validate_array(lvalue_dim=0)
... make real index ...
*/
/* arr[3]=x, self->arraydim is 0, lvalue_dim is 1 */
/* arr[3] = x, self->arraydim is 0, lvalue_dim is 1 */
/* Ensures that a python sequence has expected number of items/sub-items and items are of desired type. */
static int validate_array_type(PyObject *seq, int dim, int totdim, int dimsize[],
ItemTypeCheckFunc check_item_type, const char *item_type_str, const char *error_prefix)
@@ -72,59 +72,62 @@ static int validate_array_type(PyObject *seq, int dim, int totdim, int dimsize[]
/* not the last dimension */
if (dim + 1 < totdim) {
/* check that a sequence contains dimsize[dim] items */
const Py_ssize_t seq_size= PySequence_Size(seq);
const Py_ssize_t seq_size = PySequence_Size(seq);
if (seq_size == -1) {
PyErr_Format(PyExc_ValueError, "%s sequence expected at dimension %d, not '%s'",
error_prefix, (int)dim + 1, Py_TYPE(seq)->tp_name);
return -1;
}
for (i= 0; i < seq_size; i++) {
for (i = 0; i < seq_size; i++) {
PyObject *item;
int ok= 1;
item= PySequence_GetItem(seq, i);
int ok = 1;
item = PySequence_GetItem(seq, i);
if (item == NULL) {
PyErr_Format(PyExc_TypeError, "%s sequence type '%s' failed to retrieve index %d",
error_prefix, Py_TYPE(seq)->tp_name, i);
ok= 0;
ok = 0;
}
else if (!PySequence_Check(item)) {
/* BLI_snprintf(error_str, error_str_size, "expected a sequence of %s", item_type_str); */
PyErr_Format(PyExc_TypeError, "%s expected a sequence of %s, not %s",
error_prefix, item_type_str, Py_TYPE(item)->tp_name);
ok= 0;
ok = 0;
}
/* arr[3][4][5]
dimsize[1]=4
dimsize[2]=5
dim=0 */
* dimsize[1] = 4
* dimsize[2] = 5
*
* dim = 0 */
else if (PySequence_Size(item) != dimsize[dim + 1]) {
/* BLI_snprintf(error_str, error_str_size, "sequences of dimension %d should contain %d items", (int)dim + 1, (int)dimsize[dim + 1]); */
/* BLI_snprintf(error_str, error_str_size,
"sequences of dimension %d should contain %d items",
(int)dim + 1, (int)dimsize[dim + 1]); */
PyErr_Format(PyExc_ValueError, "%s sequences of dimension %d should contain %d items",
error_prefix, (int)dim + 1, (int)dimsize[dim + 1]);
ok= 0;
ok = 0;
}
else if (validate_array_type(item, dim + 1, totdim, dimsize, check_item_type, item_type_str, error_prefix) == -1) {
ok= 0;
ok = 0;
}
Py_XDECREF(item);
if (!ok)
if (!ok) {
return -1;
}
}
}
else {
/* check that items are of correct type */
const int seq_size= PySequence_Size(seq);
const int seq_size = PySequence_Size(seq);
if (seq_size == -1) {
PyErr_Format(PyExc_ValueError, "%s sequence expected at dimension %d, not '%s'",
error_prefix, (int)dim + 1, Py_TYPE(seq)->tp_name);
return -1;
}
for (i= 0; i < seq_size; i++) {
PyObject *item= PySequence_GetItem(seq, i);
for (i = 0; i < seq_size; i++) {
PyObject *item = PySequence_GetItem(seq, i);
if (item == NULL) {
PyErr_Format(PyExc_TypeError, "%s sequence type '%s' failed to retrieve index %d",
@@ -150,32 +153,32 @@ static int validate_array_type(PyObject *seq, int dim, int totdim, int dimsize[]
/* Returns the number of items in a single- or multi-dimensional sequence. */
static int count_items(PyObject *seq, int dim)
{
int totitem= 0;
int totitem = 0;
if (dim > 1) {
const Py_ssize_t seq_size= PySequence_Size(seq);
const Py_ssize_t seq_size = PySequence_Size(seq);
Py_ssize_t i;
for (i= 0; i < seq_size; i++) {
PyObject *item= PySequence_GetItem(seq, i);
for (i = 0; i < seq_size; i++) {
PyObject *item = PySequence_GetItem(seq, i);
if (item) {
const int tot= count_items(item, dim - 1);
const int tot = count_items(item, dim - 1);
Py_DECREF(item);
if (tot != -1) {
totitem += tot;
}
else {
totitem= -1;
totitem = -1;
break;
}
}
else {
totitem= -1;
totitem = -1;
break;
}
}
}
else {
totitem= PySequence_Size(seq);
totitem = PySequence_Size(seq);
}
return totitem;
@@ -188,8 +191,8 @@ static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA
int dimsize[MAX_ARRAY_DIMENSION];
int tot, totdim, len;
totdim= RNA_property_array_dimension(ptr, prop, dimsize);
tot= count_items(rvalue, totdim - lvalue_dim);
totdim = RNA_property_array_dimension(ptr, prop, dimsize);
tot = count_items(rvalue, totdim - lvalue_dim);
if (tot == -1) {
PyErr_Format(PyExc_ValueError, "%s %.200s.%.200s, error validating the sequence length",
@@ -201,45 +204,47 @@ static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA
#if 0
/* length is flexible */
if (!RNA_property_dynamic_array_set_length(ptr, prop, tot)) {
/* BLI_snprintf(error_str, error_str_size, "%s.%s: array length cannot be changed to %d", RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot); */
/* BLI_snprintf(error_str, error_str_size,
"%s.%s: array length cannot be changed to %d",
RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot); */
PyErr_Format(PyExc_ValueError, "%s %s.%s: array length cannot be changed to %d",
error_prefix, RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot);
return -1;
}
#else
*totitem= tot;
*totitem = tot;
return 0;
#endif
}
len= tot;
len = tot;
}
else {
/* length is a constraint */
if (!lvalue_dim) {
len= RNA_property_array_length(ptr, prop);
len = RNA_property_array_length(ptr, prop);
}
/* array item assignment */
else {
int i;
len= 1;
len = 1;
/* arr[3][4][5]
arr[2]= x
dimsize={4, 5}
dimsize[1]= 4
dimsize[2]= 5
lvalue_dim=0, totdim=3
arr[2] = x
dimsize = {4, 5}
dimsize[1] = 4
dimsize[2] = 5
lvalue_dim = 0, totdim = 3
arr[2][3]= x
lvalue_dim=1
arr[2][3] = x
lvalue_dim = 1
arr[2][3][4]= x
lvalue_dim=2 */
for (i= lvalue_dim; i < totdim; i++)
arr[2][3][4] = x
lvalue_dim = 2 */
for (i = lvalue_dim; i < totdim; i++)
len *= dimsize[i];
}
@@ -251,7 +256,7 @@ static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA
}
}
*totitem= len;
*totitem = len;
return 0;
}
@@ -261,7 +266,7 @@ static int validate_array(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop,
const char *error_prefix)
{
int dimsize[MAX_ARRAY_DIMENSION];
int totdim= RNA_property_array_dimension(ptr, prop, dimsize);
int totdim = RNA_property_array_dimension(ptr, prop, dimsize);
/* validate type first because length validation may modify property array length */
@@ -269,7 +274,7 @@ static int validate_array(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop,
#ifdef USE_MATHUTILS
if (lvalue_dim == 0) { /* only valid for first level array */
if (MatrixObject_Check(rvalue)) {
MatrixObject *pymat= (MatrixObject *)rvalue;
MatrixObject *pymat = (MatrixObject *)rvalue;
if (BaseMath_ReadCallback(pymat) == -1)
return -1;
@@ -292,7 +297,7 @@ static int validate_array(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop,
return -1;
}
else {
*totitem= dimsize[0] * dimsize[1];
*totitem = dimsize[0] * dimsize[1];
return 0;
}
}
@@ -317,7 +322,7 @@ static char *copy_value_single(PyObject *item, PointerRNA *ptr, PropertyRNA *pro
convert_item(item, value);
rna_set_index(ptr, prop, *index, value);
*index= *index + 1;
*index = *index + 1;
}
else {
convert_item(item, data);
@@ -331,8 +336,8 @@ static char *copy_values(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
int dim, char *data, unsigned int item_size, int *index,
ItemConvertFunc convert_item, RNA_SetIndexFunc rna_set_index)
{
int totdim= RNA_property_array_dimension(ptr, prop, NULL);
const Py_ssize_t seq_size= PySequence_Size(seq);
int totdim = RNA_property_array_dimension(ptr, prop, NULL);
const Py_ssize_t seq_size = PySequence_Size(seq);
Py_ssize_t i;
/* Regarding PySequence_GetItem() failing.
@@ -352,8 +357,8 @@ static char *copy_values(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
#ifdef USE_MATHUTILS
if (dim == 0) {
if (MatrixObject_Check(seq)) {
MatrixObject *pymat= (MatrixObject *)seq;
size_t allocsize= pymat->num_col * pymat->num_row * sizeof(float);
MatrixObject *pymat = (MatrixObject *)seq;
size_t allocsize = pymat->num_col * pymat->num_row * sizeof(float);
/* read callback already done by validate */
/* since this is the first iteration we can assume data is allocated */
@@ -368,14 +373,14 @@ static char *copy_values(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
#endif /* USE_MATHUTILS */
for (i= 0; i < seq_size; i++) {
PyObject *item= PySequence_GetItem(seq, i);
for (i = 0; i < seq_size; i++) {
PyObject *item = PySequence_GetItem(seq, i);
if (item) {
if (dim + 1 < totdim) {
data= copy_values(item, ptr, prop, dim + 1, data, item_size, index, convert_item, rna_set_index);
data = copy_values(item, ptr, prop, dim + 1, data, item_size, index, convert_item, rna_set_index);
}
else {
data= copy_value_single(item, ptr, prop, data, item_size, index, convert_item, rna_set_index);
data = copy_value_single(item, ptr, prop, data, item_size, index, convert_item, rna_set_index);
}
Py_DECREF(item);
@@ -396,9 +401,9 @@ static int py_to_array(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
{
/*int totdim, dim_size[MAX_ARRAY_DIMENSION];*/
int totitem;
char *data= NULL;
char *data = NULL;
/*totdim= RNA_property_array_dimension(ptr, prop, dim_size);*/ /*UNUSED*/
/*totdim = RNA_property_array_dimension(ptr, prop, dim_size);*/ /*UNUSED*/
if (validate_array(seq, ptr, prop, 0, check_item_type, item_type_str, &totitem, error_prefix) == -1) {
return -1;
@@ -408,30 +413,30 @@ static int py_to_array(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
/* note: this code is confusing */
if (param_data && RNA_property_flag(prop) & PROP_DYNAMIC) {
/* not freeing allocated mem, RNA_parameter_list_free() will do this */
ParameterDynAlloc *param_alloc= (ParameterDynAlloc *)param_data;
param_alloc->array_tot= (int)totitem;
param_alloc->array= MEM_callocN(item_size * totitem, "py_to_array dyn"); /* freeing param list will free */
ParameterDynAlloc *param_alloc = (ParameterDynAlloc *)param_data;
param_alloc->array_tot = (int)totitem;
param_alloc->array = MEM_callocN(item_size * totitem, "py_to_array dyn"); /* freeing param list will free */
data= param_alloc->array;
data = param_alloc->array;
}
else if (param_data) {
data= param_data;
data = param_data;
}
else {
data= PyMem_MALLOC(item_size * totitem);
data = PyMem_MALLOC(item_size * totitem);
}
/* will only fail in very rare cases since we already validated the
* python data, the check here is mainly for completeness. */
if (copy_values(seq, ptr, prop, 0, data, item_size, NULL, convert_item, NULL) != NULL) {
if (param_data==NULL) {
if (param_data == NULL) {
/* NULL can only pass through in case RNA property arraylength is 0 (impossible?) */
rna_set_array(ptr, prop, data);
PyMem_FREE(data);
}
}
else {
if (param_data==NULL) {
if (param_data == NULL) {
PyMem_FREE(data);
}
@@ -452,21 +457,21 @@ static int py_to_array_index(PyObject *py, PointerRNA *ptr, PropertyRNA *prop,
int totdim, dimsize[MAX_ARRAY_DIMENSION];
int totitem, i;
totdim= RNA_property_array_dimension(ptr, prop, dimsize);
totdim = RNA_property_array_dimension(ptr, prop, dimsize);
/* convert index */
/* arr[3][4][5]
arr[2]= x
lvalue_dim=0, index= 0 + 2 * 4 * 5
arr[2] = x
lvalue_dim = 0, index = 0 + 2 * 4 * 5
arr[2][3]= x
lvalue_dim=1, index= 40 + 3 * 5 */
arr[2][3] = x
lvalue_dim = 1, index = 40 + 3 * 5 */
lvalue_dim++;
for (i= lvalue_dim; i < totdim; i++)
for (i = lvalue_dim; i < totdim; i++)
index *= dimsize[i];
index += arrayoffset;
@@ -495,17 +500,17 @@ static int py_to_array_index(PyObject *py, PointerRNA *ptr, PropertyRNA *prop,
static void py_to_float(PyObject *py, char *data)
{
*(float*)data= (float)PyFloat_AsDouble(py);
*(float *)data = (float)PyFloat_AsDouble(py);
}
static void py_to_int(PyObject *py, char *data)
{
*(int*)data= (int)PyLong_AsSsize_t(py);
*(int *)data = (int)PyLong_AsSsize_t(py);
}
static void py_to_bool(PyObject *py, char *data)
{
*(int*)data= (int)PyObject_IsTrue(py);
*(int *)data = (int)PyObject_IsTrue(py);
}
static int py_float_check(PyObject *py)
@@ -527,17 +532,17 @@ static int py_bool_check(PyObject *py)
static void float_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
{
RNA_property_float_set_index(ptr, prop, index, *(float*)value);
RNA_property_float_set_index(ptr, prop, index, *(float *)value);
}
static void int_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
{
RNA_property_int_set_index(ptr, prop, index, *(int*)value);
RNA_property_int_set_index(ptr, prop, index, *(int *)value);
}
static void bool_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
{
RNA_property_boolean_set_index(ptr, prop, index, *(int*)value);
RNA_property_boolean_set_index(ptr, prop, index, *(int *)value);
}
int pyrna_py_to_array(PointerRNA *ptr, PropertyRNA *prop, char *param_data,
@@ -546,20 +551,20 @@ int pyrna_py_to_array(PointerRNA *ptr, PropertyRNA *prop, char *param_data,
int ret;
switch (RNA_property_type(prop)) {
case PROP_FLOAT:
ret= py_to_array(py, ptr, prop, param_data, py_float_check, "float", sizeof(float),
ret = py_to_array(py, ptr, prop, param_data, py_float_check, "float", sizeof(float),
py_to_float, (RNA_SetArrayFunc)RNA_property_float_set_array, error_prefix);
break;
case PROP_INT:
ret= py_to_array(py, ptr, prop, param_data, py_int_check, "int", sizeof(int),
ret = py_to_array(py, ptr, prop, param_data, py_int_check, "int", sizeof(int),
py_to_int, (RNA_SetArrayFunc)RNA_property_int_set_array, error_prefix);
break;
case PROP_BOOLEAN:
ret= py_to_array(py, ptr, prop, param_data, py_bool_check, "boolean", sizeof(int),
ret = py_to_array(py, ptr, prop, param_data, py_bool_check, "boolean", sizeof(int),
py_to_bool, (RNA_SetArrayFunc)RNA_property_boolean_set_array, error_prefix);
break;
default:
PyErr_SetString(PyExc_TypeError, "not an array type");
ret= -1;
ret = -1;
}
return ret;
@@ -571,20 +576,20 @@ int pyrna_py_to_array_index(PointerRNA *ptr, PropertyRNA *prop, int arraydim, in
int ret;
switch (RNA_property_type(prop)) {
case PROP_FLOAT:
ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
ret = py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
py_float_check, "float", py_to_float, float_set_index, error_prefix);
break;
case PROP_INT:
ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
ret = py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
py_int_check, "int", py_to_int, int_set_index, error_prefix);
break;
case PROP_BOOLEAN:
ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
ret = py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index,
py_bool_check, "boolean", py_to_bool, bool_set_index, error_prefix);
break;
default:
PyErr_SetString(PyExc_TypeError, "not an array type");
ret= -1;
ret = -1;
}
return ret;
@@ -596,17 +601,17 @@ PyObject *pyrna_array_index(PointerRNA *ptr, PropertyRNA *prop, int index)
switch (RNA_property_type(prop)) {
case PROP_FLOAT:
item= PyFloat_FromDouble(RNA_property_float_get_index(ptr, prop, index));
item = PyFloat_FromDouble(RNA_property_float_get_index(ptr, prop, index));
break;
case PROP_BOOLEAN:
item= PyBool_FromLong(RNA_property_boolean_get_index(ptr, prop, index));
item = PyBool_FromLong(RNA_property_boolean_get_index(ptr, prop, index));
break;
case PROP_INT:
item= PyLong_FromSsize_t(RNA_property_int_get_index(ptr, prop, index));
item = PyLong_FromSsize_t(RNA_property_int_get_index(ptr, prop, index));
break;
default:
PyErr_SetString(PyExc_TypeError, "not an array type");
item= NULL;
item = NULL;
}
return item;
@@ -619,20 +624,20 @@ static PyObject *pyrna_py_from_array_internal(PointerRNA *ptr, PropertyRNA *prop
{
PyObject *tuple;
int i, len;
int totdim= RNA_property_array_dimension(ptr, prop, NULL);
int totdim = RNA_property_array_dimension(ptr, prop, NULL);
len= RNA_property_multi_array_length(ptr, prop, dim);
len = RNA_property_multi_array_length(ptr, prop, dim);
tuple= PyTuple_New(len);
tuple = PyTuple_New(len);
for (i= 0; i < len; i++) {
for (i = 0; i < len; i++) {
PyObject *item;
if (dim + 1 < totdim)
item= pyrna_py_from_array_internal(ptr, prop, dim + 1, index);
item = pyrna_py_from_array_internal(ptr, prop, dim + 1, index);
else {
item= pyrna_array_index(ptr, prop, *index);
*index= *index + 1;
item = pyrna_array_index(ptr, prop, *index);
*index = *index + 1;
}
if (!item) {
@@ -650,13 +655,13 @@ static PyObject *pyrna_py_from_array_internal(PointerRNA *ptr, PropertyRNA *prop
PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr, PropertyRNA *prop, int index)
{
int totdim, arraydim, arrayoffset, dimsize[MAX_ARRAY_DIMENSION], i, len;
BPy_PropertyArrayRNA *ret= NULL;
BPy_PropertyArrayRNA *ret = NULL;
arraydim= self ? self->arraydim : 0;
arrayoffset= self ? self->arrayoffset : 0;
arraydim = self ? self->arraydim : 0;
arrayoffset = self ? self->arrayoffset : 0;
/* just in case check */
len= RNA_property_multi_array_length(ptr, prop, arraydim);
len = RNA_property_multi_array_length(ptr, prop, arraydim);
if (index >= len || index < 0) {
/* this shouldn't happen because higher level funcs must check for invalid index */
if (G.f & G_DEBUG) printf("pyrna_py_from_array_index: invalid index %d for array with length=%d\n", index, len);
@@ -665,38 +670,38 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, PointerRNA *ptr,
return NULL;
}
totdim= RNA_property_array_dimension(ptr, prop, dimsize);
totdim = RNA_property_array_dimension(ptr, prop, dimsize);
if (arraydim + 1 < totdim) {
ret= (BPy_PropertyArrayRNA*)pyrna_prop_CreatePyObject(ptr, prop);
ret->arraydim= arraydim + 1;
ret = (BPy_PropertyArrayRNA *)pyrna_prop_CreatePyObject(ptr, prop);
ret->arraydim = arraydim + 1;
/* arr[3][4][5]
x= arr[2]
index= 0 + 2 * 4 * 5
x = arr[2]
index = 0 + 2 * 4 * 5
x= arr[2][3]
index= offset + 3 * 5 */
x = arr[2][3]
index = offset + 3 * 5 */
for (i= arraydim + 1; i < totdim; i++)
for (i = arraydim + 1; i < totdim; i++)
index *= dimsize[i];
ret->arrayoffset= arrayoffset + index;
ret->arrayoffset = arrayoffset + index;
}
else {
index= arrayoffset + index;
ret= (BPy_PropertyArrayRNA *)pyrna_array_index(ptr, prop, index);
index = arrayoffset + index;
ret = (BPy_PropertyArrayRNA *)pyrna_array_index(ptr, prop, index);
}
return (PyObject*)ret;
return (PyObject *)ret;
}
PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop)
{
PyObject *ret;
ret= pyrna_math_object_from_array(ptr, prop);
ret = pyrna_math_object_from_array(ptr, prop);
/* is this a maths object? */
if (ret) return ret;
@@ -707,11 +712,11 @@ PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop)
/* TODO, multi-dimensional arrays */
int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
{
int len= RNA_property_array_length(ptr, prop);
int len = RNA_property_array_length(ptr, prop);
int type;
int i;
if (len==0) /* possible with dynamic arrays */
if (len == 0) /* possible with dynamic arrays */
return 0;
if (RNA_property_array_dimension(ptr, prop, NULL) > 1) {
@@ -719,13 +724,13 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
return -1;
}
type= RNA_property_type(prop);
type = RNA_property_type(prop);
switch (type) {
case PROP_FLOAT:
{
float value_f= PyFloat_AsDouble(value);
if (value_f==-1 && PyErr_Occurred()) {
float value_f = PyFloat_AsDouble(value);
if (value_f == -1 && PyErr_Occurred()) {
PyErr_Clear();
return 0;
}
@@ -734,15 +739,15 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
float *tmp_arr;
if (len * sizeof(float) > sizeof(tmp)) {
tmp_arr= PyMem_MALLOC(len * sizeof(float));
tmp_arr = PyMem_MALLOC(len * sizeof(float));
}
else {
tmp_arr= tmp;
tmp_arr = tmp;
}
RNA_property_float_get_array(ptr, prop, tmp_arr);
for (i=0; i<len; i++) {
for (i = 0; i < len; i++) {
if (tmp_arr[i] == value_f) {
break;
}
@@ -751,15 +756,15 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
if (tmp_arr != tmp)
PyMem_FREE(tmp_arr);
return i<len ? 1 : 0;
return i < len ? 1 : 0;
}
break;
}
case PROP_BOOLEAN:
case PROP_INT:
{
int value_i= PyLong_AsSsize_t(value);
if (value_i==-1 && PyErr_Occurred()) {
int value_i = PyLong_AsSsize_t(value);
if (value_i == -1 && PyErr_Occurred()) {
PyErr_Clear();
return 0;
}
@@ -768,18 +773,18 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
int *tmp_arr;
if (len * sizeof(int) > sizeof(tmp)) {
tmp_arr= PyMem_MALLOC(len * sizeof(int));
tmp_arr = PyMem_MALLOC(len * sizeof(int));
}
else {
tmp_arr= tmp;
tmp_arr = tmp;
}
if (type==PROP_BOOLEAN)
if (type == PROP_BOOLEAN)
RNA_property_boolean_get_array(ptr, prop, tmp_arr);
else
RNA_property_int_get_array(ptr, prop, tmp_arr);
for (i=0; i<len; i++) {
for (i = 0; i < len; i++) {
if (tmp_arr[i] == value_i) {
break;
}
@@ -788,7 +793,7 @@ int pyrna_array_contains_py(PointerRNA *ptr, PropertyRNA *prop, PyObject *value)
if (tmp_arr != tmp)
PyMem_FREE(tmp_arr);
return i<len ? 1 : 0;
return i < len ? 1 : 0;
}
break;
}