static int write_element_to_buffer(buffer_t buffer, int type_byte,
PyObject* value, unsigned char check_keys,
unsigned char first_attempt) {
int result;
if(Py_EnterRecursiveCall(" while encoding an object to BSON "))
return 0;
result = _write_element_to_buffer(buffer, type_byte, value,
check_keys, first_attempt);
Py_LeaveRecursiveCall();
return result;
}
/* Compare v to w. Return
-1 if v < w or exception (PyErr_Occurred() true in latter case).
0 if v == w.
1 if v > w.
XXX The docs (C API manual) say the return value is undefined in case
XXX of error.
*/
int
PyObject_Compare(PyObject *v, PyObject *w)
{
int result;
if (v == NULL || w == NULL) {
PyErr_BadInternalCall();
return -1;
}
if (v == w)
return 0;
if (Py_EnterRecursiveCall(" in cmp"))
return -1;
result = do_cmp(v, w);
Py_LeaveRecursiveCall();
return result < 0 ? -1 : result;
}
NUITKA_MAY_BE_UNUSED static PyObject *CALL_FUNCTION( PyObject *function_object, PyObject *positional_args, PyObject *named_args )
{
assertObject( function_object );
assertObject( positional_args );
assert( named_args == NULL || Py_REFCNT( named_args ) > 0 );
ternaryfunc call_slot = Py_TYPE( function_object )->tp_call;
if (unlikely( call_slot == NULL ))
{
PyErr_Format(
PyExc_TypeError,
"'%s' object is not callable",
function_object->ob_type->tp_name
);
throw PythonException();
}
if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object") ))
{
throw PythonException();
}
PyObject *result = (*call_slot)( function_object, positional_args, named_args );
Py_LeaveRecursiveCall();
if ( result == NULL )
{
if (unlikely( !ERROR_OCCURED() ))
{
PyErr_Format(
PyExc_SystemError,
"NULL result without error in PyObject_Call"
);
}
throw PythonException();
}
else
{
return result;
}
}
/* Return:
NULL for exception;
some object not equal to NotImplemented if it is implemented
(this latter object may not be a Boolean).
*/
PyObject *
PyObject_RichCompare(PyObject *v, PyObject *w, int op)
{
PyObject *res;
assert(Py_LT <= op && op <= Py_GE);
if (Py_EnterRecursiveCall(" in cmp"))
return NULL;
/* If the types are equal, and not old-style instances, try to
get out cheap (don't bother with coercions etc.). */
if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
cmpfunc fcmp;
richcmpfunc frich = RICHCOMPARE(v->ob_type);
/* If the type has richcmp, try it first. try_rich_compare
tries it two-sided, which is not needed since we've a
single type only. */
if (frich != NULL) {
res = (*frich)(v, w, op);
if (res != Py_NotImplemented)
goto Done;
Py_DECREF(res);
}
/* No richcmp, or this particular richmp not implemented.
Try 3-way cmp. */
fcmp = v->ob_type->tp_compare;
if (fcmp != NULL) {
int c = (*fcmp)(v, w);
c = adjust_tp_compare(c);
if (c == -2) {
res = NULL;
goto Done;
}
res = convert_3way_to_object(op, c);
goto Done;
}
}
/* Fast path not taken, or couldn't deliver a useful result. */
res = do_richcmp(v, w, op);
Done:
Py_LeaveRecursiveCall();
return res;
}
PyObject* __stdcall Jit_EvalHelper(void* state, PyFrameObject*frame) {
PyThreadState *tstate = PyThreadState_GET();
if (tstate->use_tracing) {
if (tstate->c_tracefunc != NULL) {
return PyEval_EvalFrameEx_NoJit(frame, 0);
}
}
if (Py_EnterRecursiveCall("")) {
return NULL;
}
frame->f_executing = 1;
auto res = ((Py_EvalFunc)state)(nullptr, frame);
Py_LeaveRecursiveCall();
frame->f_executing = 0;
return _Py_CheckFunctionResult(NULL, res, "Jit_EvalHelper");
}
/*
* Convert the array to a scalar if allowed, and apply the builtin function
* to it. The where argument is passed onto Py_EnterRecursiveCall when the
* array contains python objects.
*/
NPY_NO_EXPORT PyObject *
array_scalar_forward(PyArrayObject *v,
PyObject *(*builtin_func)(PyObject *),
const char *where)
{
PyObject *scalar;
if (PyArray_SIZE(v) != 1) {
PyErr_SetString(PyExc_TypeError, "only size-1 arrays can be"\
" converted to Python scalars");
return NULL;
}
scalar = PyArray_GETITEM(v, PyArray_DATA(v));
if (scalar == NULL) {
return NULL;
}
/* Need to guard against recursion if our array holds references */
if (PyDataType_REFCHK(PyArray_DESCR(v))) {
PyObject *res;
if (Npy_EnterRecursiveCall(where) != 0) {
Py_DECREF(scalar);
return NULL;
}
res = builtin_func(scalar);
Py_DECREF(scalar);
Py_LeaveRecursiveCall();
return res;
}
else {
PyObject *res;
res = builtin_func(scalar);
Py_DECREF(scalar);
return res;
}
}
static int
_array_nonzero(PyArrayObject *mp)
{
npy_intp n;
n = PyArray_SIZE(mp);
if (n == 1) {
int res;
if (Npy_EnterRecursiveCall(" while converting array to bool")) {
return -1;
}
res = PyArray_DESCR(mp)->f->nonzero(PyArray_DATA(mp), mp);
/* nonzero has no way to indicate an error, but one can occur */
if (PyErr_Occurred()) {
res = -1;
}
Py_LeaveRecursiveCall();
return res;
}
else if (n == 0) {
/* 2017-09-25, 1.14 */
if (DEPRECATE("The truth value of an empty array is ambiguous. "
"Returning False, but in future this will result in an error. "
"Use `array.size > 0` to check that an array is not empty.") < 0) {
return -1;
}
return 0;
}
else {
PyErr_SetString(PyExc_ValueError,
"The truth value of an array "
"with more than one element is ambiguous. "
"Use a.any() or a.all()");
return -1;
}
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
PyObject *s = NULL;
_PyAccu acc;
static PyObject *sep = NULL;
n = Py_SIZE(v);
if (n == 0)
return PyUnicode_FromString("()");
if (sep == NULL) {
sep = PyUnicode_FromString(", ");
if (sep == NULL)
return NULL;
}
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyUnicode_FromString("(...)") : NULL;
}
if (_PyAccu_Init(&acc))
goto error;
s = PyUnicode_FromString("(");
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto error;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (i > 0 && _PyAccu_Accumulate(&acc, sep))
goto error;
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
}
if (n > 1)
s = PyUnicode_FromString(")");
else
s = PyUnicode_FromString(",)");
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
Py_ReprLeave((PyObject *)v);
return _PyAccu_Finish(&acc);
error:
_PyAccu_Destroy(&acc);
Py_XDECREF(s);
Py_ReprLeave((PyObject *)v);
return NULL;
}
static PyObject *
record_repr(ApgRecordObject *v)
{
Py_ssize_t i, n;
PyObject *keys_iter;
_PyUnicodeWriter writer;
n = Py_SIZE(v);
assert(n > 0);
keys_iter = PyObject_GetIter(v->mapping);
if (keys_iter == NULL) {
return NULL;
}
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
Py_DECREF(keys_iter);
return i > 0 ? PyUnicode_FromString("<Record ...>") : NULL;
}
_PyUnicodeWriter_Init(&writer);
writer.overallocate = 1;
writer.min_length = 12; /* <Record a=1> */
if (_PyUnicodeWriter_WriteASCIIString(&writer, "<Record ", 8) < 0) {
goto error;
}
for (i = 0; i < n; ++i) {
PyObject *key;
PyObject *key_repr;
PyObject *val_repr;
if (i > 0) {
if (_PyUnicodeWriter_WriteChar(&writer, ' ') < 0) {
goto error;
}
}
if (Py_EnterRecursiveCall(" while getting the repr of a record")) {
goto error;
}
val_repr = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (val_repr == NULL) {
goto error;
}
key = PyIter_Next(keys_iter);
if (key == NULL) {
Py_DECREF(val_repr);
PyErr_SetString(PyExc_RuntimeError, "invalid record mapping");
goto error;
}
key_repr = PyObject_Str(key);
Py_DECREF(key);
if (key_repr == NULL) {
Py_DECREF(val_repr);
goto error;
}
if (_PyUnicodeWriter_WriteStr(&writer, key_repr) < 0) {
Py_DECREF(key_repr);
Py_DECREF(val_repr);
goto error;
}
Py_DECREF(key_repr);
if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) {
Py_DECREF(val_repr);
goto error;
}
if (_PyUnicodeWriter_WriteStr(&writer, val_repr) < 0) {
Py_DECREF(val_repr);
goto error;
}
Py_DECREF(val_repr);
}
writer.overallocate = 0;
if (_PyUnicodeWriter_WriteChar(&writer, '>') < 0) {
goto error;
}
Py_DECREF(keys_iter);
Py_ReprLeave((PyObject *)v);
return _PyUnicodeWriter_Finish(&writer);
error:
Py_DECREF(keys_iter);
_PyUnicodeWriter_Dealloc(&writer);
Py_ReprLeave((PyObject *)v);
return NULL;
}
PyObject *CALL_FUNCTION_WITH_ARGS9( PyObject *called, PyObject *arg1, PyObject *arg2, PyObject *arg3, PyObject *arg4, PyObject *arg5, PyObject *arg6, PyObject *arg7, PyObject *arg8, PyObject *arg9 )
{
assertObject( called );
// Check if arguments are valid objects in debug mode.
#ifndef __NUITKA_NO_ASSERT__
PyObject *args_for_test[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
for( size_t i = 0; i < sizeof( args_for_test ) / sizeof( PyObject * ); i++ )
{
assertObject( args_for_test[ i ] );
}
#endif
if ( Nuitka_Function_Check( called ) )
{
if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) ))
{
return NULL;
}
Nuitka_FunctionObject *function = (Nuitka_FunctionObject *)called;
PyObject *result;
PyObject *args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
if ( function->m_direct_arg_parser )
{
result = function->m_direct_arg_parser(
function,
args,
sizeof( args ) / sizeof( PyObject * )
);
}
else
{
result = function->m_code(
function,
args,
sizeof( args ) / sizeof( PyObject * ),
NULL
);
}
Py_LeaveRecursiveCall();
return result;
}
else if ( Nuitka_Method_Check( called ) )
{
Nuitka_MethodObject *method = (Nuitka_MethodObject *)called;
// Unbound method without arguments, let the error path be slow.
if ( method->m_object != NULL )
{
if (unlikely( Py_EnterRecursiveCall( (char *)" while calling a Python object" ) ))
{
return NULL;
}
PyObject *args[] = {
method->m_object,
arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
};
PyObject *result;
if ( method->m_function->m_direct_arg_parser )
{
result = method->m_function->m_direct_arg_parser(
method->m_function,
args,
sizeof( args ) / sizeof( PyObject * )
);
}
else
{
result = method->m_function->m_code(
method->m_function,
args,
sizeof( args ) / sizeof( PyObject * ),
NULL
);
}
Py_LeaveRecursiveCall();
return result;
}
}
else if ( PyFunction_Check( called ) )
{
PyObject *args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
return fast_python_call(
called,
args,
sizeof( args ) / sizeof( PyObject * )
);
}
PyObject *args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 };
PyObject *pos_args = MAKE_TUPLE( args, sizeof( args ) / sizeof( PyObject * ) );
PyObject *result = CALL_FUNCTION(
called,
pos_args,
NULL
);
Py_DECREF( pos_args );
return result;
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
_PyUnicodeWriter writer;
n = Py_SIZE(v);
if (n == 0)
return PyUnicode_FromString("()");
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyUnicode_FromString("(...)") : NULL;
}
_PyUnicodeWriter_Init(&writer);
writer.overallocate = 1;
if (Py_SIZE(v) > 1) {
/* "(" + "1" + ", 2" * (len - 1) + ")" */
writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;
}
else {
/* "(1,)" */
writer.min_length = 4;
}
if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0)
goto error;
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
PyObject *s;
if (i > 0) {
if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0)
goto error;
}
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto error;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (s == NULL)
goto error;
if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) {
Py_DECREF(s);
goto error;
}
Py_DECREF(s);
}
writer.overallocate = 0;
if (n > 1) {
if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0)
goto error;
}
else {
if (_PyUnicodeWriter_WriteASCIIString(&writer, ",)", 2) < 0)
goto error;
}
Py_ReprLeave((PyObject *)v);
return _PyUnicodeWriter_Finish(&writer);
error:
_PyUnicodeWriter_Dealloc(&writer);
Py_ReprLeave((PyObject *)v);
return NULL;
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
PyObject *s, *temp;
PyObject *pieces, *result = NULL;
n = v->ob_size;
if (n == 0)
return PyString_FromString("()");
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyString_FromString("(...)") : NULL;
}
pieces = PyTuple_New(n);
if (pieces == NULL)
return NULL;
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto Done;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (s == NULL)
goto Done;
PyTuple_SET_ITEM(pieces, i, s);
}
/* Add "()" decorations to the first and last items. */
assert(n > 0);
s = PyString_FromString("(");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, 0);
PyString_ConcatAndDel(&s, temp);
PyTuple_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
s = PyString_FromString(n == 1 ? ",)" : ")");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, n-1);
PyString_ConcatAndDel(&temp, s);
PyTuple_SET_ITEM(pieces, n-1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
s = PyString_FromString(", ");
if (s == NULL)
goto Done;
result = _PyString_Join(s, pieces);
Py_DECREF(s);
Done:
Py_DECREF(pieces);
Py_ReprLeave((PyObject *)v);
return result;
}