static PyFrameObject *duplicateFrame( PyFrameObject *old_frame, PyObject *locals )
{
PyFrameObject *new_frame = PyObject_GC_NewVar( PyFrameObject, &PyFrame_Type, 0 );
// Allow only to detach only our tracing frames.
assert( Py_TYPE( old_frame ) == &Nuitka_Frame_Type );
assert( old_frame->f_trace == Py_None );
new_frame->f_trace = Py_None;
Py_INCREF( Py_None );
// Copy the back reference if any.
new_frame->f_back = old_frame->f_back;
Py_XINCREF( new_frame->f_back );
// Take a code reference as well.
new_frame->f_code = old_frame->f_code;
Py_XINCREF( new_frame->f_code );
// Copy attributes.
new_frame->f_globals = INCREASE_REFCOUNT( old_frame->f_globals );
new_frame->f_locals = locals;
new_frame->f_builtins = INCREASE_REFCOUNT( old_frame->f_builtins );
new_frame->f_exc_type = NULL;
new_frame->f_exc_value = NULL;
new_frame->f_exc_traceback = NULL;
assert( old_frame->f_valuestack == old_frame->f_localsplus );
new_frame->f_valuestack = new_frame->f_localsplus;
assert( old_frame->f_stacktop == old_frame->f_valuestack );
new_frame->f_stacktop = new_frame->f_valuestack;
#if PYTHON_VERSION < 340
new_frame->f_tstate = old_frame->f_tstate;
#endif
new_frame->f_lasti = -1;
new_frame->f_lineno = old_frame->f_lineno;
assert( old_frame->f_iblock == 0 );
new_frame->f_iblock = 0;
#if PYTHON_VERSION >= 340
new_frame->f_gen = NULL;
new_frame->f_executing = 0;
#endif
Nuitka_GC_Track( new_frame );
return new_frame;
}
static inline PyObject *make_compiled_function( function_arg_parser code, direct_arg_parser dparse, PyObject *name, PyObject *qualname, PyCodeObject *code_object, PyObject *defaults, PyObject *kwdefaults, PyObject *annotations, PyObject *module, PyObject *doc, PyCellObject **closure, Py_ssize_t closure_given )
#endif
{
Nuitka_FunctionObject *result = PyObject_GC_New( Nuitka_FunctionObject, &Nuitka_Function_Type );
assert( result );
result->m_code = code;
result->m_direct_arg_parser = dparse;
result->m_name = INCREASE_REFCOUNT( name );
#if PYTHON_VERSION >= 330
result->m_qualname = INCREASE_REFCOUNT( qualname ? qualname : name );
#endif
if ( defaults == NULL )
{
defaults = INCREASE_REFCOUNT( Py_None );
}
CHECK_OBJECT( defaults );
assert( defaults == Py_None || ( PyTuple_Check( defaults ) && PyTuple_Size( defaults ) > 0 ) );
result->m_defaults = defaults;
result->m_defaults_given = defaults == Py_None ? 0 : PyTuple_GET_SIZE( defaults );
#if PYTHON_VERSION >= 300
if ( kwdefaults == NULL )
{
kwdefaults = INCREASE_REFCOUNT( Py_None );
}
assert( kwdefaults == Py_None || ( PyDict_Check( kwdefaults ) && PyDict_Size( kwdefaults ) > 0 ) );
result->m_kwdefaults = kwdefaults;
assert( annotations == Py_None || PyDict_Check( annotations ) );
result->m_annotations = INCREASE_REFCOUNT( annotations );
#endif
result->m_code_object = code_object;
result->m_module = module;
result->m_doc = INCREASE_REFCOUNT( doc );
result->m_dict = NULL;
result->m_weakrefs = NULL;
static long Nuitka_Function_counter = 0;
result->m_counter = Nuitka_Function_counter++;
result->m_closure = closure;
result->m_closure_given = closure_given;
Nuitka_GC_Track( result );
return (PyObject *)result;
}
NUITKA_MAY_BE_UNUSED static PyTracebackObject *MAKE_TRACEBACK( PyFrameObject *frame )
{
// assertFrameObject( frame );
PyTracebackObject *result = PyObject_GC_New( PyTracebackObject, &PyTraceBack_Type );
result->tb_next = NULL;
result->tb_frame = frame;
result->tb_lasti = 0;
result->tb_lineno = frame->f_lineno;
Nuitka_GC_Track( result );
return result;
}
PyObject *Nuitka_Generator_New( generator_code code, PyObject *name, PyObject *qualname, PyCodeObject *code_object, PyCellObject **closure, Py_ssize_t closure_given )
#endif
{
struct Nuitka_GeneratorObject *result = PyObject_GC_New( struct Nuitka_GeneratorObject, &Nuitka_Generator_Type );
assert( result != NULL );
result->m_code = (void *)code;
CHECK_OBJECT( name );
result->m_name = name;
Py_INCREF( name );
#if PYTHON_VERSION >= 350
CHECK_OBJECT( qualname );
result->m_qualname = qualname;
Py_INCREF( qualname );
result->m_yieldfrom = NULL;
#endif
// We take ownership of those and received the reference count from the
// caller.
result->m_closure = closure;
result->m_closure_given = closure_given;
result->m_weakrefs = NULL;
result->m_status = status_Unused;
result->m_running = false;
result->m_exception_type = NULL;
result->m_exception_value = NULL;
result->m_exception_tb = NULL;
result->m_yielded = NULL;
result->m_frame = NULL;
result->m_code_object = code_object;
initFiber( &result->m_yielder_context );
Nuitka_GC_Track( result );
return (PyObject *)result;
}
PyObject *Nuitka_Generator_New( yielder_func code, PyObject *name, PyCodeObject *code_object, void *context, releaser cleanup )
{
Nuitka_GeneratorObject *result = PyObject_GC_New( Nuitka_GeneratorObject, &Nuitka_Generator_Type );
if (unlikely( result == NULL ))
{
PyErr_Format(
PyExc_RuntimeError,
"cannot create genexpr %s",
Nuitka_String_AsString( name )
);
return NULL;
}
result->m_code = (void *)code;
result->m_name = INCREASE_REFCOUNT( name );
result->m_context = context;
result->m_cleanup = cleanup;
result->m_weakrefs = NULL;
result->m_status = status_Unused;
result->m_running = false;
result->m_exception_type = NULL;
result->m_exception_value = NULL;
result->m_exception_tb = NULL;
result->m_yielded = NULL;
result->m_frame = NULL;
result->m_code_object = code_object;
initFiber( &result->m_yielder_context );
Nuitka_GC_Track( result );
return (PyObject *)result;
}
PyObject *Nuitka_Method_New( struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass )
{
struct Nuitka_MethodObject *result = method_cache_head;
if ( result != NULL )
{
method_cache_head = (struct Nuitka_MethodObject *)method_cache_head->m_object;
method_cache_size -= 1;
Py_TYPE( result ) = &Nuitka_Method_Type;
_Py_NewReference( (PyObject *)result );
}
else
{
result = PyObject_GC_New(struct 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 = (struct Nuitka_FunctionObject *)INCREASE_REFCOUNT( (PyObject *)function );
result->m_object = object;
Py_XINCREF( object );
result->m_class = klass;
Py_XINCREF( klass );
result->m_weakrefs = NULL;
Nuitka_GC_Track( result );
return (PyObject *)result;
}
static PyFrameObject *MAKE_FRAME( PyCodeObject *code, PyObject *module, bool is_module )
{
PyTraceBack_Type.tp_dealloc = (destructor)tb_dealloc;
assertCodeObject( code );
PyObject *globals = ((PyModuleObject *)module)->md_dict;
assert( PyDict_Check( globals ) );
Py_ssize_t ncells = PyTuple_GET_SIZE( code->co_cellvars );
Py_ssize_t nfrees = PyTuple_GET_SIZE( code->co_freevars );
Py_ssize_t extras = code->co_stacksize + code->co_nlocals + ncells + nfrees;
Nuitka_FrameObject *result = PyObject_GC_NewVar( Nuitka_FrameObject, &Nuitka_Frame_Type, extras );
if (unlikely( result == NULL ))
{
return NULL;
}
PyFrameObject *frame = &result->m_frame;
frame->f_code = code;
extras = code->co_nlocals + ncells + nfrees;
frame->f_valuestack = frame->f_localsplus + extras;
for ( Py_ssize_t i = 0; i < extras; i++ )
{
frame->f_localsplus[i] = NULL;
}
frame->f_locals = NULL;
frame->f_trace = INCREASE_REFCOUNT( Py_None );
frame->f_exc_type = NULL;
frame->f_exc_value = NULL;
frame->f_exc_traceback = NULL;
frame->f_stacktop = frame->f_valuestack;
frame->f_builtins = INCREASE_REFCOUNT( (PyObject *)dict_builtin );
frame->f_back = NULL;
frame->f_globals = INCREASE_REFCOUNT( globals );
if (likely( (code->co_flags & CO_OPTIMIZED ) == CO_OPTIMIZED ))
{
frame->f_locals = NULL;
}
else if (is_module)
{
frame->f_locals = INCREASE_REFCOUNT( globals );
}
else
{
frame->f_locals = PyDict_New();
if (unlikely( frame->f_locals == NULL ))
{
Py_DECREF( result );
return NULL;
}
PyDict_SetItem(
frame->f_locals,
const_str_plain___module__,
MODULE_NAME( module )
);
}
#if PYTHON_VERSION < 340
frame->f_tstate = PyThreadState_GET();
#endif
frame->f_lasti = -1;
frame->f_lineno = code->co_firstlineno;
frame->f_iblock = 0;
#if PYTHON_VERSION >= 340
frame->f_gen = NULL;
frame->f_executing = 0;
#endif
Nuitka_GC_Track( result );
return (PyFrameObject *)result;
}
static struct Nuitka_FrameObject *MAKE_FRAME(PyCodeObject *code, PyObject *module, bool is_module,
Py_ssize_t locals_size) {
assertCodeObject(code);
PyObject *globals = ((PyModuleObject *)module)->md_dict;
assert(PyDict_Check(globals));
struct Nuitka_FrameObject *result;
// Macro to assign result memory from GC or free list.
allocateFromFreeList(free_list_frames, struct Nuitka_FrameObject, Nuitka_Frame_Type, locals_size);
result->m_type_description = NULL;
PyFrameObject *frame = &result->m_frame;
frame->f_code = code;
frame->f_trace = Py_None;
#if PYTHON_VERSION < 370
frame->f_exc_type = NULL;
frame->f_exc_value = NULL;
frame->f_exc_traceback = NULL;
#else
frame->f_trace_lines = 0;
frame->f_trace_opcodes = 0;
#endif
Py_INCREF(dict_builtin);
frame->f_builtins = (PyObject *)dict_builtin;
frame->f_back = NULL;
Py_INCREF(globals);
frame->f_globals = globals;
if (likely((code->co_flags & CO_OPTIMIZED) == CO_OPTIMIZED)) {
frame->f_locals = NULL;
} else if (is_module) {
Py_INCREF(globals);
frame->f_locals = globals;
} else {
frame->f_locals = PyDict_New();
if (unlikely(frame->f_locals == NULL)) {
Py_DECREF(result);
return NULL;
}
PyDict_SetItem(frame->f_locals, const_str_plain___module__, MODULE_NAME(module));
}
#if PYTHON_VERSION < 340
frame->f_tstate = PyThreadState_GET();
#endif
frame->f_lasti = -1;
frame->f_lineno = code->co_firstlineno;
frame->f_iblock = 0;
#if PYTHON_VERSION >= 340
frame->f_gen = NULL;
frame->f_executing = 0;
#endif
Nuitka_GC_Track(result);
return result;
}
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
{
