Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledFrameType.c

@@ -1,25 +1,10 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
-#include "nuitka/prelude.h"
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
 
+#ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
-
-#include "structmember.h"
+#include "nuitka/prelude.h"
+#include <structmember.h>
+#endif
 
 // For reporting about reference counts per type.
 #if _DEBUG_REFCOUNTS
@@ -37,7 +22,7 @@ int count_hit_frame_cache_instances = 0;
 #endif
 
 #if PYTHON_VERSION < 0x3b0
-static PyMemberDef Nuitka_Frame_memberlist[] = {
+static PyMemberDef Nuitka_Frame_members[] = {
     {(char *)"f_back", T_OBJECT, offsetof(PyFrameObject, f_back), READONLY | RESTRICTED},
     {(char *)"f_code", T_OBJECT, offsetof(PyFrameObject, f_code), READONLY | RESTRICTED},
     {(char *)"f_builtins", T_OBJECT, offsetof(PyFrameObject, f_builtins), READONLY | RESTRICTED},
@@ -46,12 +31,16 @@ static PyMemberDef Nuitka_Frame_memberlist[] = {
     {NULL}};
 
 #else
-#define Nuitka_Frame_memberlist 0
+#define Nuitka_Frame_members 0
 #endif
 
 #if PYTHON_VERSION < 0x300
 
-static PyObject *Nuitka_Frame_get_exc_traceback(struct Nuitka_FrameObject *frame) {
+static PyObject *_Nuitka_Frame_get_exc_traceback(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result = frame->m_frame.f_exc_traceback;
 
     if (result == NULL) {
@@ -62,7 +51,11 @@ static PyObject *Nuitka_Frame_get_exc_traceback(struct Nuitka_FrameObject *frame
     return result;
 }
 
-static int Nuitka_Frame_set_exc_traceback(struct Nuitka_FrameObject *frame, PyObject *traceback) {
+static int _Nuitka_Frame_set_exc_traceback(struct Nuitka_FrameObject *frame, PyObject *traceback) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     Py_XDECREF(frame->m_frame.f_exc_traceback);
 
     if (traceback == Py_None) {
@@ -75,7 +68,11 @@ static int Nuitka_Frame_set_exc_traceback(struct Nuitka_FrameObject *frame, PyOb
     return 0;
 }
 
-static PyObject *Nuitka_Frame_get_exc_type(struct Nuitka_FrameObject *frame) {
+static PyObject *_Nuitka_Frame_get_exc_type(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result;
 
     if (frame->m_frame.f_exc_type != NULL) {
@@ -88,7 +85,11 @@ static PyObject *Nuitka_Frame_get_exc_type(struct Nuitka_FrameObject *frame) {
     return result;
 }
 
-static int Nuitka_Frame_set_exc_type(struct Nuitka_FrameObject *frame, PyObject *exception_type) {
+static int _Nuitka_Frame_set_exc_type(struct Nuitka_FrameObject *frame, PyObject *exception_type) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *old = frame->m_frame.f_exc_type;
 
     if (exception_type == Py_None) {
@@ -103,7 +104,11 @@ static int Nuitka_Frame_set_exc_type(struct Nuitka_FrameObject *frame, PyObject
     return 0;
 }
 
-static PyObject *Nuitka_Frame_get_exc_value(struct Nuitka_FrameObject *frame) {
+static PyObject *_Nuitka_Frame_get_exc_value(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result;
 
     if (frame->m_frame.f_exc_value != NULL) {
@@ -116,7 +121,11 @@ static PyObject *Nuitka_Frame_get_exc_value(struct Nuitka_FrameObject *frame) {
     return result;
 }
 
-static int Nuitka_Frame_set_exc_value(struct Nuitka_FrameObject *frame, PyObject *exception_value) {
+static int _Nuitka_Frame_set_exc_value(struct Nuitka_FrameObject *frame, PyObject *exception_value) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *old = frame->m_frame.f_exc_value;
 
     if (exception_value == Py_None) {
@@ -130,14 +139,24 @@ static int Nuitka_Frame_set_exc_value(struct Nuitka_FrameObject *frame, PyObject
     return 0;
 }
 
-static PyObject *Nuitka_Frame_get_restricted(struct Nuitka_FrameObject *frame, void *closure) {
-    Py_INCREF(Py_False);
+static PyObject *_Nuitka_Frame_get_restricted(struct Nuitka_FrameObject *frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
+    Py_INCREF_IMMORTAL(Py_False);
     return Py_False;
 }
 
 #endif
 
-static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame, void *closure) {
+static PyObject *_Nuitka_Frame_get_locals(struct Nuitka_FrameObject *nuitka_frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)nuitka_frame));
+    CHECK_OBJECT((PyObject *)nuitka_frame);
+    assert(_PyObject_GC_IS_TRACKED(nuitka_frame));
+
+    NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
+
     if (nuitka_frame->m_type_description == NULL) {
 #if PYTHON_VERSION < 0x3b0
         PyFrameObject *locals_owner = &nuitka_frame->m_frame;
@@ -146,14 +165,14 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
 #endif
 
         if (locals_owner->f_locals == NULL) {
-            locals_owner->f_locals = MAKE_DICT_EMPTY();
+            locals_owner->f_locals = MAKE_DICT_EMPTY(tstate);
         }
 
         Py_INCREF(locals_owner->f_locals);
         return locals_owner->f_locals;
     } else {
-        PyObject *result = MAKE_DICT_EMPTY();
-        PyObject **varnames = Nuitka_GetCodeVarNames(Nuitka_GetFrameCodeObject(nuitka_frame));
+        PyObject *result = MAKE_DICT_EMPTY(tstate);
+        PyObject **var_names = Nuitka_GetCodeVarNames(Nuitka_GetFrameCodeObject(nuitka_frame));
 
         char const *w = nuitka_frame->m_type_description;
         char const *t = nuitka_frame->m_locals_storage;
@@ -166,7 +185,7 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
                 CHECK_OBJECT_X(value);
 
                 if (value != NULL) {
-                    DICT_SET_ITEM(result, *varnames, value);
+                    DICT_SET_ITEM(result, *var_names, value);
                 }
 
                 t += sizeof(PyObject *);
@@ -179,7 +198,7 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
                 CHECK_OBJECT(value);
 
                 if (value->ob_ref != NULL) {
-                    DICT_SET_ITEM(result, *varnames, value->ob_ref);
+                    DICT_SET_ITEM(result, *var_names, value->ob_ref);
                 }
 
                 t += sizeof(struct Nuitka_CellObject *);
@@ -194,11 +213,11 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
                 t += sizeof(int);
                 switch ((nuitka_bool)value) {
                 case NUITKA_BOOL_TRUE: {
-                    DICT_SET_ITEM(result, *varnames, Py_True);
+                    DICT_SET_ITEM(result, *var_names, Py_True);
                     break;
                 }
                 case NUITKA_BOOL_FALSE: {
-                    DICT_SET_ITEM(result, *varnames, Py_False);
+                    DICT_SET_ITEM(result, *var_names, Py_False);
                     break;
                 }
                 default:
@@ -211,24 +230,36 @@ static PyObject *Nuitka_Frame_getlocals(struct Nuitka_FrameObject *nuitka_frame,
             }
 
             w += 1;
-            varnames += 1;
+            var_names += 1;
         }
 
         return result;
     }
 }
 
-static PyObject *Nuitka_Frame_getlineno(struct Nuitka_FrameObject *frame, void *closure) {
+static PyObject *_Nuitka_Frame_get_lineno(struct Nuitka_FrameObject *frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     return PyInt_FromLong(frame->m_frame.f_lineno);
 }
 
-static PyObject *Nuitka_Frame_gettrace(struct Nuitka_FrameObject *frame, void *closure) {
+static PyObject *_Nuitka_Frame_get_trace(struct Nuitka_FrameObject *frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result = frame->m_frame.f_trace;
     Py_INCREF(result);
     return result;
 }
 
-static int Nuitka_Frame_settrace(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+static int _Nuitka_Frame_set_trace(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyThreadState *tstate = PyThreadState_GET();
 
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace is not writable in Nuitka");
@@ -236,26 +267,42 @@ static int Nuitka_Frame_settrace(struct Nuitka_FrameObject *frame, PyObject *v,
 }
 
 #if PYTHON_VERSION >= 0x370
-static PyObject *Nuitka_Frame_gettracelines(struct Nuitka_FrameObject *frame, void *closure) {
+static PyObject *_Nuitka_Frame_get_trace_lines(struct Nuitka_FrameObject *frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result = Py_False;
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
-static int Nuitka_Frame_settracelines(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+static int _Nuitka_Frame_set_trace_lines(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyThreadState *tstate = PyThreadState_GET();
 
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace_lines is not writable in Nuitka");
     return -1;
 }
 
-static PyObject *Nuitka_Frame_gettraceopcodes(struct Nuitka_FrameObject *frame, void *closure) {
+static PyObject *_Nuitka_Frame_get_trace_opcodes(struct Nuitka_FrameObject *frame, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyObject *result = Py_False;
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
-static int Nuitka_Frame_settraceopcodes(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+static int _Nuitka_Frame_set_trace_opcodes(struct Nuitka_FrameObject *frame, PyObject *v, void *closure) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyThreadState *tstate = PyThreadState_GET();
 
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace_opcodes is not writable in Nuitka");
@@ -263,33 +310,27 @@ static int Nuitka_Frame_settraceopcodes(struct Nuitka_FrameObject *frame, PyObje
 }
 #endif
 
-#if PYTHON_VERSION >= 0x3B0
-static PyObject *Nuitka_Frame_getback(struct Nuitka_FrameObject *frame, void *closure) {
-    return (PyObject *)PyFrame_GetBack(&frame->m_frame);
-}
-#endif
-
-static PyGetSetDef Nuitka_Frame_getsetlist[] = {
-    {(char *)"f_locals", (getter)Nuitka_Frame_getlocals, NULL, NULL},
-    {(char *)"f_lineno", (getter)Nuitka_Frame_getlineno, NULL, NULL},
-    {(char *)"f_trace", (getter)Nuitka_Frame_gettrace, (setter)Nuitka_Frame_settrace, NULL},
+static PyGetSetDef Nuitka_Frame_tp_getset[] = {
+    {(char *)"f_locals", (getter)_Nuitka_Frame_get_locals, NULL, NULL},
+    {(char *)"f_lineno", (getter)_Nuitka_Frame_get_lineno, NULL, NULL},
+    {(char *)"f_trace", (getter)_Nuitka_Frame_get_trace, (setter)_Nuitka_Frame_set_trace, NULL},
 #if PYTHON_VERSION < 0x300
-    {(char *)"f_restricted", (getter)Nuitka_Frame_get_restricted, NULL, NULL},
-    {(char *)"f_exc_traceback", (getter)Nuitka_Frame_get_exc_traceback, (setter)Nuitka_Frame_set_exc_traceback, NULL},
-    {(char *)"f_exc_type", (getter)Nuitka_Frame_get_exc_type, (setter)Nuitka_Frame_set_exc_type, NULL},
-    {(char *)"f_exc_value", (getter)Nuitka_Frame_get_exc_value, (setter)Nuitka_Frame_set_exc_value, NULL},
+    {(char *)"f_restricted", (getter)_Nuitka_Frame_get_restricted, NULL, NULL},
+    {(char *)"f_exc_traceback", (getter)_Nuitka_Frame_get_exc_traceback, (setter)_Nuitka_Frame_set_exc_traceback, NULL},
+    {(char *)"f_exc_type", (getter)_Nuitka_Frame_get_exc_type, (setter)_Nuitka_Frame_set_exc_type, NULL},
+    {(char *)"f_exc_value", (getter)_Nuitka_Frame_get_exc_value, (setter)_Nuitka_Frame_set_exc_value, NULL},
 #endif
 #if PYTHON_VERSION >= 0x370
-    {(char *)"f_trace_lines", (getter)Nuitka_Frame_gettracelines, (setter)Nuitka_Frame_settracelines, NULL},
-    {(char *)"f_trace_opcodes", (getter)Nuitka_Frame_gettraceopcodes, (setter)Nuitka_Frame_settraceopcodes, NULL},
-#endif
-#if PYTHON_VERSION >= 0x3b0
-    {(char *)"f_trace_lines", (getter)Nuitka_Frame_getback, NULL, NULL},
+    {(char *)"f_trace_lines", (getter)_Nuitka_Frame_get_trace_lines, (setter)_Nuitka_Frame_set_trace_lines, NULL},
+    {(char *)"f_trace_opcodes", (getter)_Nuitka_Frame_get_trace_opcodes, (setter)_Nuitka_Frame_set_trace_opcodes, NULL},
 #endif
     {NULL}};
 
 // tp_repr slot, decide how a function shall be output
 static PyObject *Nuitka_Frame_tp_repr(struct Nuitka_FrameObject *nuitka_frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)nuitka_frame));
+    CHECK_OBJECT((PyObject *)nuitka_frame);
+    assert(_PyObject_GC_IS_TRACKED(nuitka_frame));
 
 #if PYTHON_VERSION >= 0x370
     PyCodeObject *code_object = Nuitka_GetFrameCodeObject(nuitka_frame);
@@ -367,10 +408,9 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
     // Save the current exception, if any, we must to not corrupt it.
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state1;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
 #endif
 
     Nuitka_GC_UnTrack(nuitka_frame);
@@ -382,6 +422,7 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
     _PyInterpreterFrame *locals_owner = &nuitka_frame->m_interpreter_frame;
 #endif
 
+    assert(Nuitka_GC_IS_TRACKED_X((PyObject *)frame->f_back));
     Py_XDECREF(frame->f_back);
     Py_DECREF(locals_owner->f_builtins);
     Py_DECREF(locals_owner->f_globals);
@@ -395,6 +436,13 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
 
     Nuitka_Frame_tp_clear(nuitka_frame);
 
+    Py_SET_REFCNT(nuitka_frame, Py_REFCNT(nuitka_frame) - 1);
+    if (Py_REFCNT(nuitka_frame) >= 1) {
+        // TODO: Allow this in debug mode, for now we would like to reproduce it.
+        assert(false);
+        return;
+    }
+
 #if PYTHON_VERSION >= 0x3b0
     // Restore from backup, see header comment for the field "m_ob_size" to get
     // it.
@@ -404,13 +452,19 @@ static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
     releaseToFreeList(free_list_frames, nuitka_frame, MAX_FRAME_FREE_LIST_COUNT);
 
 #ifndef __NUITKA_NO_ASSERT__
-    assert(tstate->curexc_type == save_exception_type);
-    assert(tstate->curexc_value == save_exception_value);
-    assert((PyTracebackObject *)tstate->curexc_traceback == save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state2;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+
+    ASSERT_SAME_EXCEPTION_STATE(&saved_exception_state1, &saved_exception_state2);
 #endif
 }
 
 static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc visit, void *arg) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     Py_VISIT(frame->m_frame.f_back);
 
 #if PYTHON_VERSION < 0x3b0
@@ -474,9 +528,13 @@ static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc
     return 0;
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 
 static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     PyThreadState *tstate = PyThreadState_GET();
 
     if (Nuitka_Frame_IsExecuting(frame)) {
@@ -498,7 +556,7 @@ static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame) {
     }
 #endif
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     // For frames that are closed, we also need to close the generator.
     PyObject *f_gen = Nuitka_GetFrameGenerator(frame);
     if (f_gen != NULL) {
@@ -555,6 +613,10 @@ static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame) {
 #endif
 
 static inline Py_ssize_t Nuitka_Frame_GetSize(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
 #if PYTHON_VERSION < 0x3b0
     return Py_SIZE(frame);
 #else
@@ -563,11 +625,15 @@ static inline Py_ssize_t Nuitka_Frame_GetSize(struct Nuitka_FrameObject *frame)
 }
 
 static PyObject *Nuitka_Frame_sizeof(struct Nuitka_FrameObject *frame) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame));
+    CHECK_OBJECT((PyObject *)frame);
+    assert(_PyObject_GC_IS_TRACKED(frame));
+
     return PyInt_FromSsize_t(sizeof(struct Nuitka_FrameObject) + Py_SIZE(frame));
 }
 
 static PyMethodDef Nuitka_Frame_methods[] = {
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     {"clear", (PyCFunction)Nuitka_Frame_clear, METH_NOARGS, "F.clear(): clear most references held by the frame"},
 #endif
     {"__sizeof__", (PyCFunction)Nuitka_Frame_sizeof, METH_NOARGS, "F.__sizeof__() -> size of F in memory, in bytes"},
@@ -601,8 +667,8 @@ PyTypeObject Nuitka_Frame_Type = {
     0,                                       // tp_iter
     0,                                       // tp_iternext
     Nuitka_Frame_methods,                    // tp_methods
-    Nuitka_Frame_memberlist,                 // tp_members
-    Nuitka_Frame_getsetlist,                 // tp_getset
+    Nuitka_Frame_members,                    // tp_members
+    Nuitka_Frame_tp_getset,                  // tp_getset
     0,                                       // tp_base
     0,                                       // tp_dict
 };
@@ -619,23 +685,24 @@ void _initCompiledFrameType(void) {
     assert(Nuitka_Frame_Type.tp_methods != PyFrame_Type.tp_methods);
     assert(Nuitka_Frame_Type.tp_members != PyFrame_Type.tp_members);
     assert(Nuitka_Frame_Type.tp_getset != PyFrame_Type.tp_getset);
-    assert(Nuitka_Frame_Type.tp_dict != PyFrame_Type.tp_dict);
+
     assert(Nuitka_Frame_Type.tp_descr_get != PyFrame_Type.tp_descr_get || PyFrame_Type.tp_descr_get == NULL);
 
     assert(Nuitka_Frame_Type.tp_descr_set != PyFrame_Type.tp_descr_set || PyFrame_Type.tp_descr_set == NULL);
     assert(Nuitka_Frame_Type.tp_dictoffset != PyFrame_Type.tp_dictoffset || PyFrame_Type.tp_dictoffset == 0);
     // TODO: These get changed and into the same thing, not sure what to compare against, project something
+    // assert(Nuitka_Frame_Type.tp_dict != PyFrame_Type.tp_dict);
     // assert(Nuitka_Frame_Type.tp_init != PyFrame_Type.tp_init || PyFrame_Type.tp_init == NULL);
     // assert(Nuitka_Frame_Type.tp_alloc != PyFrame_Type.tp_alloc || PyFrame_Type.tp_alloc == NULL);
     // assert(Nuitka_Frame_Type.tp_new != PyFrame_Type.tp_new || PyFrame_Type.tp_new == NULL);
     // assert(Nuitka_Frame_Type.tp_free != PyFrame_Type.tp_free || PyFrame_Type.tp_free == NULL);
+    // assert(Nuitka_Frame_Type.tp_weaklist != PyFrame_Type.tp_weaklist);
     assert(Nuitka_Frame_Type.tp_bases != PyFrame_Type.tp_bases);
     assert(Nuitka_Frame_Type.tp_mro != PyFrame_Type.tp_mro);
     assert(Nuitka_Frame_Type.tp_cache != PyFrame_Type.tp_cache || PyFrame_Type.tp_cache == NULL);
     assert(Nuitka_Frame_Type.tp_subclasses != PyFrame_Type.tp_subclasses || PyFrame_Type.tp_cache == NULL);
-    assert(Nuitka_Frame_Type.tp_weaklist != PyFrame_Type.tp_weaklist);
     assert(Nuitka_Frame_Type.tp_del != PyFrame_Type.tp_del || PyFrame_Type.tp_del == NULL);
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     assert(Nuitka_Frame_Type.tp_finalize != PyFrame_Type.tp_finalize || PyFrame_Type.tp_finalize == NULL);
 #endif
     Nuitka_PyType_Ready(&Nuitka_Frame_Type, &PyFrame_Type, true, true, false, false, false);
@@ -674,7 +741,12 @@ static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObj
     _PyInterpreterFrame *locals_owner = &result->m_interpreter_frame;
 #endif
 
+#if PYTHON_VERSION < 0x3d0
     locals_owner->f_code = code;
+#else
+    // TODO: Why is our code object not just immortal.
+    locals_owner->f_executable = (PyObject *)code;
+#endif
 
     frame->f_trace = Py_None;
 
@@ -708,12 +780,12 @@ static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObj
 
 #if PYTHON_VERSION < 0x3b0
     frame->f_lasti = -1;
-    frame->f_iblock = 0;
+    frame->f_iblock = 0; // spell-checker: ignore iblock
 #endif
 
     frame->f_lineno = code->co_firstlineno;
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     Nuitka_SetFrameGenerator(result, NULL);
 
     Nuitka_Frame_MarkAsNotExecuting(result);
@@ -721,9 +793,18 @@ static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObj
 
 #if PYTHON_VERSION >= 0x3b0
     result->m_interpreter_frame.frame_obj = &result->m_frame;
-    result->m_interpreter_frame.owner = 0;
+    result->m_interpreter_frame.owner = FRAME_OWNED_BY_GENERATOR;
+#if PYTHON_VERSION >= 0x3c0
+    result->m_interpreter_frame.f_funcobj = NULL; // spell-checker: ignore funcobj
+#else
+    result->m_interpreter_frame.f_func = NULL;
+#endif
+#if PYTHON_VERSION < 0x3d0
     result->m_interpreter_frame.prev_instr = _PyCode_CODE(code);
+#endif
     result->m_frame.f_frame = &result->m_interpreter_frame;
+
+    assert(!_PyFrame_IsIncomplete(&result->m_interpreter_frame));
 #endif
 
     Nuitka_GC_Track(result);
@@ -769,7 +850,7 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
 #if PYTHON_VERSION >= 0x3b0
                              PyObject *function_qualname,
 #endif
-                             PyObject *argnames, PyObject *freevars, int arg_count
+                             PyObject *arg_names, PyObject *free_vars, int arg_count
 #if PYTHON_VERSION >= 0x300
                              ,
                              int kw_only_count
@@ -780,21 +861,35 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
 #endif
 ) {
     CHECK_OBJECT(filename);
-    assert(Nuitka_String_CheckExact(filename));
+    assert(Nuitka_StringOrUnicode_CheckExact(filename));
     CHECK_OBJECT(function_name);
     assert(Nuitka_String_CheckExact(function_name));
 
-    if (argnames == NULL) {
-        argnames = const_tuple_empty;
+#if PYTHON_VERSION < 0x300
+    PyObject *filename_str = NULL;
+
+    // TODO: Memory leak of filename, it might be intended transferred to the
+    // code object by using code.
+    if (PyUnicode_CheckExact(filename)) {
+        filename_str = PyUnicode_AsUTF8String(filename);
+        filename = filename_str;
+    } else {
+        filename_str = filename;
+        Py_INCREF(filename);
+    }
+#endif
+
+    if (arg_names == NULL || arg_names == Py_None) {
+        arg_names = const_tuple_empty;
     }
-    CHECK_OBJECT(argnames);
-    assert(PyTuple_Check(argnames));
+    CHECK_OBJECT(arg_names);
+    assert(PyTuple_Check(arg_names));
 
-    if (freevars == NULL) {
-        freevars = const_tuple_empty;
+    if (free_vars == NULL || free_vars == Py_None) {
+        free_vars = const_tuple_empty;
     }
-    CHECK_OBJECT(freevars);
-    assert(PyTuple_Check(freevars));
+    CHECK_OBJECT(free_vars);
+    assert(PyTuple_Check(free_vars));
 
     // The PyCode_New has funny code that interns, mutating the tuple that owns
     // it. Really serious non-immutable shit. We have triggered that changes
@@ -803,36 +898,76 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
     // TODO: Reactivate once code object creation becomes un-streaming driven
     // and we can pass the extra args with no worries.
 
-    // Py_hash_t hash = DEEP_HASH(argnames);
+    // Py_hash_t hash = DEEP_HASH(arg_names);
 #endif
 
+    // spell-checker: ignore lnotab
 #if PYTHON_VERSION < 0x300
     PyObject *code = const_str_empty;
     PyObject *lnotab = const_str_empty;
-#else
-#if PYTHON_VERSION < 0x3b0
+    PyObject *consts = const_tuple_empty;
+    PyObject *names = const_tuple_empty;
+    int stacksize = 0;
+#elif PYTHON_VERSION < 0x3b0
     PyObject *code = const_bytes_empty;
     PyObject *lnotab = const_bytes_empty;
+    PyObject *consts = const_tuple_empty;
+    PyObject *names = const_tuple_empty;
+    int stacksize = 0;
 #else
     // Our code object needs to be recognizable, and Python doesn't store the
     // length anymore, so we need a non-empty one.
     static PyObject *empty_code = NULL;
+    static PyObject *lnotab = NULL;
+    static PyObject *consts = NULL;
+    static PyObject *names = NULL;
+    // TODO: Seems removable.
+    static PyObject *exception_table = NULL;
+    static int stacksize = 0;
+
     if (empty_code == NULL) {
-        empty_code = PyBytes_FromString("\0\0");
+        // Only needed once here.
+        PyThreadState *tstate = PyThreadState_GET();
+
+        PyObject *empty_code_module_object = Py_CompileString(
+            "def empty(): raise RuntimeError('Compiled function bytecode used')", "<exec>", Py_file_input);
+        NUITKA_MAY_BE_UNUSED PyObject *module =
+            PyImport_ExecCodeModule("nuitka_empty_function", empty_code_module_object);
+        CHECK_OBJECT(module);
+
+        PyObject *empty_function = PyObject_GetAttrString(module, "empty");
+        CHECK_OBJECT(empty_function);
+        PyObject *empty_code_object = PyObject_GetAttrString(empty_function, "__code__");
+        CHECK_OBJECT(empty_code_object);
+
+        NUITKA_MAY_BE_UNUSED bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_empty_function");
+        assert(bool_res != false);
+
+        empty_code = PyObject_GetAttrString(empty_code_object, "co_code");
+        CHECK_OBJECT(empty_code);
+        lnotab = PyObject_GetAttrString(empty_code_object, "co_lnotab");
+        CHECK_OBJECT(lnotab);
+        consts = PyObject_GetAttrString(empty_code_object, "co_consts");
+        CHECK_OBJECT(consts);
+        names = PyObject_GetAttrString(empty_code_object, "co_names");
+        CHECK_OBJECT(names);
+        exception_table = PyObject_GetAttrString(empty_code_object, "co_exceptiontable");
+        CHECK_OBJECT(exception_table);
+
+        stacksize = (int)PyLong_AsLong(PyObject_GetAttrString(empty_code_object, "co_stacksize"));
     }
+
     PyObject *code = empty_code;
-    static PyObject *lnotab = NULL;
-    if (lnotab == NULL) {
-        lnotab = PyBytes_FromStringAndSize("\x80\x00\xd8\x04\x08\x80"
-                                           "D",
-                                           7);
-    }
-#endif
+    CHECK_OBJECT(empty_code);
+    CHECK_OBJECT(lnotab);
+    CHECK_OBJECT(consts);
+    CHECK_OBJECT(names);
+    CHECK_OBJECT(exception_table);
 #endif
 
     // For Python 3.11 this value is checked, even if not used.
-#if PYTHON_VERSION >= 0x3B0
-    int nlocals = (int)PyTuple_GET_SIZE(argnames);
+#if PYTHON_VERSION >= 0x3b0
+    int nlocals = (int)PyTuple_GET_SIZE(arg_names);
 #else
     int nlocals = 0;
 #endif
@@ -841,50 +976,52 @@ PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *
     // and is not available for Python2.
 
 #if PYTHON_VERSION >= 0x380
-    PyCodeObject *result = PyCode_NewWithPosOnlyArgs(arg_count, // argcount
+    PyCodeObject *result = PyCode_NewWithPosOnlyArgs(arg_count, // arg_count
 #else
-    PyCodeObject *result = PyCode_New(arg_count, // argcount
+    PyCodeObject *result = PyCode_New(arg_count, // arg_count
 #endif
 
 #if PYTHON_VERSION >= 0x300
 #if PYTHON_VERSION >= 0x380
-                                                     pos_only_count, // kw-only count
+                                                     pos_only_count, // pos-only count
 #endif
                                                      kw_only_count, // kw-only count
 #endif
                                                      nlocals,           // nlocals
-                                                     0,                 // stacksize
+                                                     stacksize,         // stacksize
                                                      flags,             // flags
                                                      code,              // code (bytecode)
-                                                     const_tuple_empty, // consts (we are not going to be compatible)
-                                                     const_tuple_empty, // names (we are not going to be compatible)
-                                                     argnames,          // varnames (we are not going to be compatible)
-                                                     freevars,          // freevars
-                                                     const_tuple_empty, // cellvars (we are not going to be compatible)
+                                                     consts,            // consts (we are not going to be compatible)
+                                                     names,             // names (we are not going to be compatible)
+                                                     arg_names,         // var_names (we are not going to be compatible)
+                                                     free_vars,         // free_vars
+                                                     const_tuple_empty, // cell_vars (we are not going to be compatible)
                                                      filename,          // filename
                                                      function_name,     // name
 #if PYTHON_VERSION >= 0x3b0
                                                      function_qualname, // qualname
 #endif
-                                                     line,  // firstlineno (offset of the code object)
+                                                     line,  // first_lineno (offset of the code object)
                                                      lnotab // lnotab (table to translate code object)
 #if PYTHON_VERSION >= 0x3b0
                                                      ,
-                                                     const_bytes_empty // exceptiontable
+                                                     exception_table // exception_table
 #endif
     );
 
-    // assert(DEEP_HASH(tstate, argnames) == hash);
+    // assert(DEEP_HASH(tstate, arg_names) == hash);
 
-    if (result == NULL) {
-        PyErr_PrintEx(0);
-    }
+#if PYTHON_VERSION < 0x300
+    Py_DECREF(filename_str);
+#endif
 
-    CHECK_OBJECT(result);
     return result;
 }
 
 void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char const *type_description, ...) {
+    assert(Nuitka_Frame_CheckExact((PyObject *)frame_object));
+    CHECK_OBJECT((PyObject *)frame_object);
+    assert(_PyObject_GC_IS_TRACKED(frame_object));
     assertFrameObject(frame_object);
 
 #if _DEBUG_FRAME
@@ -939,6 +1076,11 @@ void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char con
             CHECK_OBJECT_X(value->ob_ref);
 
             memcpy(t, &value, sizeof(struct Nuitka_CellObject *));
+            // TODO: Reference count must become wrong here, should
+            // be forced to one probably, or we should simply not
+            // store cells, but their values. Take a ref off "value"
+            // is probably not needed.
+            // Py_SET_REFCNT((struct Nuitka_CellObject *)t, 1);
             Py_INCREF(value);
 
             t += sizeof(struct Nuitka_CellObject *);
@@ -975,10 +1117,8 @@ void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char con
 void dumpFrameStack(void) {
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *saved_exception_type, *saved_exception_value;
-    PyTracebackObject *saved_exception_tb;
-
-    FETCH_ERROR_OCCURRED(&saved_exception_type, &saved_exception_value, &saved_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 
     int total = 0;
 
@@ -1014,7 +1154,7 @@ void dumpFrameStack(void) {
             current_repr = const_str_empty;
             Py_INCREF(const_str_empty);
         }
-        PyObject *code_repr = PyObject_Str((PyObject *)current->current_frame->f_code);
+        PyObject *code_repr = PyObject_Str((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(current->current_frame));
 #endif
 
         PRINT_FORMAT("Frame stack %d: %s %d %s\n", total--, Nuitka_String_AsString(current_repr), Py_REFCNT(current),
@@ -1032,7 +1172,7 @@ void dumpFrameStack(void) {
 
     PRINT_STRING(">---------<\n");
 
-    RESTORE_ERROR_OCCURRED(tstate, saved_exception_type, saved_exception_value, saved_exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
 }
 
 static void PRINT_UNCOMPILED_FRAME(char const *prefix, PyFrameObject *frame) {
@@ -1070,7 +1210,7 @@ void PRINT_INTERPRETER_FRAME(char const *prefix, Nuitka_ThreadStateFrameType *fr
     if (frame) {
         PRINT_FORMAT("0x%lx ", frame);
 
-        PyObject *code_object_str = PyObject_Repr((PyObject *)frame->f_code);
+        PyObject *code_object_str = PyObject_Repr((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(frame));
         PRINT_ITEM(code_object_str);
         Py_DECREF(code_object_str);
     } else {
@@ -1087,8 +1227,22 @@ void PRINT_TOP_FRAME(char const *prefix) {
 #if PYTHON_VERSION < 0x3b0
     PRINT_UNCOMPILED_FRAME(prefix, tstate->frame);
 #else
-    PRINT_INTERPRETER_FRAME(prefix, tstate->cframe->current_frame);
+    PRINT_INTERPRETER_FRAME(prefix, CURRENT_TSTATE_INTERPRETER_FRAME(tstate));
 #endif
 }
 
-#endif
+#endif
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.