void save( const PythonException &e ) { this->exception_type = INCREASE_REFCOUNT_X( e.exception_type ); this->exception_value = INCREASE_REFCOUNT_X( e.exception_value ); this->exception_tb = INCREASE_REFCOUNT_X( e.exception_tb ); this->keeping = true; }
NUITKA_NO_RETURN NUITKA_MAY_BE_UNUSED static void RAISE_EXCEPTION_WITH_VALUE_NO_NORMALIZE( PyObject *exception_type, PyObject *value, PyObject *tb ) { PyTracebackObject *traceback = (PyTracebackObject *)tb; assertObject( exception_type ); assert( !PyTuple_Check( exception_type ) ); if ( PyExceptionClass_Check( exception_type ) ) { throw PythonException( INCREASE_REFCOUNT( exception_type ), INCREASE_REFCOUNT( value ), INCREASE_REFCOUNT_X( traceback ) ); } else if ( PyExceptionInstance_Check( exception_type ) ) { assert ( value == NULL || value == Py_None ); // The type is rather a value, so we are overriding it here. value = exception_type; exception_type = PyExceptionInstance_Class( exception_type ); throw PythonException( INCREASE_REFCOUNT( exception_type ), INCREASE_REFCOUNT( value ), INCREASE_REFCOUNT_X( traceback ) ); } else { assert( false ); PyErr_Format( PyExc_TypeError, WRONG_EXCEPTION_TYPE_ERROR_MESSAGE, Py_TYPE( exception_type )->tp_name ); throw PythonException(); } }
PyObject *Nuitka_Method_New( Nuitka_FunctionObject *function, PyObject *object, PyObject *klass ) { Nuitka_MethodObject *result = method_cache_head; if ( result != NULL ) { method_cache_head = (Nuitka_MethodObject *)method_cache_head->m_object; method_cache_size -= 1; PyObject_INIT( result, &Nuitka_Method_Type ); } else { result = PyObject_GC_New( Nuitka_MethodObject, &Nuitka_Method_Type ); } if (unlikely( result == NULL )) { PyErr_Format( PyExc_RuntimeError, "cannot create method %s", Nuitka_String_AsString( function->m_name ) ); return NULL; } result->m_function = (Nuitka_FunctionObject * )INCREASE_REFCOUNT( (PyObject *)function ); result->m_object = INCREASE_REFCOUNT_X( object ); result->m_class = INCREASE_REFCOUNT_X( klass ); result->m_weakrefs = NULL; Nuitka_GC_Track( result ); return (PyObject *)result; }
// Helper that sets the current thread exception, releasing the current one, for use in this // file only. inline void _SET_CURRENT_EXCEPTION( PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb ) { PyThreadState *thread_state = PyThreadState_GET(); PyObject *old_type = thread_state->exc_type; PyObject *old_value = thread_state->exc_value; PyObject *old_tb = thread_state->exc_traceback; thread_state->exc_type = INCREASE_REFCOUNT_X( exception_type ); thread_state->exc_value = INCREASE_REFCOUNT_X( exception_value ); thread_state->exc_traceback = (PyObject *)INCREASE_REFCOUNT_X( exception_tb ); Py_XDECREF( old_type ); Py_XDECREF( old_value ); Py_XDECREF( old_tb ); // Set sys attributes in the fastest possible way. PyObject *sys_dict = thread_state->interp->sysdict; assertObject( sys_dict ); PyDict_SetItem( sys_dict, _python_str_plain_exc_type, exception_type ? exception_type : Py_None ); PyDict_SetItem( sys_dict, _python_str_plain_exc_value, exception_value ? exception_value : Py_None ); PyDict_SetItem( sys_dict, _python_str_plain_exc_traceback, exception_tb ? (PyObject *)exception_tb : Py_None ); }
static PyObject *fparse_function_1_inner_of_function_1_permalink_of_module_django__db__models( Nuitka_FunctionObject *self, PyObject **args, Py_ssize_t args_size, PyObject *kw ) { assert( kw == NULL || PyDict_Check( kw ) ); NUITKA_MAY_BE_UNUSED Py_ssize_t kw_size = kw ? PyDict_Size( kw ) : 0; NUITKA_MAY_BE_UNUSED Py_ssize_t kw_found = 0; NUITKA_MAY_BE_UNUSED Py_ssize_t kw_only_found = 0; Py_ssize_t args_given = args_size; PyObject *_python_par_args = NULL; PyObject *_python_par_kwargs = NULL; if ( kw == NULL ) { _python_par_kwargs = PyDict_New(); } else { if ( ((PyDictObject *)kw)->ma_used > 0 ) { #if PYTHON_VERSION < 330 _python_par_kwargs = _PyDict_NewPresized( ((PyDictObject *)kw)->ma_used ); for ( int i = 0; i <= ((PyDictObject *)kw)->ma_mask; i++ ) { PyDictEntry *entry = &((PyDictObject *)kw)->ma_table[ i ]; if ( entry->me_value != NULL ) { #if PYTHON_VERSION < 300 if (unlikely( !PyString_Check( entry->me_key ) && !PyUnicode_Check( entry->me_key ) )) #else if (unlikely( !PyUnicode_Check( entry->me_key ) )) #endif { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } int res = PyDict_SetItem( _python_par_kwargs, entry->me_key, entry->me_value ); if (unlikely( res == -1 )) { goto error_exit; } } } #else if ( _PyDict_HasSplitTable( ((PyDictObject *)kw) ) ) { PyDictObject *mp = (PyDictObject *)kw; PyObject **newvalues = PyMem_NEW( PyObject *, mp->ma_keys->dk_size ); assert (newvalues != NULL); PyDictObject *split_copy = PyObject_GC_New( PyDictObject, &PyDict_Type ); assert( split_copy != NULL ); split_copy->ma_values = newvalues; split_copy->ma_keys = mp->ma_keys; split_copy->ma_used = mp->ma_used; mp->ma_keys->dk_refcnt += 1; Nuitka_GC_Track( split_copy ); int size = mp->ma_keys->dk_size; for ( int i = 0; i < size; i++ ) { PyDictKeyEntry *entry = &split_copy->ma_keys->dk_entries[ i ]; if (unlikely( !PyUnicode_Check( entry->me_key ) )) { PyErr_Format( PyExc_TypeError, "inner() keywords must be strings" ); goto error_exit; } split_copy->ma_values[ i ] = INCREASE_REFCOUNT_X( mp->ma_values[ i ] ); } _python_par_kwargs = (PyObject *)split_copy; } else {
NUITKA_NO_RETURN NUITKA_MAY_BE_UNUSED static void RAISE_EXCEPTION_WITH_VALUE( PyObject *exception_type, PyObject *value, PyObject *exception_tb ) { assertObject( exception_type ); PyTracebackObject *traceback = (PyTracebackObject *)exception_tb; // Non-empty tuple exceptions are the first element. while (unlikely( PyTuple_Check( exception_type ) && PyTuple_Size( exception_type ) > 0 )) { exception_type = PyTuple_GET_ITEM( exception_type, 0 ); } if ( PyExceptionClass_Check( exception_type ) ) { Py_INCREF( exception_type ); Py_XINCREF( value ); Py_XINCREF( traceback ); NORMALIZE_EXCEPTION( &exception_type, &value, &traceback ); #if PYTHON_VERSION >= 270 if (unlikely( !PyExceptionInstance_Check( value ) )) { PyErr_Format( PyExc_TypeError, "calling %s() should have returned an instance of BaseException, not '%s'", ((PyTypeObject *)exception_type)->tp_name, Py_TYPE( value )->tp_name ); Py_DECREF( exception_type ); Py_XDECREF( value ); Py_XDECREF( traceback ); throw PythonException(); } #endif throw PythonException( exception_type, value, traceback ); } else if ( PyExceptionInstance_Check( exception_type ) ) { if (unlikely( value != NULL && value != Py_None )) { PyErr_Format( PyExc_TypeError, "instance exception may not have a separate value" ); throw PythonException(); } // The type is rather a value, so we are overriding it here. value = exception_type; exception_type = PyExceptionInstance_Class( exception_type ); throw PythonException( INCREASE_REFCOUNT( exception_type ), INCREASE_REFCOUNT( value ), INCREASE_REFCOUNT_X( traceback ) ); } else { PyErr_Format( PyExc_TypeError, WRONG_EXCEPTION_TYPE_ERROR_MESSAGE, Py_TYPE( exception_type )->tp_name ); throw PythonException(); } }
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; } }