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

nuitka/code_generation/ExceptionCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Exception handling.
 
 """
@@ -25,6 +11,7 @@ from .CodeHelpers import (
     generateExpressionCode,
     withObjectCodeTemporaryAssignment,
 )
+from .ErrorCodes import getErrorExitCode
 from .templates.CodeTemplatesExceptions import (
     template_publish_exception_to_handler,
 )
@@ -56,57 +43,83 @@ def getTracebackMakingIdentifier(context, lineno_name):
 
 
 def generateExceptionCaughtTypeCode(to_name, expression, emit, context):
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
     with withObjectCodeTemporaryAssignment(
         to_name, "exception_caught_type", expression, emit, context
     ) as value_name:
-        if keeper_variables[0] is None:
-            emit("%s = EXC_TYPE(PyThreadState_GET());" % (value_name,))
+        if keeper_exception_state_name is None:
+            emit("%s = EXC_TYPE(tstate);" % (value_name,))
         else:
-            emit("%s = %s;" % (value_name, keeper_variables[0]))
+            if python_version < 0x3C0:
+                emit(
+                    "%s = %s.exception_type;"
+                    % (value_name, keeper_exception_state_name)
+                )
+            else:
+                emit(
+                    "%s = %s.exception_value;"
+                    % (value_name, keeper_exception_state_name)
+                )
 
 
 def generateExceptionCaughtValueCode(to_name, expression, emit, context):
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
     with withObjectCodeTemporaryAssignment(
         to_name, "exception_caught_value", expression, emit, context
     ) as value_name:
-        if keeper_variables[1] is None:
-            emit("%s = EXC_VALUE(PyThreadState_GET());" % (value_name,))
+        if keeper_exception_state_name is None:
+            emit("%s = EXC_VALUE(tstate);" % value_name)
+        elif python_version >= 0x270:
+            emit("%s = %s.exception_value;" % (value_name, keeper_exception_state_name))
         else:
-            if python_version >= 0x270:
-                emit("%s = %s;" % (value_name, keeper_variables[1]))
-            else:
-                emit(
-                    "%s = %s ? %s : Py_None;"
-                    % (value_name, keeper_variables[1], keeper_variables[1])
+            # For Python2.6, value can be NULL.
+            emit(
+                "%s = %s.exception_value ? %s.exception_value : Py_None;"
+                % (
+                    value_name,
+                    keeper_exception_state_name,
+                    keeper_exception_state_name,
                 )
+            )
+
+        emit("CHECK_OBJECT(%s); " % value_name)
 
 
 def generateExceptionCaughtTracebackCode(to_name, expression, emit, context):
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
     with withObjectCodeTemporaryAssignment(
         to_name, "exception_caught_tb", expression, emit, context
     ) as value_name:
-        if keeper_variables[2] is None:
+        if keeper_exception_state_name is None:
             if python_version < 0x3B0:
-                emit(
-                    "%s = (PyObject *)EXC_TRACEBACK(PyThreadState_GET());"
-                    % (value_name,)
-                )
+                emit("%s = (PyObject *)EXC_TRACEBACK(tstate);" % (value_name,))
             else:
                 emit(
-                    "%s = (PyObject *)GET_EXCEPTION_TRACEBACK(EXC_VALUE(PyThreadState_GET()));"
-                    % (value_name,)
+                    """\
+%(value_name)s = (PyObject *)GET_EXCEPTION_TRACEBACK(EXC_VALUE(tstate));
+if (%(value_name)s == NULL) {
+    %(value_name)s = Py_None;
+}"""
+                    % {"value_name": value_name}
                 )
+
         else:
             emit(
                 """\
-if (%(keeper_tb)s != NULL) {
-    %(to_name)s = (PyObject *)%(keeper_tb)s;
+if (%(keeper_exception_state_name)s.exception_tb != NULL) {
+    %(to_name)s = (PyObject *)%(keeper_exception_state_name)s.exception_tb;
     Py_INCREF(%(to_name)s);
 } else {
     %(to_name)s = (PyObject *)%(tb_making)s;
@@ -114,9 +127,9 @@ if (%(keeper_tb)s != NULL) {
 """
                 % {
                     "to_name": value_name,
-                    "keeper_tb": keeper_variables[2],
+                    "keeper_exception_state_name": keeper_exception_state_name,
                     "tb_making": getTracebackMakingIdentifier(
-                        context=context, lineno_name=keeper_variables[3]
+                        context=context, lineno_name=keeper_lineno
                     ),
                 }
             )
@@ -125,12 +138,13 @@ if (%(keeper_tb)s != NULL) {
 
 
 def getExceptionUnpublishedReleaseCode(emit, context):
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
-    if keeper_variables[0] is not None:
-        emit("Py_DECREF(%s);" % keeper_variables[0])
-        emit("Py_XDECREF(%s);" % keeper_variables[1])
-        emit("Py_XDECREF(%s);" % keeper_variables[2])
+    if keeper_exception_state_name is not None:
+        emit("RELEASE_ERROR_OCCURRED_STATE(&%s);" % keeper_exception_state_name)
 
 
 def generateExceptionPublishCode(statement, emit, context):
@@ -138,11 +152,9 @@ def generateExceptionPublishCode(statement, emit, context):
 
     # Current variables cannot be used anymore now.
     (
-        keeper_type,
-        keeper_value,
-        keeper_tb,
+        keeper_exception_state_name,
         keeper_lineno,
-    ) = context.setExceptionKeeperVariables((None, None, None, None))
+    ) = context.setExceptionKeeperVariables((None, None))
 
     emit(
         template_publish_exception_to_handler
@@ -150,7 +162,7 @@ def generateExceptionPublishCode(statement, emit, context):
             "tb_making": getTracebackMakingIdentifier(
                 context=context, lineno_name=keeper_lineno
             ),
-            "keeper_tb": keeper_tb,
+            "keeper_exception_state_name": keeper_exception_state_name,
             "keeper_lineno": keeper_lineno,
             "frame_identifier": context.getFrameHandle(),
         }
@@ -158,15 +170,44 @@ def generateExceptionPublishCode(statement, emit, context):
 
     # TODO: Make this one thing for performance with thread state shared, also for less code,
     # then we should not make it in header anymore. Might be more scalable too.
-    emit(
-        "PUBLISH_CURRENT_EXCEPTION(tstate, &%s, &%s, &%s);"
-        % (keeper_type, keeper_value, keeper_tb)
-    )
+    emit("PUBLISH_CURRENT_EXCEPTION(tstate, &%s);" % keeper_exception_state_name)
+
+
+def _attachExceptionAttributeCode(
+    to_name,
+    attribute_expression,
+    c_type_name,
+    c_attribute_name,
+    base_name_str,
+    emit,
+    context,
+):
+    if attribute_expression is not None:
+        from .PythonAPICodes import getReferenceExportCode
+
+        exception_attribute_name = context.allocateTempName(
+            base_name_str + "_" + c_attribute_name
+        )
+
+        generateExpressionCode(
+            to_name=exception_attribute_name,
+            expression=attribute_expression,
+            emit=emit,
+            context=context,
+            allow_none=True,
+        )
 
+        getReferenceExportCode(exception_attribute_name, emit, context)
+        if context.needsCleanup(exception_attribute_name):
+            context.removeCleanupTempName(exception_attribute_name)
+
+        emit(
+            "((%s *)%s)->%s = %s;"
+            % (c_type_name, to_name, c_attribute_name, exception_attribute_name)
+        )
 
-def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
-    # We try to make optimal code for various cases, pylint: disable=too-many-locals
 
+def _generateBuiltinMakeExceptionCode(to_name, expression, for_raise, emit, context):
     from .CallCodes import getCallCodeNoArgs, getCallCodePosArgsQuick
 
     exception_arg_names = []
@@ -188,10 +229,27 @@ def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
     with withObjectCodeTemporaryAssignment(
         to_name, "exception_made", expression, emit, context
     ) as value_name:
-        if exception_arg_names:
+        exception_name = getExceptionIdentifier(exception_type)
+
+        if len(exception_arg_names) == 1 and for_raise:
+            emit(
+                "%s = MAKE_EXCEPTION_WITH_VALUE(tstate, %s, %s);"
+                % (value_name, exception_name, exception_arg_names[0])
+            )
+
+            getErrorExitCode(
+                check_name=value_name,
+                release_names=exception_arg_names,
+                needs_check=expression.mayRaiseExceptionOperation(),
+                emit=emit,
+                context=context,
+            )
+
+            context.addCleanupTempName(value_name)
+        elif exception_arg_names:
             getCallCodePosArgsQuick(
                 to_name=value_name,
-                called_name=getExceptionIdentifier(exception_type),
+                called_name=exception_name,
                 expression=expression,
                 arg_names=exception_arg_names,
                 emit=emit,
@@ -201,59 +259,79 @@ def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
         else:
             getCallCodeNoArgs(
                 to_name=value_name,
-                called_name=getExceptionIdentifier(exception_type),
+                called_name=exception_name,
                 expression=expression,
                 emit=emit,
                 context=context,
             )
 
-        if expression.getExceptionName() == "ImportError" and python_version >= 0x300:
-            from .PythonAPICodes import getReferenceExportCode
-
-            import_error_name_expression = expression.subnode_name
-
-            if import_error_name_expression is not None:
-                exception_importerror_name = context.allocateTempName(
-                    "make_exception_importerror_name"
-                )
-
-                generateExpressionCode(
-                    to_name=exception_importerror_name,
-                    expression=import_error_name_expression,
-                    emit=emit,
-                    context=context,
-                    allow_none=True,
-                )
+        if (
+            expression.isExpressionBuiltinMakeExceptionImportError()
+            or expression.isExpressionBuiltinMakeExceptionModuleNotFoundError()
+        ):
+            _attachExceptionAttributeCode(
+                to_name=to_name,
+                attribute_expression=expression.subnode_name,
+                base_name_str="exception_import_error",
+                c_type_name="PyImportErrorObject",
+                c_attribute_name="name",
+                emit=emit,
+                context=context,
+            )
 
-                getReferenceExportCode(exception_importerror_name, emit, context)
-                if context.needsCleanup(exception_importerror_name):
-                    context.removeCleanupTempName(exception_importerror_name)
+            _attachExceptionAttributeCode(
+                to_name=to_name,
+                attribute_expression=expression.subnode_path,
+                base_name_str="exception_import_error",
+                c_type_name="PyImportErrorObject",
+                c_attribute_name="path",
+                emit=emit,
+                context=context,
+            )
 
-                emit(
-                    "((PyImportErrorObject *)%s)->name = %s;"
-                    % (to_name, exception_importerror_name)
-                )
+        elif expression.isExpressionBuiltinMakeExceptionAttributeError():
+            _attachExceptionAttributeCode(
+                to_name=to_name,
+                attribute_expression=expression.subnode_name,
+                base_name_str="exception_import_error",
+                c_type_name="PyAttributeErrorObject",
+                c_attribute_name="name",
+                emit=emit,
+                context=context,
+            )
 
-            import_error_path_expression = expression.subnode_path
+            _attachExceptionAttributeCode(
+                to_name=to_name,
+                attribute_expression=expression.subnode_obj,
+                base_name_str="exception_import_error",
+                c_type_name="PyAttributeErrorObject",
+                c_attribute_name="obj",
+                emit=emit,
+                context=context,
+            )
 
-            if import_error_path_expression is not None:
-                exception_importerror_path = context.allocateTempName(
-                    "make_exception_importerror_path"
-                )
 
-                generateExpressionCode(
-                    to_name=exception_importerror_path,
-                    expression=import_error_path_expression,
-                    emit=emit,
-                    context=context,
-                    allow_none=True,
-                )
+def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
+    _generateBuiltinMakeExceptionCode(
+        to_name=to_name,
+        expression=expression,
+        for_raise=expression.for_raise,
+        emit=emit,
+        context=context,
+    )
 
-                getReferenceExportCode(exception_importerror_path, emit, context)
-                if context.needsCleanup(exception_importerror_path):
-                    context.removeCleanupTempName(exception_importerror_path)
 
-                emit(
-                    "((PyImportErrorObject *)%s)->path = %s;"
-                    % (to_name, exception_importerror_path)
-                )
+#     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.

nuitka/code_generation/ExpressionCTypeSelectionHelpers.py

@@ -1,26 +1,13 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Module for helpers to select types for operation arguments.
 
 This is first used for comparisons and binary operations, but should see
 general use too and expand beyond constant values, e.g. covering constant
 values that are of behind conditions or variables.
 """
+
 from nuitka.nodes.shapes.BuiltinTypeShapes import (
     tshape_bytearray,
     tshape_bytes,
@@ -33,26 +20,39 @@ from nuitka.nodes.shapes.BuiltinTypeShapes import (
 from nuitka.PythonVersions import (
     isPythonValidCLongValue,
     isPythonValidDigitValue,
-    python_version,
 )
 
 from .c_types.CTypeCFloats import CTypeCFloat
 from .c_types.CTypeCLongs import CTypeCLong, CTypeCLongDigit
+from .c_types.CTypeNuitkaInts import CTypeNuitkaIntOrLongStruct
 from .c_types.CTypePyObjectPointers import CTypePyObjectPtr
+from .VariableCodes import getLocalVariableDeclaration
 
 
-def _pickIntFamilyType(expression):
+def _pickIntFamilyType(expression, context):
     if expression.isCompileTimeConstant():
-        # On Python2, "INT_CLONG" is very fast as "CLONG" is the internal representation
-        # of it, for Python3, it should be avoided, it usually is around 2**30.
-        if python_version < 0x300:
-            c_type = CTypeCLong
-        elif isPythonValidDigitValue(expression.getCompileTimeConstant()):
+        if isPythonValidDigitValue(expression.getCompileTimeConstant()):
             c_type = CTypeCLongDigit
         elif isPythonValidCLongValue(expression.getCompileTimeConstant()):
             c_type = CTypeCLong
         else:
             c_type = CTypePyObjectPtr
+    elif expression.isExpressionVariableRefOrTempVariableRef():
+        # TODO: Module variables are not doing it (yet?)
+        variable = expression.getVariable()
+
+        # TODO: Closure variables should be possible to have non
+        # CTypePyObjectPtr eventually.
+        if variable.isLocalVariable() and not variable.isSharedTechnically():
+            variable_declaration = getLocalVariableDeclaration(
+                context=context,
+                variable=expression.getVariable(),
+                variable_trace=expression.getVariableTrace(),
+            )
+
+            c_type = variable_declaration.getCType()
+        else:
+            c_type = CTypePyObjectPtr
     else:
         c_type = CTypePyObjectPtr
 
@@ -97,6 +97,8 @@ _long_argument_normalization = {
     (CTypeCLong, CTypePyObjectPtr): True,
     (CTypePyObjectPtr, CTypeCLongDigit): False,
     (CTypeCLongDigit, CTypePyObjectPtr): True,
+    (CTypeNuitkaIntOrLongStruct, CTypeCLongDigit): False,
+    (CTypeCLongDigit, CTypeNuitkaIntOrLongStruct): True,
 }
 
 _str_argument_normalization = {
@@ -108,7 +110,7 @@ _bytes_argument_normalization = {
 }
 
 
-def decideExpressionCTypes(left, right, may_swap_arguments):
+def decideExpressionCTypes(left, right, may_swap_arguments, context):
     # Complex stuff with many cases, pylint: disable=too-many-branches
 
     left_shape = left.getTypeShape()
@@ -117,8 +119,8 @@ def decideExpressionCTypes(left, right, may_swap_arguments):
     if left_shape in _int_types_family and right_shape in _int_types_family:
         may_swap_arguments = may_swap_arguments in ("number", "always")
 
-        left_c_type = _pickIntFamilyType(left)
-        right_c_type = _pickIntFamilyType(right)
+        left_c_type = _pickIntFamilyType(left, context)
+        right_c_type = _pickIntFamilyType(right, context)
 
         needs_argument_swap = (
             may_swap_arguments
@@ -207,3 +209,19 @@ def decideExpressionCTypes(left, right, may_swap_arguments):
         left_c_type,
         right_c_type,
     )
+
+
+#     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.

nuitka/code_generation/ExpressionCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Expression codes, side effects, or statements that are an unused expression.
 
 When you write "f()", i.e. you don't use the return value, that is an expression
@@ -57,3 +43,19 @@ def generateSideEffectsCode(to_name, expression, emit, context):
         emit=emit,
         context=context,
     )
+
+
+#     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.

nuitka/code_generation/FrameCodes.py

@@ -1,20 +1,6 @@
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Frame codes
 
 This is about frame stacks and their management. There are different kinds
@@ -258,9 +244,11 @@ def getFrameGuardHeavyCode(
                 "locals_size": getFrameLocalsStorageSize(
                     context.getFrameVariableTypeDescriptions()
                 ),
-                "locals_dict_name": frame_node.getLocalsScope().getCodeName()
-                if use_locals_dict
-                else "NULL",
+                "locals_dict_name": (
+                    frame_node.getLocalsScope().getCodeName()
+                    if use_locals_dict
+                    else "NULL"
+                ),
             }
         )
 
@@ -319,7 +307,6 @@ Py_CLEAR(%(frame_identifier)s->m_frame.f_locals);
             frame_init_code=frame_init_code,
             frame_exit_code=frame_exit_code,
             context_identifier=context_identifier,
-            is_python34_or_later=python_version >= 0x340,
             is_python3=python_version >= 0x300,
         )
     )
@@ -338,9 +325,7 @@ Py_CLEAR(%(frame_identifier)s->m_frame.f_locals);
 
     if frame_exception_exit is not None:
         (
-            _exception_type,
-            _exception_value,
-            exception_tb,
+            exception_state_name,
             exception_lineno,
         ) = context.variable_storage.getExceptionVariableDescriptions()
 
@@ -357,7 +342,7 @@ Py_CLEAR(%(frame_identifier)s->m_frame.f_locals);
                 frame_exception_exit=frame_exception_exit,
                 frame_exit_code=frame_exit_code,
                 needs_preserve=needs_preserve,
-                exception_tb=exception_tb,
+                exception_state_name=exception_state_name,
                 exception_lineno=exception_lineno,
             )
         )
@@ -379,9 +364,7 @@ def getFrameGuardGeneratorCode(
     # We really need this many parameters here and it gets very
     # detail rich, pylint: disable=too-many-locals
     (
-        exception_type,
-        _exception_value,
-        exception_tb,
+        exception_state_name,
         exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
@@ -422,7 +405,6 @@ def getFrameGuardGeneratorCode(
             frame_init_code=frame_init_code,
             frame_exit_code=frame_exit_code,
             is_generator=is_generator,
-            is_python34_or_later=python_version >= 0x340,
             is_python3=python_version >= 0x300,
         )
     )
@@ -444,8 +426,7 @@ def getFrameGuardGeneratorCode(
                 "context_identifier": context_identifier,
                 "frame_identifier": frame_identifier,
                 "frame_cache_identifier": frame_cache_identifier,
-                "exception_type": exception_type,
-                "exception_tb": exception_tb,
+                "exception_state_name": exception_state_name,
                 "exception_lineno": exception_lineno,
                 "tb_making": getTracebackMakingIdentifier(
                     context=context, lineno_name=exception_lineno
@@ -510,3 +491,19 @@ SET_CURRENT_EXCEPTION(tstate, &%(exception_preserved)s);
                 "preserver_id": preserver_id,
             }
         )
+
+
+#     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.