void splitKey(PyObject* key, long* s_key, long* t_key)
{
PyObject *s_number, *t_number;
PyObject *s_item = PySequence_Fast_GET_ITEM(key, 0);
PyObject *t_item = PySequence_Fast_GET_ITEM(key, 1);
if(s_item == NULL || t_item == NULL)
{
printf("\nCould not split the key");
Py_DECREF(key);
}
s_number = PyNumber_Long(s_item);
t_number = PyNumber_Long(t_item);
if(s_number == NULL || t_number == NULL)
{
printf("\nall items must be integers numbers");
Py_DECREF(key);
}
*s_key = PyLong_AsLong(s_number);
*t_key = PyLong_AsLong(t_number);
Py_DECREF(s_number);
Py_DECREF(t_number);
Py_DECREF(key);
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
PyNumberMethods *m;
const char *name = NULL;
PyObject *res = NULL;
#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(x) || PyLong_Check(x))
#else
if (PyLong_Check(x))
#endif
return Py_INCREF(x), x;
m = Py_TYPE(x)->tp_as_number;
#if PY_VERSION_HEX < 0x03000000
if (m && m->nb_int) {
name = "int";
res = PyNumber_Int(x);
}
else if (m && m->nb_long) {
name = "long";
res = PyNumber_Long(x);
}
#else
if (m && m->nb_int) {
name = "int";
res = PyNumber_Long(x);
}
#endif
if (res) {
#if PY_VERSION_HEX < 0x03000000
if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
if (!PyLong_Check(res)) {
#endif
PyErr_Format(PyExc_TypeError,
"__%s__ returned non-%s (type %.200s)",
name, name, Py_TYPE(res)->tp_name);
Py_DECREF(res);
return NULL;
}
}
else if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,
"an integer is required");
}
return res;
}
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
Py_ssize_t ival;
PyObject* x = PyNumber_Index(b);
if (!x) return -1;
ival = PyInt_AsSsize_t(x);
Py_DECREF(x);
return ival;
}
static PyObject *get_urn_by_id(BaseTDBResolver *self, PyObject *args, PyObject *kwds) {
static char *kwlist[] = {"id", NULL};
char buff[BUFF_SIZE];
uint32_t id;
PyObject *result, *id_obj;
TDB_DATA urn;
TDB_DATA key;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist,
&id_obj))
return NULL;
id_obj = PyNumber_Long(id_obj);
if(!id_obj) return NULL;
id = PyLong_AsUnsignedLongLong(id_obj);
Py_DECREF(id_obj);
/* We get given an ID and we retrieve the URN it belongs to */
key.dptr = (unsigned char *)buff;
key.dsize = from_int(id, buff, BUFF_SIZE);
urn = tdb_fetch(self->urn_db, key);
if(urn.dptr) {
result = PyString_FromStringAndSize((char *)urn.dptr, urn.dsize);
free(urn.dptr);
return result;
};
Py_RETURN_NONE;
};
int
get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
{
if (gdbpy_is_value_object (obj))
*addr = value_as_address (value_object_to_value (obj));
else
{
PyObject *num = PyNumber_Long (obj);
gdb_py_ulongest val;
if (num == NULL)
return 0;
val = gdb_py_long_as_ulongest (num);
Py_XDECREF (num);
if (PyErr_Occurred ())
return 0;
if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val)
{
PyErr_SetString (PyExc_ValueError,
_("Overflow converting to address."));
return 0;
}
*addr = val;
}
return 1;
}
static long getNumberValue(PyObject* v)
{
PyObject* number = PyNumber_Long(v);
long result = PyLong_AsLong(number);
Py_XDECREF(number);
return result;
}
long
parse_int(PyObject * n)
{
PyObject * i = PyNumber_Long(n);
const long x = PyLong_AsLong(i);
Py_DECREF(i);
return x;
}
//-----------------------------------------------------------------------------
// NumberVar_GetValue()
// Returns the value stored at the given array position.
//-----------------------------------------------------------------------------
static PyObject *NumberVar_GetValue(
udt_NumberVar *var, // variable to determine value for
unsigned pos) // array position
{
PyObject *result, *stringObj;
char stringValue[200];
long integerValue;
ub4 stringLength;
sword status;
if (var->type == &vt_Boolean || var->type == &vt_Integer) {
status = OCINumberToInt(var->environment->errorHandle, &var->data[pos],
sizeof(long), OCI_NUMBER_SIGNED, (dvoid*) &integerValue);
if (Environment_CheckForError(var->environment, status,
"NumberVar_GetValue(): as integer") < 0)
return NULL;
if (var->type == &vt_Boolean)
return PyBool_FromLong(integerValue);
#if PY_MAJOR_VERSION >= 3
return PyLong_FromLong(integerValue);
#else
return PyInt_FromLong(integerValue);
#endif
}
if (var->type == &vt_NumberAsString || var->type == &vt_LongInteger) {
stringLength = sizeof(stringValue);
status = OCINumberToText(var->environment->errorHandle,
&var->data[pos],
(text*) var->environment->numberToStringFormatBuffer.ptr,
var->environment->numberToStringFormatBuffer.size, NULL, 0,
&stringLength, (unsigned char*) stringValue);
if (Environment_CheckForError(var->environment, status,
"NumberVar_GetValue(): as string") < 0)
return NULL;
stringObj = cxString_FromEncodedString(stringValue, stringLength,
var->environment->encoding);
if (!stringObj)
return NULL;
if (var->type == &vt_NumberAsString)
return stringObj;
#if PY_MAJOR_VERSION >= 3
result = PyNumber_Long(stringObj);
#else
result = PyNumber_Int(stringObj);
#endif
Py_DECREF(stringObj);
if (result || !PyErr_ExceptionMatches(PyExc_ValueError))
return result;
PyErr_Clear();
}
return OracleNumberToPythonFloat(var->environment, &var->data[pos]);
}
template<typename T> bool
getVersion(PyObject* p, T& v, const char* type)
{
assert(checkIsInstance(p, type));
PyObjectHandle major = getAttr(p, "major", false);
PyObjectHandle minor = getAttr(p, "minor", false);
if(major.get())
{
major = PyNumber_Long(major.get());
if(!major.get())
{
PyErr_Format(PyExc_ValueError, STRCAST("version major must be a numeric value"));
return false;
}
long m = PyLong_AsLong(major.get());
if(m < 0 || m > 255)
{
PyErr_Format(PyExc_ValueError, STRCAST("version major must be a value between 0 and 255"));
return false;
}
v.major = static_cast<Ice::Byte>(m);
}
if(minor.get())
{
major = PyNumber_Long(minor.get());
if(!minor.get())
{
PyErr_Format(PyExc_ValueError, STRCAST("version minor must be a numeric value"));
return false;
}
long m = PyLong_AsLong(minor.get());
if(m < 0 || m > 255)
{
PyErr_Format(PyExc_ValueError, STRCAST("version minor must be a value between 0 and 255"));
return false;
}
v.minor = static_cast<Ice::Byte>(m);
}
return true;
}
static int
UintFromObj (PyObject* obj, Uint32* val)
{
PyObject* longobj;
if (PyNumber_Check (obj))
{
if (!(longobj = PyNumber_Long (obj)))
return 0;
*val = (Uint32) PyLong_AsUnsignedLong (longobj);
Py_DECREF (longobj);
return 1;
}
return 0;
}
long* convertPySequenceToCArray(PyObject* seq_x, unsigned int len_x)
{
int i;
long* x;
x = (long*) malloc (len_x * sizeof(long));
if(x == NULL)
{
printf("\nUnable to allocate memory");
Py_DECREF(seq_x);
return NULL;
//return PyErr_NoMemory();
}
for(i = 0; i < len_x; i++)
{
PyObject *fitem;
PyObject *item = PySequence_Fast_GET_ITEM(seq_x, i);
if(item == NULL)
{
printf("\nCould not get item in the sequence");
Py_DECREF(seq_x);
free(x);
return NULL;
}
/*Instead PyNumber_Long is deprecate?*/
fitem = PyNumber_Long(item);
if(fitem == NULL)
{
printf("\nall items must be integers numbers");
Py_DECREF(seq_x);
free(x);
PyErr_SetString(PyExc_TypeError, "all items must be integers numbers");
return NULL;
}
x[i] = PyLong_AsLong(fitem);
Py_DECREF(fitem);
}
Py_DECREF(seq_x);
return x;
}
static PyObj
obj_int(PyObj self)
{
PyObj s, i;
/*
* Statically allocated types are encouraged to optimize this.
*/
s = PyObject_Str(self);
if (s == NULL)
return(NULL);
i = PyNumber_Long(s);
Py_DECREF(s);
return(i);
}
static int ca_module_admin_enum_as_string_setter(contextobject *self, PyObject *value, void *closure)
{
PyObject *tmp;
if (value == NULL) {
PYCA_ERRMSG("Cannot delete enum_as_string attribute");
return -1;
}
if ((tmp = PyNumber_Long(value)) != NULL) {
ca_module_admin_enum_as_string = PyInt_AsLong(tmp);
Py_DECREF(tmp);
} else {
PYCA_ERRMSG("enum_as_string must be integer");
return -1;
}
return 0;
}
static PyObject *
grp_getgrgid(PyObject *self, PyObject *pyo_id)
{
PyObject *py_int_id;
unsigned int gid;
struct group *p;
py_int_id = PyNumber_Long(pyo_id);
if (!py_int_id)
return NULL;
gid = PyLong_AS_LONG(py_int_id);
Py_DECREF(py_int_id);
if ((p = getgrgid(gid)) == NULL) {
PyErr_Format(PyExc_KeyError, "getgrgid(): gid not found: %d", gid);
return NULL;
}
return mkgrent(p);
}
PyObjectHandle LuaToPythonConverter::convertToLong(lua_State* L, int index) {
fixIndex(L, index);
if (auto ref = getOpaqueRef(L, index)) {
PyObjectHandle obj(PyNumber_Long(ref->obj.get()));
checkPythonError(obj, L, "convertToLong(ref)");
return obj;
}
int type = lua_type(L, index);
if (type != LUA_TNUMBER) {
luaL_error(L, "Invalid type for convertToLong: %d", type);
}
double val = lua_tonumber(L, index);
long lval = folly::to<long>(val);
PyObjectHandle obj(PyLong_FromLong(lval));
checkPythonError(obj, L, "convertToLong");
return obj;
}
static PyObject* mod_timefromticks(PyObject* self, PyObject* args)
{
UNUSED(self);
PyObject* num;
if (!PyArg_ParseTuple(args, "O", &num))
return 0;
if (!PyNumber_Check(num))
return PyErr_Format(PyExc_TypeError, "TimeFromTicks requires a number.");
Object l(PyNumber_Long(num));
if (!l)
return 0;
time_t t = PyLong_AsLong(num);
struct tm* fields = localtime(&t);
return PyTime_FromTime(fields->tm_hour, fields->tm_min, fields->tm_sec, 0);
}
static PyObject *py_ue_swidget_set_visibility(ue_PySWidget *self, PyObject * args)
{
PyObject* py_object;
if (!PyArg_ParseTuple(args, "O:set_visibility", &py_object))
{
return nullptr;
}
if (!PyNumber_Check(py_object))
{
return PyErr_Format(PyExc_Exception, "argument is not a ESlateVisibility");
}
PyObject *py_value = PyNumber_Long(py_object);
ESlateVisibility slateVisibility = (ESlateVisibility)PyLong_AsLong(py_value);
Py_DECREF(py_value);
EVisibility visibility;
switch (slateVisibility)
{
case ESlateVisibility::Visible:
visibility = EVisibility::Visible;
break;
case ESlateVisibility::Collapsed:
visibility = EVisibility::Collapsed;
break;
case ESlateVisibility::Hidden:
visibility = EVisibility::Hidden;
break;
case ESlateVisibility::HitTestInvisible:
visibility = EVisibility::HitTestInvisible;
break;
case ESlateVisibility::SelfHitTestInvisible:
visibility = EVisibility::SelfHitTestInvisible;
break;
}
self->Widget->SetVisibility(visibility);
Py_RETURN_SLATE_SELF;
}
static int
get_bufinfo(PyObject *self, Py_ssize_t *psize, void **pptr)
{
PyObject *buflen = NULL;
PyObject *bufptr = NULL;
Py_ssize_t size = 0;
void* ptr = NULL;
int ret = -1;
buflen = PyObject_GetAttrString(self, "_buflen_");
if (!buflen) goto cleanup;
bufptr = PyObject_GetAttrString(self, "_bufptr_");
if (!bufptr) goto cleanup;
size = PyNumber_AsSsize_t(buflen, PyExc_OverflowError);
if (size == -1 && PyErr_Occurred()) goto cleanup;
else if (size < 0) {
PyErr_SetString(PyExc_ValueError, "negative buffer size");
goto cleanup;
}
ptr = PyLong_AsVoidPtr(PyNumber_Long(bufptr));
if (PyErr_Occurred())
goto cleanup;
else if (!ptr) {
PyErr_SetString(PyExc_ValueError, "null buffer pointer");
goto cleanup;
}
*psize = size;
*pptr = ptr;
ret = 0;
cleanup:
Py_XDECREF(buflen);
Py_XDECREF(bufptr);
return ret;
}
static PyObject *
grp_getgrgid_impl(PyModuleDef *module, PyObject *id)
/*[clinic end generated code: output=8a11f5fdeb8c78a0 input=15fa0e2ccf5cda25]*/
{
PyObject *py_int_id;
gid_t gid;
struct group *p;
if (!_Py_Gid_Converter(id, &gid)) {
if (!PyErr_ExceptionMatches(PyExc_TypeError)) {
return NULL;
}
PyErr_Clear();
if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
"group id must be int, not %.200",
id->ob_type->tp_name) < 0) {
return NULL;
}
py_int_id = PyNumber_Long(id);
if (!py_int_id)
return NULL;
if (!_Py_Gid_Converter(py_int_id, &gid)) {
Py_DECREF(py_int_id);
return NULL;
}
Py_DECREF(py_int_id);
}
if ((p = getgrgid(gid)) == NULL) {
PyObject *gid_obj = _PyLong_FromGid(gid);
if (gid_obj == NULL)
return NULL;
PyErr_Format(PyExc_KeyError, "getgrgid(): gid not found: %S", gid_obj);
Py_DECREF(gid_obj);
return NULL;
}
return mkgrent(p);
}
/*NUMPY_API
* PyArray_IntpFromSequence
* Returns the number of dimensions or -1 if an error occurred.
* vals must be large enough to hold maxvals
*/
NPY_NO_EXPORT int
PyArray_IntpFromSequence(PyObject *seq, intp *vals, int maxvals)
{
int nd, i;
PyObject *op, *err;
/*
* Check to see if sequence is a single integer first.
* or, can be made into one
*/
if ((nd=PySequence_Length(seq)) == -1) {
if (PyErr_Occurred()) PyErr_Clear();
#if SIZEOF_LONG >= SIZEOF_INTP && !defined(NPY_PY3K)
if (!(op = PyNumber_Int(seq))) {
return -1;
}
#else
if (!(op = PyNumber_Long(seq))) {
return -1;
}
#endif
nd = 1;
#if SIZEOF_LONG >= SIZEOF_INTP
vals[0] = (intp ) PyInt_AsLong(op);
#else
vals[0] = (intp ) PyLong_AsLongLong(op);
#endif
Py_DECREF(op);
/*
* Check wether there was an error - if the error was an overflow, raise
* a ValueError instead to be more helpful
*/
if(vals[0] == -1) {
err = PyErr_Occurred();
if (err &&
PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
PyErr_SetString(PyExc_ValueError,
"Maximum allowed dimension exceeded");
}
if(err != NULL) {
return -1;
}
}
}
else {
for (i = 0; i < MIN(nd,maxvals); i++) {
op = PySequence_GetItem(seq, i);
if (op == NULL) {
return -1;
}
#if SIZEOF_LONG >= SIZEOF_INTP
vals[i]=(intp )PyInt_AsLong(op);
#else
vals[i]=(intp )PyLong_AsLongLong(op);
#endif
Py_DECREF(op);
/*
* Check wether there was an error - if the error was an overflow,
* raise a ValueError instead to be more helpful
*/
if(vals[0] == -1) {
err = PyErr_Occurred();
if (err &&
PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
PyErr_SetString(PyExc_ValueError,
"Maximum allowed dimension exceeded");
}
if(err != NULL) {
return -1;
}
}
}
}
return nd;
}
//-----------------------------------------------------------------------------
// NumberVar_GetValue()
// Returns the value stored at the given array position.
//-----------------------------------------------------------------------------
static PyObject *NumberVar_GetValue(
udt_NumberVar *var, // variable to determine value for
unsigned pos) // array position
{
PyObject *result, *stringObj;
char stringValue[200];
long integerValue;
ub4 stringLength;
sword status;
#if PY_MAJOR_VERSION < 3
if (var->type == &vt_Integer || var->type == &vt_Boolean) {
#else
if (var->type == &vt_Boolean) {
#endif
status = OCINumberToInt(var->environment->errorHandle, &var->data[pos],
sizeof(long), OCI_NUMBER_SIGNED, (dvoid*) &integerValue);
if (Environment_CheckForError(var->environment, status,
"NumberVar_GetValue(): as integer") < 0)
return NULL;
#if PY_MAJOR_VERSION < 3
if (var->type == &vt_Integer)
return PyInt_FromLong(integerValue);
#endif
return PyBool_FromLong(integerValue);
}
if (var->type == &vt_NumberAsString || var->type == &vt_LongInteger) {
stringLength = sizeof(stringValue);
status = OCINumberToText(var->environment->errorHandle,
&var->data[pos],
(text*) var->environment->numberToStringFormatBuffer.ptr,
var->environment->numberToStringFormatBuffer.size, NULL, 0,
&stringLength, (unsigned char*) stringValue);
if (Environment_CheckForError(var->environment, status,
"NumberVar_GetValue(): as string") < 0)
return NULL;
stringObj = cxString_FromEncodedString(stringValue, stringLength,
var->environment->encoding);
if (!stringObj)
return NULL;
if (var->type == &vt_NumberAsString)
return stringObj;
#if PY_MAJOR_VERSION >= 3
result = PyNumber_Long(stringObj);
#else
result = PyNumber_Int(stringObj);
#endif
Py_DECREF(stringObj);
if (result || !PyErr_ExceptionMatches(PyExc_ValueError))
return result;
PyErr_Clear();
}
return OracleNumberToPythonFloat(var->environment, &var->data[pos]);
}
#ifdef SQLT_BFLOAT
//-----------------------------------------------------------------------------
// NativeFloatVar_GetValue()
// Returns the value stored at the given array position as a float.
//-----------------------------------------------------------------------------
static PyObject *NativeFloatVar_GetValue(
udt_NativeFloatVar *var, // variable to determine value for
unsigned pos) // array position
{
return PyFloat_FromDouble(var->data[pos]);
}
//-----------------------------------------------------------------------------
// NativeFloatVar_SetValue()
// Set the value of the variable which should be a native double.
//-----------------------------------------------------------------------------
static int NativeFloatVar_SetValue(
udt_NativeFloatVar *var, // variable to set value for
unsigned pos, // array position to set
PyObject *value) // value to set
{
if (!PyFloat_Check(value)) {
PyErr_SetString(PyExc_TypeError, "expecting float");
return -1;
}
var->data[pos] = PyFloat_AS_DOUBLE(value);
return 0;
}
static gboolean
_pygi_marshal_from_py_long (PyObject *object, /* in */
GIArgument *arg, /* out */
GITypeTag type_tag,
GITransfer transfer)
{
PyObject *number;
if (!PyNumber_Check (object)) {
PyErr_Format (PyExc_TypeError, "Must be number, not %s",
object->ob_type->tp_name);
return FALSE;
}
#if PY_MAJOR_VERSION < 3
{
PyObject *tmp = PyNumber_Int (object);
if (tmp) {
number = PyNumber_Long (tmp);
Py_DECREF (tmp);
} else {
number = PyNumber_Long (object);
}
}
#else
number = PyNumber_Long (object);
#endif
if (number == NULL) {
PyErr_SetString (PyExc_TypeError, "expected int argument");
return FALSE;
}
switch (type_tag) {
case GI_TYPE_TAG_INT8:
{
long long_value = PyLong_AsLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < G_MININT8 || long_value > G_MAXINT8) {
PyErr_Format (PyExc_OverflowError, "%ld not in range %ld to %ld",
long_value, (long)G_MININT8, (long)G_MAXINT8);
} else {
arg->v_int8 = long_value;
}
break;
}
case GI_TYPE_TAG_UINT8:
{
long long_value = PyLong_AsLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < 0 || long_value > G_MAXUINT8) {
PyErr_Format (PyExc_OverflowError, "%ld not in range %ld to %ld",
long_value, (long)0, (long)G_MAXUINT8);
} else {
arg->v_uint8 = long_value;
}
break;
}
case GI_TYPE_TAG_INT16:
{
long long_value = PyLong_AsLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < G_MININT16 || long_value > G_MAXINT16) {
PyErr_Format (PyExc_OverflowError, "%ld not in range %ld to %ld",
long_value, (long)G_MININT16, (long)G_MAXINT16);
} else {
arg->v_int16 = long_value;
}
break;
}
case GI_TYPE_TAG_UINT16:
{
long long_value = PyLong_AsLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < 0 || long_value > G_MAXUINT16) {
PyErr_Format (PyExc_OverflowError, "%ld not in range %ld to %ld",
long_value, (long)0, (long)G_MAXUINT16);
} else {
arg->v_uint16 = long_value;
}
break;
}
case GI_TYPE_TAG_INT32:
{
long long_value = PyLong_AsLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < G_MININT32 || long_value > G_MAXINT32) {
PyErr_Format (PyExc_OverflowError, "%ld not in range %ld to %ld",
long_value, (long)G_MININT32, (long)G_MAXINT32);
} else {
arg->v_int32 = long_value;
}
break;
}
case GI_TYPE_TAG_UINT32:
{
PY_LONG_LONG long_value = PyLong_AsLongLong (number);
if (PyErr_Occurred()) {
break;
} else if (long_value < 0 || long_value > G_MAXUINT32) {
PyErr_Format (PyExc_OverflowError, "%lld not in range %ld to %lu",
long_value, (long)0, (unsigned long)G_MAXUINT32);
} else {
arg->v_uint32 = long_value;
}
break;
}
case GI_TYPE_TAG_INT64:
{
/* Rely on Python overflow error and convert to ValueError for 64 bit values */
arg->v_int64 = PyLong_AsLongLong (number);
break;
}
case GI_TYPE_TAG_UINT64:
{
/* Rely on Python overflow error and convert to ValueError for 64 bit values */
arg->v_uint64 = PyLong_AsUnsignedLongLong (number);
break;
}
default:
g_assert_not_reached ();
}
Py_DECREF (number);
if (PyErr_Occurred())
return FALSE;
return TRUE;
}
static PyObject *Proxy_long(ProxyObject *self)
{
Proxy__ENSURE_WRAPPED_OR_RETURN_NULL(self);
return PyNumber_Long(self->wrapped);
}
static PyObject *object_to_string(PyObject *object)
{
PyObject *result = NULL;
if (PyUnicode_Check(object)) {
Py_INCREF(object);
result = object;
}
else if (PyString_Check(object)) {
/* Python DOM binding: string objects must be UTF-8 */
result = PyUnicode_FromEncodedObject(object, "UTF-8", "strict");
}
else if (PyFloat_Check(object)) {
double d = PyFloat_AS_DOUBLE(object);
if (PyNumber_Finite(object)) {
if (floor(d) == d) {
/* Format as integer */
PyObject *num = PyNumber_Long(object);
if (!num)
return NULL;
result = PyObject_Unicode(num);
Py_DECREF(num);
}
else {
/* worst case length calc to ensure no buffer overrun:
fmt = %#.<prec>g
buf = '-' + [0-9]*prec + '.' + 'e+' + (longest exp for
any double rep.)
len = 1 + prec + 1 + 2 + 5 = 9 + prec
If prec=0 the effective precision is 1 (the leading digit is
always given), therefore increase by one to 10+prec.
*/
char buf[32]; /* only 10 + 12 + '\0' is needed, more than enough */
int len;
len = sprintf(buf, "%0.12g", d);
result = PyUnicode_DecodeASCII(buf, len, "strict");
}
}
else if (PyNumber_IsNaN(object)) {
result = PyUnicode_DecodeASCII("NaN", 3, "strict");
}
else if (d < 0) {
result = PyUnicode_DecodeASCII("-Infinity", 9, "strict");
}
else {
result = PyUnicode_DecodeASCII("Infinity", 8, "strict");
}
}
else if (PyBoolean_Check(object)) {
if (PyObject_IsTrue(object))
result = PyUnicode_DecodeASCII("true", 4, "strict");
else
result = PyUnicode_DecodeASCII("false", 5, "strict");
}
else if (PyInt_Check(object) || PyLong_Check(object)) {
result = PyObject_Unicode(object);
}
else if (PyList_Check(object)) {
if (PyList_GET_SIZE(object))
result = object_to_string(PyList_GET_ITEM(object, 0));
else
result = PyUnicode_FromUnicode(NULL, 0);
}
else {
/* check for pre-computed string value */
result = PyObject_GetAttrString(object, "stringValue");
if (result == NULL) {
/* assume a DOM node, node_to_string() returns empty string if not */
PyErr_Clear();
result = node_to_string(object);
}
}
return result;
}
PyObject *py_ue_skeletal_mesh_set_required_bones(ue_PyUObject *self, PyObject * args)
{
ue_py_check(self);
PyObject *py_map;
int lod_index = 0;
if (!PyArg_ParseTuple(args, "O|i:skeletal_mesh_set_required_bones", &py_map, &lod_index))
return nullptr;
USkeletalMesh *mesh = ue_py_check_type<USkeletalMesh>(self);
if (!mesh)
return PyErr_Format(PyExc_Exception, "uobject is not a USkeletalMesh");
#if ENGINE_MINOR_VERSION < 19
FSkeletalMeshResource *resource = mesh->GetImportedResource();
#else
FSkeletalMeshModel *resource = mesh->GetImportedModel();
#endif
if (lod_index < 0 || lod_index >= resource->LODModels.Num())
return PyErr_Format(PyExc_Exception, "invalid LOD index, must be between 0 and %d", resource->LODModels.Num() - 1);
#if ENGINE_MINOR_VERSION < 19
FStaticLODModel &model = resource->LODModels[lod_index];
#else
FSkeletalMeshLODModel &model = resource->LODModels[lod_index];
#endif
PyObject *py_iter = PyObject_GetIter(py_map);
if (!py_iter)
{
return PyErr_Format(PyExc_Exception, "argument is not an iterable of numbers");
}
TArray<FBoneIndexType> required_bones;
while (PyObject *py_item = PyIter_Next(py_iter))
{
if (!PyNumber_Check(py_item))
{
Py_DECREF(py_iter);
return PyErr_Format(PyExc_Exception, "argument is not an iterable of numbers");
}
PyObject *py_num = PyNumber_Long(py_item);
uint16 index = PyLong_AsUnsignedLong(py_num);
Py_DECREF(py_num);
required_bones.Add(index);
}
Py_DECREF(py_iter);
// temporarily disable all USkinnedMeshComponent's
TComponentReregisterContext<USkinnedMeshComponent> ReregisterContext;
mesh->ReleaseResources();
mesh->ReleaseResourcesFence.Wait();
model.RequiredBones = required_bones;
model.RequiredBones.Sort();
mesh->RefBasesInvMatrix.Empty();
mesh->CalculateInvRefMatrices();
#if WITH_EDITOR
mesh->PostEditChange();
#endif
mesh->InitResources();
mesh->MarkPackageDirty();
Py_RETURN_NONE;
}
static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
PyNumberMethods *m;
const char *name = NULL;
PyObject *res = NULL;
#if PY_MAJOR_VERSION < 3
if (PyInt_Check(x) || PyLong_Check(x))
#else
if (PyLong_Check(x))
#endif
return Py_INCREF(x), x;
m = Py_TYPE(x)->tp_as_number;
#if PY_MAJOR_VERSION < 3
if (m && m->nb_int) {
name = "int";
res = PyNumber_Int(x);
}
else if (m && m->nb_long) {
name = "long";
res = PyNumber_Long(x);
}
#else
if (m && m->nb_int) {
name = "int";
res = PyNumber_Long(x);
}
#endif
if (res) {
#if PY_MAJOR_VERSION < 3
if (!PyInt_Check(res) && !PyLong_Check(res)) {
#else
if (!PyLong_Check(res)) {
#endif
PyErr_Format(PyExc_TypeError,
"__%.4s__ returned non-%.4s (type %.200s)",
name, name, Py_TYPE(res)->tp_name);
Py_DECREF(res);
return NULL;
}
}
else if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,
"an integer is required");
}
return res;
}
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#endif
#endif
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
Py_ssize_t ival;
PyObject *x;
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_CheckExact(b)))
return PyInt_AS_LONG(b);
#endif
if (likely(PyLong_CheckExact(b))) {
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#if CYTHON_USE_PYLONG_INTERNALS
switch (Py_SIZE(b)) {
case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0];
case 0: return 0;
case 1: return ((PyLongObject*)b)->ob_digit[0];
}
#endif
#endif
#if PY_VERSION_HEX < 0x02060000
return PyInt_AsSsize_t(b);
#else
return PyLong_AsSsize_t(b);
#endif
}
x = PyNumber_Index(b);
if (!x) return -1;
ival = PyInt_AsSsize_t(x);
Py_DECREF(x);
return ival;
}
