// Restore a previously preserved exception to the frame.
NUITKA_MAY_BE_UNUSED static inline void RESTORE_FRAME_EXCEPTION( PyFrameObject *frame_object )
{
if ( frame_object->f_exc_type )
{
#if _DEBUG_EXCEPTIONS
PRINT_STRING("RESTORE_FRAME_EXCEPTION: restoring preserved\n");
PRINT_ITEM( (PyObject *)frame_object );
PRINT_NEW_LINE();
#endif
SET_CURRENT_EXCEPTION( frame_object->f_exc_type, frame_object->f_exc_value, (PyTracebackObject *)frame_object->f_exc_traceback );
frame_object->f_exc_type = NULL;
frame_object->f_exc_value = NULL;
frame_object->f_exc_traceback = NULL;
}
#if _DEBUG_EXCEPTIONS
else
{
PRINT_STRING("RESTORE_FRAME_EXCEPTION: nothing to restore\n");
PRINT_ITEM( (PyObject *)frame_object );
PRINT_NEW_LINE();
}
#endif
}
// Publish an exception, erasing the values of the variables.
NUITKA_MAY_BE_UNUSED static inline void PUBLISH_EXCEPTION( PyObject **exception_type, PyObject **exception_value, PyTracebackObject **exception_tb )
{
#if _DEBUG_EXCEPTIONS
PRINT_STRING("PUBLISH_EXCEPTION:\n");
#endif
SET_CURRENT_EXCEPTION( *exception_type, *exception_value, *exception_tb );
*exception_type = NULL;
*exception_value = NULL;
*exception_tb = NULL;
}
static PyObject *Nuitka_Generator_send( struct Nuitka_GeneratorObject *generator, PyObject *value )
{
if ( generator->m_status == status_Unused && value != NULL && value != Py_None )
{
PyErr_Format( PyExc_TypeError, "can't send non-None value to a just-started generator" );
return NULL;
}
if ( generator->m_status != status_Finished )
{
PyThreadState *thread_state = PyThreadState_GET();
#if PYTHON_VERSION < 300
PyObject *saved_exception_type = thread_state->exc_type;
Py_XINCREF( saved_exception_type );
PyObject *saved_exception_value = thread_state->exc_value;
Py_XINCREF( saved_exception_value );
PyTracebackObject *saved_exception_traceback = (PyTracebackObject *)thread_state->exc_traceback;
Py_XINCREF( saved_exception_traceback );
#endif
if ( generator->m_running )
{
PyErr_Format( PyExc_ValueError, "generator already executing" );
return NULL;
}
if ( generator->m_status == status_Unused )
{
// Prepare the generator context to run.
int res = prepareFiber( &generator->m_yielder_context, (void *)Nuitka_Generator_entry_point, (uintptr_t)generator );
if ( res != 0 )
{
PyErr_Format( PyExc_MemoryError, "generator cannot be allocated" );
return NULL;
}
generator->m_status = status_Running;
}
generator->m_yielded = value;
// Put the generator back on the frame stack.
PyFrameObject *return_frame = thread_state->frame;
#ifndef __NUITKA_NO_ASSERT__
if ( return_frame )
{
assertFrameObject( return_frame );
}
#endif
if ( generator->m_frame )
{
// It would be nice if our frame were still alive. Nobody had the
// right to release it.
assertFrameObject( generator->m_frame );
// It's not supposed to be on the top right now.
assert( return_frame != generator->m_frame );
Py_XINCREF( return_frame );
generator->m_frame->f_back = return_frame;
thread_state->frame = generator->m_frame;
}
// Continue the yielder function while preventing recursion.
generator->m_running = true;
swapFiber( &generator->m_caller_context, &generator->m_yielder_context );
generator->m_running = false;
thread_state = PyThreadState_GET();
// Remove the generator from the frame stack.
if ( generator->m_frame )
{
assert( thread_state->frame == generator->m_frame );
assertFrameObject( generator->m_frame );
Py_CLEAR( generator->m_frame->f_back );
}
thread_state->frame = return_frame;
if ( generator->m_yielded == NULL )
{
assert( ERROR_OCCURRED() );
generator->m_status = status_Finished;
Py_XDECREF( generator->m_frame );
generator->m_frame = NULL;
Nuitka_Generator_release_closure( generator );
assert( ERROR_OCCURRED() );
#if PYTHON_VERSION < 300
Py_XDECREF( saved_exception_type );
Py_XDECREF( saved_exception_value );
Py_XDECREF( saved_exception_traceback );
#endif
#if PYTHON_VERSION >= 350
if ( generator->m_code_object->co_flags & CO_FUTURE_GENERATOR_STOP &&
GET_ERROR_OCCURRED() == PyExc_StopIteration )
{
PyObject *saved_exception_type, *saved_exception_value;
PyTracebackObject *saved_exception_tb;
FETCH_ERROR_OCCURRED( &saved_exception_type, &saved_exception_value, &saved_exception_tb );
NORMALIZE_EXCEPTION( &saved_exception_type, &saved_exception_value, &saved_exception_tb );
PyErr_Format(
PyExc_RuntimeError,
"generator raised StopIteration"
);
PyObject *exception_type, *exception_value;
PyTracebackObject *exception_tb;
FETCH_ERROR_OCCURRED( &exception_type, &exception_value, &exception_tb );
RAISE_EXCEPTION_WITH_CAUSE(
&exception_type,
&exception_value,
&exception_tb,
saved_exception_value
);
CHECK_OBJECT( exception_value );
CHECK_OBJECT( saved_exception_value );
Py_INCREF( saved_exception_value );
PyException_SetContext( exception_value, saved_exception_value );
Py_DECREF( saved_exception_type );
Py_XDECREF( saved_exception_tb );
RESTORE_ERROR_OCCURRED( exception_type, exception_value, exception_tb );
}
#endif
return NULL;
}
else
{
#if PYTHON_VERSION < 300
SET_CURRENT_EXCEPTION( saved_exception_type, saved_exception_value, saved_exception_traceback );
#endif
return generator->m_yielded;
}
}
else
{
PyErr_SetObject( PyExc_StopIteration, (PyObject *)NULL );
return NULL;
}
}
static PyObject *Nuitka_Generator_send( Nuitka_GeneratorObject *generator, PyObject *value )
{
if ( generator->m_status == status_Unused && value != NULL && value != Py_None )
{
PyErr_Format( PyExc_TypeError, "can't send non-None value to a just-started generator" );
return NULL;
}
if ( generator->m_status != status_Finished )
{
PyThreadState *thread_state = PyThreadState_GET();
#if PYTHON_VERSION < 300
PyObject *saved_exception_type = INCREASE_REFCOUNT_X( thread_state->exc_type );
PyObject *saved_exception_value = INCREASE_REFCOUNT_X( thread_state->exc_value );
PyTracebackObject *saved_exception_traceback = INCREASE_REFCOUNT_X( (PyTracebackObject *)thread_state->exc_traceback );
#endif
if ( generator->m_running )
{
PyErr_Format( PyExc_ValueError, "generator already executing" );
return NULL;
}
if ( generator->m_status == status_Unused )
{
generator->m_status = status_Running;
// Prepare the generator context to run.
prepareFiber( &generator->m_yielder_context, generator->m_code, (intptr_t)generator );
}
generator->m_yielded = value;
// Put the generator back on the frame stack.
PyFrameObject *return_frame = thread_state->frame;
#ifndef __NUITKA_NO_ASSERT__
if ( return_frame )
{
assertFrameObject( return_frame );
}
#endif
if ( generator->m_frame )
{
// It would be nice if our frame were still alive. Nobody had the
// right to release it.
assertFrameObject( generator->m_frame );
// It's not supposed to be on the top right now.
assert( return_frame != generator->m_frame );
Py_XINCREF( return_frame );
generator->m_frame->f_back = return_frame;
thread_state->frame = generator->m_frame;
}
// Continue the yielder function while preventing recursion.
generator->m_running = true;
swapFiber( &generator->m_caller_context, &generator->m_yielder_context );
generator->m_running = false;
thread_state = PyThreadState_GET();
// Remove the generator from the frame stack.
if ( generator->m_frame )
{
assert( thread_state->frame == generator->m_frame );
assertFrameObject( generator->m_frame );
Py_CLEAR( generator->m_frame->f_back );
}
thread_state->frame = return_frame;
if ( generator->m_yielded == NULL )
{
assert( ERROR_OCCURED() );
generator->m_status = status_Finished;
Py_XDECREF( generator->m_frame );
generator->m_frame = NULL;
if ( generator->m_context )
{
// Surpressing exception in cleanup, to restore later before
// return.
generator->m_cleanup( generator->m_context );
generator->m_context = NULL;
}
assert( ERROR_OCCURED() );
#if PYTHON_VERSION < 300
Py_XDECREF( saved_exception_type );
Py_XDECREF( saved_exception_value );
Py_XDECREF( saved_exception_traceback );
#endif
return NULL;
}
else
{
#if PYTHON_VERSION < 300
SET_CURRENT_EXCEPTION( saved_exception_type, saved_exception_value, saved_exception_traceback );
#endif
return generator->m_yielded;
}
}
else
{
PyErr_SetObject( PyExc_StopIteration, (PyObject *)NULL );
return NULL;
}
}
