Nuitka-winsvc 2.4.11__cp311-cp311-win_amd64.whl → 2.5.6__cp311-cp311-win_amd64.whl

nuitka/code_generation/VariableCodes.py

@@ -72,7 +72,7 @@ def generateAssignmentVariableCode(statement, emit, context):
     )
 
     # Ownership of that reference must have been transferred.
-    assert not context.needsCleanup(tmp_name)
+    assert not context.needsCleanup(tmp_name), (statement.source_ref, tmp_name)
 
 
 def generateDelVariableCode(statement, emit, context):
@@ -89,46 +89,77 @@ def generateDelVariableCode(statement, emit, context):
         )
 
 
-def getVariableReferenceCode(
-    to_name, variable, variable_trace, needs_check, conversion_check, emit, context
+def getModuleVariableAccessorCodeName(module_identifier, variable_name):
+    # For non-ascii names use encoding.
+    if str is not bytes:
+        variable_name = variable_name.encode("ascii", "c_identifier").decode()
+
+    return "module_var_accessor_%s_$$_%s" % (module_identifier, variable_name)
+
+
+def getModuleVariableReferenceCode(
+    to_name, variable_name, use_caching, needs_check, conversion_check, emit, context
 ):
-    if variable.isModuleVariable():
-        owner = context.getOwner()
+    owner = context.getOwner()
+
+    context.setModuleVariableAccessorCaching(variable_name, use_caching)
+
+    with withObjectCodeTemporaryAssignment2(
+        to_name, "mvar_value", conversion_check, emit, context
+    ) as value_name:
+        emit(
+            "%(value_name)s = %(module_variable_accessor)s(tstate);"
+            % {
+                "value_name": value_name,
+                "module_variable_accessor": getModuleVariableAccessorCodeName(
+                    context.getModuleCodeName(), variable_name
+                ),
+            }
+        )
 
-        with withObjectCodeTemporaryAssignment2(
-            to_name, "mvar_value", conversion_check, emit, context
-        ) as value_name:
-            # TODO: Rather have this passed from a distinct node type, so inlining
-            # doesn't change things.
+        if needs_check:
+            if (
+                python_version < 0x300
+                and not owner.isCompiledPythonModule()
+                and not owner.isExpressionClassBodyBase()
+            ):
+                error_helper_name = "RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR"
+            else:
+                error_helper_name = "RAISE_CURRENT_EXCEPTION_NAME_ERROR"
+
+            (
+                exception_state_name,
+                _exception_lineno,
+            ) = context.variable_storage.getExceptionVariableDescriptions()
 
             emit(
                 """\
-%(value_name)s = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
-
 if (unlikely(%(value_name)s == NULL)) {
-    %(value_name)s = %(helper_code)s(tstate, %(var_name)s);
+    %(error_helper_name)s(tstate, &%(exception_state_name)s, %(var_name)s);
 }
 """
                 % {
-                    "helper_code": (
-                        "GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION"
-                        if python_version < 0x340
-                        and not owner.isCompiledPythonModule()
-                        and not owner.isExpressionClassBodyBase()
-                        else "GET_MODULE_VARIABLE_VALUE_FALLBACK"
-                    ),
-                    "module_identifier": context.getModuleCodeName(),
                     "value_name": value_name,
-                    "var_name": context.getConstantCode(constant=variable.getName()),
+                    "error_helper_name": error_helper_name,
+                    "var_name": context.getConstantCode(constant=variable_name),
+                    "exception_state_name": exception_state_name,
                 }
             )
 
-            getErrorExitCode(
-                check_name=value_name,
-                emit=emit,
-                context=context,
-                needs_check=needs_check,
-            )
+        getErrorExitCode(
+            check_name=value_name,
+            emit=emit,
+            context=context,
+            fetched_exception=True,
+            needs_check=needs_check,
+        )
+
+
+def getNonModuleVariableReferenceCode(
+    to_name, variable, variable_trace, needs_check, conversion_check, emit, context
+):
+    if variable.isModuleVariable():
+        assert False
     else:
         variable_declaration = getLocalVariableDeclaration(
             context, variable, variable_trace
@@ -166,15 +197,44 @@ def generateVariableReferenceCode(to_name, expression, emit, context):
 
     needs_check = expression.mayRaiseException(BaseException)
 
-    getVariableReferenceCode(
-        to_name=to_name,
-        variable=variable,
-        variable_trace=variable_trace,
-        needs_check=needs_check,
-        conversion_check=decideConversionCheckNeeded(to_name, expression),
-        emit=emit,
-        context=context,
-    )
+    if variable.isModuleVariable():
+        user = context.getOwner()
+        variable_name = variable.getName()
+
+        if python_version < 0x360:
+            # Python2 doesn't have the means to do it, we got some acceleration
+            # for it still, but no real caching.
+            use_caching = False
+        elif user.isCompiledPythonModule():
+            # For module level code, cache module variable access only if inside
+            # a loop.
+            use_caching = False
+
+            if not context.isModuleVariableAccessorCaching(variable_name):
+                if expression.getContainingLoopNode() is not None:
+                    use_caching = True
+        else:
+            use_caching = True
+
+        getModuleVariableReferenceCode(
+            to_name=to_name,
+            variable_name=variable_name,
+            use_caching=use_caching,
+            needs_check=needs_check,
+            conversion_check=decideConversionCheckNeeded(to_name, expression),
+            emit=emit,
+            context=context,
+        )
+    else:
+        getNonModuleVariableReferenceCode(
+            to_name=to_name,
+            variable=variable,
+            variable_trace=variable_trace,
+            needs_check=needs_check,
+            conversion_check=decideConversionCheckNeeded(to_name, expression),
+            emit=emit,
+            context=context,
+        )
 
 
 def _getVariableCodeName(in_context, variable):
@@ -358,8 +418,7 @@ def getVariableAssignmentCode(
         context=context,
     )
 
-    if ref_count:
-        context.removeCleanupTempName(tmp_name)
+    # print(variable_declaration.getCType())
 
 
 def _getVariableDelCode(
@@ -442,7 +501,7 @@ def generateVariableReleaseCode(statement, emit, context):
 
     c_type.getReleaseCode(value_name=value_name, needs_check=needs_check, emit=emit)
 
-    c_type.emitReinitCode(value_name=value_name, emit=emit)
+    c_type.emitReInitCode(value_name=value_name, emit=emit)
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/code_generation/VariableDeclarations.py

@@ -135,7 +135,7 @@ class VariableStorage(object):
         "variable_declarations_main",
         "variable_declarations_closure",
         "variable_declarations_locals",
-        "exception_variable_declarations",
+        "exception_variable_name",
     )
 
     def __init__(self, heap_name):
@@ -147,7 +147,7 @@ class VariableStorage(object):
 
         self.variable_declarations_locals = []
 
-        self.exception_variable_declarations = None
+        self.exception_variable_name = None
 
     @contextmanager
     def withLocalStorage(self):
@@ -197,19 +197,19 @@ class VariableStorage(object):
         ]
 
     def getExceptionVariableDescriptions(self):
-        if self.exception_variable_declarations is None:
-            self.exception_variable_declarations = (
-                self.addVariableDeclarationTop("PyObject *", "exception_type", "NULL"),
-                self.addVariableDeclarationTop("PyObject *", "exception_value", "NULL"),
+        if self.exception_variable_name is None:
+            self.exception_variable_name = (
                 self.addVariableDeclarationTop(
-                    "PyTracebackObject *", "exception_tb", "NULL"
+                    "struct Nuitka_ExceptionPreservationItem",
+                    "exception_state",
+                    "Empty_Nuitka_ExceptionPreservationItem",
                 ),
                 self.addVariableDeclarationTop(
                     "NUITKA_MAY_BE_UNUSED int", "exception_lineno", "0"
                 ),
             )
 
-        return self.exception_variable_declarations
+        return self.exception_variable_name
 
     def addVariableDeclarationLocal(self, c_type, code_name):
         result = VariableDeclaration(c_type, code_name, None, None)

nuitka/code_generation/YieldCodes.py

@@ -3,7 +3,7 @@
 
 """ Yield related codes.
 
-The normal "yield", and the Python 3.3 or higher "yield from" variant.
+The normal "yield", and the Python 3 "yield from" variant.
 """
 
 from .CodeHelpers import (

nuitka/code_generation/c_types/CTypeBases.py

@@ -91,6 +91,10 @@ class CTypeBase(object):
         # Need to overload this for each type it is used for, pylint: disable=unused-argument
         assert False, to_name
 
+    @classmethod
+    def hasReleaseCode(cls):
+        return False
+
     @classmethod
     def getReleaseCode(cls, value_name, needs_check, emit):
         """Get release code for given object."""
@@ -98,7 +102,7 @@ class CTypeBase(object):
         assert False, cls.c_type
 
     @classmethod
-    def emitReinitCode(cls, value_name, emit):
+    def emitReInitCode(cls, value_name, emit):
         """Get release code for given object."""
         # Need to overload this for each type it is used for, pylint: disable=unused-argument
         assert False, cls.c_type
@@ -108,7 +112,7 @@ class CTypeBase(object):
         """Take reference code for given object."""
 
         # Need to overload this for each type it is used for, pylint: disable=unused-argument
-        assert False, cls.c_type
+        assert False, (value_name, cls.c_type)
 
     @classmethod
     def emitTruthCheckCode(cls, to_name, value_name, emit):
@@ -134,6 +138,10 @@ class CTypeBase(object):
         # Need to overload this for each type it is used for, pylint: disable=unused-argument
         assert False, cls.c_type
 
+    @classmethod
+    def isDualType(cls):
+        return False
+
 
 class CTypeNotReferenceCountedMixin(object):
     """Mixin for C types, that have no reference counting mechanism."""

nuitka/code_generation/c_types/CTypeModuleDictVariables.py

@@ -52,6 +52,9 @@ if (%(orig_name)s != %(tmp_name)s) {
                 )
             )
 
+            if ref_count:
+                context.removeCleanupTempName(tmp_name)
+
     @classmethod
     def emitValueAccessCode(cls, value_name, emit, context):
         tmp_name = context.allocateTempName("mvar_value")

nuitka/code_generation/c_types/CTypeNuitkaBooleans.py

@@ -33,9 +33,8 @@ class CTypeNuitkaBoolEnum(CTypeNotReferenceCountedMixin, CTypeBase):
                 to_name=value_name, condition=test_code, emit=emit
             )
 
-            # TODO: Refcount and context needs release are redundant.
-            if ref_count:
-                getReleaseCode(tmp_name, emit, context)
+        if ref_count:
+            getReleaseCode(tmp_name, emit, context)
 
     @classmethod
     def emitAssignmentCodeToNuitkaIntOrLong(
@@ -94,7 +93,7 @@ class CTypeNuitkaBoolEnum(CTypeNotReferenceCountedMixin, CTypeBase):
         return "%s %s NUITKA_BOOL_UNASSIGNED" % (value_name, "==" if inverted else "!=")
 
     @classmethod
-    def emitReinitCode(cls, value_name, emit):
+    def emitReInitCode(cls, value_name, emit):
         emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
 
     @classmethod

nuitka/code_generation/c_types/CTypeNuitkaInts.py

@@ -10,6 +10,7 @@ from nuitka.code_generation.templates.CodeTemplatesVariables import (
     template_release_object_unclear,
 )
 
+from ..ErrorCodes import getTakeReferenceCode
 from .CTypeBases import CTypeBase
 
 
@@ -18,42 +19,45 @@ class CTypeNuitkaIntOrLongStruct(CTypeBase):
 
     helper_code = "NILONG"
 
+    @classmethod
+    def isDualType(cls):
+        return True
+
     @classmethod
     def emitVariableAssignCode(
         cls, value_name, needs_release, tmp_name, ref_count, inplace, emit, context
     ):
-        assert not inplace
+        if not ref_count:
+            getTakeReferenceCode(tmp_name, emit)
 
         if tmp_name.c_type == "nuitka_ilong":
             emit("%s = %s;" % (value_name, tmp_name))
-
-            if ref_count:
-                emit("/* REFCOUNT ? */")
-
         else:
             if tmp_name.c_type == "PyObject *":
-                emit("%s.validity = NUITKA_ILONG_OBJECT_VALID;" % value_name)
-                emit("%s.ilong_object = %s;" % (value_name, tmp_name))
-
-                if ref_count:
-                    emit("/* REFCOUNT ? */")
+                emit("SET_NILONG_OBJECT_VALUE(&%s, %s);" % (value_name, tmp_name))
             else:
                 assert False, repr(tmp_name)
 
+        if ref_count:
+            context.removeCleanupTempName(tmp_name)
+
     @classmethod
-    def emitVariantAssignmentCode(cls, int_name, value_name, int_value, emit, context):
-        # needs no context, pylint: disable=unused-argument
-        if value_name is None:
+    def emitVariantAssignmentCode(
+        cls, to_name, ilong_value_name, int_value, emit, context
+    ):
+        if ilong_value_name is None:
             assert int_value is not None
             assert False  # TODO
         else:
             if int_value is None:
-                emit("%s.validity = NUITKA_ILONG_OBJECT_VALID;" % int_name)
-                emit("%s.ilong_object = %s;" % (int_name, value_name))
+                emit("SET_NILONG_OBJECT_VALUE(&%s, %s);" % (to_name, ilong_value_name))
             else:
-                emit("%s.validity = NUITKA_ILONG_BOTH_VALID;" % int_name)
-                emit("%s.ilong_object = %s;" % (int_name, value_name))
-                emit("%s.ilong_value = %s;" % (int_name, int_value))
+                emit(
+                    "SET_NILONG_OBJECT_AND_C_VALUE(&%s, %s, %s );"
+                    % (to_name, ilong_value_name, int_value)
+                )
+
+            context.transferCleanupTempName(ilong_value_name, to_name)
 
     @classmethod
     def getTruthCheckCode(cls, value_name):
@@ -97,6 +101,10 @@ class CTypeNuitkaIntOrLongStruct(CTypeBase):
             "==" if inverted else "!=",
         )
 
+    @classmethod
+    def hasReleaseCode(cls):
+        return True
+
     @classmethod
     def getReleaseCode(cls, value_name, needs_check, emit):
         emit(
@@ -111,7 +119,7 @@ class CTypeNuitkaIntOrLongStruct(CTypeBase):
         else:
             template = template_release_object_clear
 
-        emit(template % {"identifier": "%s.ilong_object" % value_name})
+        emit(template % {"identifier": "%s.python_value" % value_name})
 
         emit("}")
 
@@ -119,15 +127,16 @@ class CTypeNuitkaIntOrLongStruct(CTypeBase):
     def getDeleteObjectCode(
         cls, to_name, value_name, needs_check, tolerant, emit, context
     ):
-        assert False, "TODO"
-
         if not needs_check:
-            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+            emit("RELEASE_NILONG_VALUE(&%s);" % value_name)
         elif tolerant:
-            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+            emit("RELEASE_NILONG_VALUE(&%s);" % value_name)
         else:
-            emit("%s = %s == NUITKA_BOOL_UNASSIGNED;" % (to_name, value_name))
-            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+            # TODO: That doesn't seem right, maybe this function makes no sense
+            # after all, and should be one for checking, and one for releasing
+            # instead.
+            emit("%s = %s.validity == NUITKA_ILONG_UNASSIGNED" % (to_name, value_name))
+            emit("RELEASE_NILONG_VALUE(&%s);" % value_name)
 
     @classmethod
     def emitAssignmentCodeFromBoolCondition(cls, to_name, condition, emit):
@@ -138,6 +147,42 @@ class CTypeNuitkaIntOrLongStruct(CTypeBase):
             % {"to_name": to_name, "condition": condition}
         )
 
+    @classmethod
+    def emitAssignmentCodeFromConstant(
+        cls, to_name, constant, may_escape, emit, context
+    ):
+        # No escaping matters with integer values, as they are immutable
+        # the do not have to make copies of the prepared values.
+        # pylint: disable=unused-argument
+
+        assert type(constant) is int, repr(constant)
+
+        cls.emitVariantAssignmentCode(
+            to_name=to_name,
+            ilong_value_name=context.getConstantCode(constant=constant),
+            int_value=constant,
+            emit=emit,
+            context=context,
+        )
+
+    @classmethod
+    def getTakeReferenceCode(cls, value_name, emit):
+        """Take reference code for given object."""
+
+        emit("INCREF_NILONG_VALUE(&%s);" % value_name)
+
+    @classmethod
+    def emitReInitCode(cls, value_name, emit):
+        emit("%s.validity = NUITKA_ILONG_UNASSIGNED;" % value_name)
+
+    @classmethod
+    def hasErrorIndicator(cls):
+        return True
+
+    @classmethod
+    def getExceptionCheckCondition(cls, value_name):
+        return "%s == NUITKA_ILONG_EXCEPTION" % value_name
+
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.

nuitka/code_generation/c_types/CTypeNuitkaVoids.py

@@ -32,7 +32,7 @@ class CTypeNuitkaVoidEnum(CTypeNotReferenceCountedMixin, CTypeBase):
         emit("assert(%s == NUITKA_VOID_OK);" % value_name)
 
     @classmethod
-    def emitReinitCode(cls, value_name, emit):
+    def emitReInitCode(cls, value_name, emit):
         emit("%s = NUITKA_VOID_OK;" % value_name)
 
     @classmethod

nuitka/code_generation/c_types/CTypePyObjectPointers.py

@@ -67,6 +67,9 @@ class CPythonPyObjectPtrBase(CTypeBase):
                 else:
                     template = template_write_local_unclear_ref1
 
+            if ref_count:
+                context.removeCleanupTempName(tmp_name)
+
         emit(template % {"identifier": value_name, "tmp_name": tmp_name})
 
     @classmethod
@@ -76,8 +79,8 @@ class CPythonPyObjectPtrBase(CTypeBase):
         to_type = to_name.getCType()
 
         to_type.emitVariantAssignmentCode(
-            int_name=to_name,
-            value_name=value_name,
+            to_name=to_name,
+            ilong_value_name=value_name,
             int_value=None,
             emit=emit,
             context=context,
@@ -93,6 +96,10 @@ class CPythonPyObjectPtrBase(CTypeBase):
 
         emit("%s = CHECK_IF_TRUE(%s);" % (to_name, value_name))
 
+    @classmethod
+    def hasReleaseCode(cls):
+        return True
+
     @classmethod
     def getReleaseCode(cls, value_name, needs_check, emit):
         if needs_check:
@@ -318,7 +325,7 @@ class CTypePyObjectPtr(CPythonPyObjectPtrBase):
         return "%s %s NULL" % (value_name, "==" if inverted else "!=")
 
     @classmethod
-    def emitReinitCode(cls, value_name, emit):
+    def emitReInitCode(cls, value_name, emit):
         emit("%s = NULL;" % value_name)
 
     @classmethod
@@ -376,9 +383,9 @@ class CTypePyObjectPtr(CPythonPyObjectPtrBase):
                 emit=emit,
             )
         elif value_name.c_type == "nuitka_ilong":
-            emit("ENFORCE_ILONG_OBJECT_VALUE(&%s);" % value_name)
+            emit("ENFORCE_NILONG_OBJECT_VALUE(&%s);" % value_name)
 
-            emit("%s = %s.ilong_object;" % (to_name, value_name))
+            emit("%s = %s.python_value;" % (to_name, value_name))
 
             context.transferCleanupTempName(value_name, to_name)
         else:
@@ -477,6 +484,9 @@ class CTypeCellObject(CTypeBase):
                     template = template_write_shared_clear_ref0
                 else:
                     template = template_write_shared_unclear_ref0
+
+                if ref_count:
+                    context.removeCleanupTempName(tmp_name)
             else:
                 if needs_release is False:
                     template = template_write_shared_clear_ref1
@@ -534,7 +544,7 @@ class CTypeCellObject(CTypeBase):
         emit(template % {"identifier": value_name})
 
     @classmethod
-    def emitReinitCode(cls, value_name, emit):
+    def emitReInitCode(cls, value_name, emit):
         emit("%s = NULL;" % value_name)
 
     @classmethod

nuitka/code_generation/templates/CodeTemplatesAsyncgens.py

@@ -67,8 +67,8 @@ template_asyncgen_exception_exit = """\
 
     function_exception_exit:
 %(function_cleanup)s
-    assert(%(exception_type)s);
-    RESTORE_ERROR_OCCURRED(tstate, %(exception_type)s, %(exception_value)s, %(exception_tb)s);
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
     return NULL;
 """
 

nuitka/code_generation/templates/CodeTemplatesConstants.py

@@ -134,6 +134,7 @@ static void _createGlobalConstants(PyThreadState *tstate) {
         {(char *)"no_annotations", (char *)"boolean indicating --python-flag=no_annotations usage"},
         {(char *)"module", (char *)"boolean indicating --module usage"},
         {(char *)"main", (char *)"name of main module at runtime"},
+        {(char *)"original_argv0", (char *)"original argv[0] as received by the onefile binary, None otherwise"},
         {0}
     };
 
@@ -149,9 +150,9 @@ static void _createGlobalConstants(PyThreadState *tstate) {
     Nuitka_dunder_compiled_value = PyStructSequence_New(&Nuitka_VersionInfoType);
     assert(Nuitka_dunder_compiled_value != NULL);
 
-    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 0, PyInt_FromLong(%(nuitka_version_major)s));
-    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 1, PyInt_FromLong(%(nuitka_version_minor)s));
-    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 2, PyInt_FromLong(%(nuitka_version_micro)s));
+    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 0, Nuitka_PyInt_FromLong(%(nuitka_version_major)s));
+    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 1, Nuitka_PyInt_FromLong(%(nuitka_version_minor)s));
+    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 2, Nuitka_PyInt_FromLong(%(nuitka_version_micro)s));
 
     PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 3, Nuitka_String_FromString("%(nuitka_version_level)s"));
 
@@ -234,6 +235,13 @@ static void _createGlobalConstants(PyThreadState *tstate) {
 #endif
     PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 12, main_name);
 
+#if defined(_NUITKA_EXE)
+    PyObject *original_argv0 = getOriginalArgv0Object();
+#else
+    PyObject *original_argv0 = Py_None;
+# endif
+    PyStructSequence_SET_ITEM(Nuitka_dunder_compiled_value, 13, original_argv0);
+
     // Prevent users from creating the Nuitka version type object.
     Nuitka_VersionInfoType.tp_init = NULL;
     Nuitka_VersionInfoType.tp_new = NULL;

nuitka/code_generation/templates/CodeTemplatesCoroutines.py

@@ -68,8 +68,8 @@ template_coroutine_exception_exit = """\
 
     function_exception_exit:
 %(function_cleanup)s
-    assert(%(exception_type)s);
-    RESTORE_ERROR_OCCURRED(tstate, %(exception_type)s, %(exception_value)s, %(exception_tb)s);
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
     return NULL;
 """
 

nuitka/code_generation/templates/CodeTemplatesExceptions.py

@@ -6,27 +6,26 @@
 """
 
 template_publish_exception_to_handler = """\
-if (%(keeper_tb)s == NULL) {
-    %(keeper_tb)s = %(tb_making)s;
-} else if (%(keeper_lineno)s != 0) {
-    %(keeper_tb)s = ADD_TRACEBACK(%(keeper_tb)s, %(frame_identifier)s, %(keeper_lineno)s);
+{
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&%(keeper_exception_state_name)s);
+    if (exception_tb == NULL) {
+        exception_tb = %(tb_making)s;
+        SET_EXCEPTION_STATE_TRACEBACK(&%(keeper_exception_state_name)s, exception_tb);
+    } else if (%(keeper_lineno)s != 0) {
+        exception_tb = ADD_TRACEBACK(exception_tb, %(frame_identifier)s, %(keeper_lineno)s);
+        SET_EXCEPTION_STATE_TRACEBACK(&%(keeper_exception_state_name)s, exception_tb);
+    }
 }
 """
 
-template_error_catch_quick_exception = """\
+template_error_catch_fetched_exception = """\
 if (%(condition)s) {
-    if (!HAS_ERROR_OCCURRED(tstate)) {
-        %(exception_type)s = %(quick_exception)s;
-        Py_INCREF(%(exception_type)s);
-        %(exception_value)s = NULL;
-        %(exception_tb)s = NULL;
-    } else {
-        FETCH_ERROR_OCCURRED(tstate, &%(exception_type)s, &%(exception_value)s, &%(exception_tb)s);
-    }
+    assert(HAS_EXCEPTION_STATE(&%(exception_state_name)s));
+
 %(release_temps)s
 
-%(var_description_code)s
 %(line_number_code)s
+%(var_description_code)s
     goto %(exception_exit)s;
 }"""
 
@@ -34,7 +33,7 @@ template_error_catch_exception = """\
 if (%(condition)s) {
     assert(HAS_ERROR_OCCURRED(tstate));
 
-    FETCH_ERROR_OCCURRED(tstate, &%(exception_type)s, &%(exception_value)s, &%(exception_tb)s);
+    FETCH_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
 %(release_temps)s
 
 %(line_number_code)s
@@ -56,7 +55,7 @@ if (%(condition)s) {
 template_error_format_name_error_exception = """\
 if (unlikely(%(condition)s)) {
 %(release_temps)s
-%(raise_name_error_helper)s(tstate, %(variable_name)s, &%(exception_type)s, &%(exception_value)s);
+%(raise_name_error_helper)s(tstate, &%(exception_state_name)s, %(variable_name)s);
 
 %(line_number_code)s
 %(var_description_code)s