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

nuitka/code_generation/ErrorCodes.py

@@ -16,12 +16,11 @@ And releasing of values, as this is what the error case commonly does.
 
 from nuitka.PythonVersions import python_version
 
-from .ExceptionCodes import getExceptionIdentifier
 from .Indentation import indented
 from .LineNumberCodes import getErrorLineNumberUpdateCode
 from .templates.CodeTemplatesExceptions import (
     template_error_catch_exception,
-    template_error_catch_quick_exception,
+    template_error_catch_fetched_exception,
     template_error_format_name_error_exception,
     template_error_format_string_exception,
 )
@@ -32,12 +31,15 @@ def getErrorExitReleaseCode(context):
         "Py_DECREF(%s);" % tmp_name for tmp_name in context.getCleanupTempNames()
     )
 
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
-    if keeper_variables[0] is not None:
-        temp_release += "\nPy_DECREF(%s);" % keeper_variables[0]
-        temp_release += "\nPy_XDECREF(%s);" % keeper_variables[1]
-        temp_release += "\nPy_XDECREF(%s);" % keeper_variables[2]
+    if keeper_exception_state_name is not None:
+        temp_release += (
+            "\nRELEASE_ERROR_OCCURRED_STATE(&%s);" % keeper_exception_state_name
+        )
 
     return temp_release
 
@@ -60,8 +62,8 @@ def getErrorExitBoolCode(
     context,
     release_names=(),
     release_name=None,
+    fetched_exception=False,
     needs_check=True,
-    quick_exception=None,
 ):
     assert not condition.endswith(";")
 
@@ -79,23 +81,18 @@ def getErrorExitBoolCode(
         return
 
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    if quick_exception:
+    if fetched_exception:
         emit(
             indented(
-                template_error_catch_quick_exception
+                template_error_catch_fetched_exception
                 % {
                     "condition": condition,
-                    "exception_type": exception_type,
-                    "exception_value": exception_value,
-                    "exception_tb": exception_tb,
+                    "exception_state_name": exception_state_name,
                     "exception_exit": context.getExceptionEscape(),
-                    "quick_exception": getExceptionIdentifier(quick_exception),
                     "release_temps": indented(getErrorExitReleaseCode(context)),
                     "var_description_code": indented(
                         getFrameVariableTypeDescriptionCode(context)
@@ -111,9 +108,7 @@ def getErrorExitBoolCode(
                 template_error_catch_exception
                 % {
                     "condition": condition,
-                    "exception_type": exception_type,
-                    "exception_value": exception_value,
-                    "exception_tb": exception_tb,
+                    "exception_state_name": exception_state_name,
                     "exception_exit": context.getExceptionEscape(),
                     "release_temps": indented(getErrorExitReleaseCode(context)),
                     "var_description_code": indented(
@@ -132,7 +127,7 @@ def getErrorExitCode(
     context,
     release_names=(),
     release_name=None,
-    quick_exception=None,
+    fetched_exception=False,
     needs_check=True,
 ):
     getErrorExitBoolCode(
@@ -140,7 +135,7 @@ def getErrorExitCode(
         release_names=release_names,
         release_name=release_name,
         needs_check=needs_check,
-        quick_exception=quick_exception,
+        fetched_exception=fetched_exception,
         emit=emit,
         context=context,
     )
@@ -148,25 +143,22 @@ def getErrorExitCode(
 
 def _getExceptionChainingCode(context):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    keeper_vars = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
-    if keeper_vars[0] is not None:
-        return (
-            "ADD_EXCEPTION_CONTEXT(tstate, &%s, &%s);"
-            % (keeper_vars[0], keeper_vars[1]),
-        )
+    if keeper_exception_state_name is not None:
+        yield "ADD_EXCEPTION_CONTEXT(tstate, &%s);" % keeper_exception_state_name
     else:
-        return (
-            "NORMALIZE_EXCEPTION(tstate, &%s, &%s, &%s);"
-            % (exception_type, exception_value, exception_tb),
-            "CHAIN_EXCEPTION(tstate, %s);" % exception_value,
-        )
+        if python_version < 0x3C0:
+            yield "NORMALIZE_EXCEPTION_STATE(tstate, &%s);" % exception_state_name
+
+        yield "CHAIN_EXCEPTION(tstate, %s.exception_value);" % exception_state_name
 
 
 def getTakeReferenceCode(value_name, emit):
@@ -204,9 +196,7 @@ def getLocalVariableReferenceErrorCode(variable, condition, emit, context):
     variable_name = variable.getName()
 
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
@@ -216,14 +206,12 @@ def getLocalVariableReferenceErrorCode(variable, condition, emit, context):
         helper_code = "FORMAT_UNBOUND_LOCAL_ERROR"
 
     set_exception = [
-        "%s(&%s, &%s, %s);"
+        "%s(tstate, &%s, %s);"
         % (
             helper_code,
-            exception_type,
-            exception_value,
+            exception_state_name,
             context.getConstantCode(variable_name),
         ),
-        "%s = NULL;" % exception_tb,
     ]
 
     # TODO: Move this into the helper code.
@@ -249,16 +237,14 @@ def getLocalVariableReferenceErrorCode(variable, condition, emit, context):
 def getNameReferenceErrorCode(variable_name, condition, emit, context):
     helper_code = "RAISE_CURRENT_EXCEPTION_NAME_ERROR"
 
-    if python_version < 0x340:
+    if python_version < 0x300:
         owner = context.getOwner()
 
         if not owner.isCompiledPythonModule() and not owner.isExpressionClassBodyBase():
             helper_code = "RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR"
 
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
@@ -274,9 +260,7 @@ def getNameReferenceErrorCode(variable_name, condition, emit, context):
                 getFrameVariableTypeDescriptionCode(context)
             ),
             "line_number_code": indented(getErrorLineNumberUpdateCode(context)),
-            "exception_type": exception_type,
-            "exception_value": exception_value,
-            "exception_tb": exception_tb,
+            "exception_state_name": exception_state_name,
         }
     )
 

nuitka/code_generation/ExceptionCodes.py

@@ -11,6 +11,7 @@ from .CodeHelpers import (
     generateExpressionCode,
     withObjectCodeTemporaryAssignment,
 )
+from .ErrorCodes import getErrorExitCode
 from .templates.CodeTemplatesExceptions import (
     template_publish_exception_to_handler,
 )
@@ -42,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;
@@ -100,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
                     ),
                 }
             )
@@ -111,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):
@@ -124,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
@@ -136,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(),
         }
@@ -144,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,
+        )
 
-def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
-    # We try to make optimal code for various cases, pylint: disable=too-many-locals
+        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, for_raise, emit, context):
     from .CallCodes import getCallCodeNoArgs, getCallCodePosArgsQuick
 
     exception_arg_names = []
@@ -174,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,
@@ -187,69 +259,66 @@ 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 exception_type == "ImportError" and python_version >= 0x300:
-            is_new_import_error = True
-        elif exception_type == "ModuleNotFoundError" and python_version >= 0x360:
-            is_new_import_error = True
-        else:
-            is_new_import_error = False
-
-        if is_new_import_error:
-            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,
-                )
-
-                getReferenceExportCode(exception_importerror_name, emit, context)
-                if context.needsCleanup(exception_importerror_name):
-                    context.removeCleanupTempName(exception_importerror_name)
-
-                emit(
-                    "((PyImportErrorObject *)%s)->name = %s;"
-                    % (to_name, exception_importerror_name)
-                )
+        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,
+            )
 
-            import_error_path_expression = expression.subnode_path
+            _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,
+            )
 
-            if import_error_path_expression is not None:
-                exception_importerror_path = context.allocateTempName(
-                    "make_exception_importerror_path"
-                )
+        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,
+            )
 
-                generateExpressionCode(
-                    to_name=exception_importerror_path,
-                    expression=import_error_path_expression,
-                    emit=emit,
-                    context=context,
-                    allow_none=True,
-                )
+            _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,
+            )
 
-                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)
-                )
+def generateBuiltinMakeExceptionCode(to_name, expression, emit, context):
+    _generateBuiltinMakeExceptionCode(
+        to_name=to_name,
+        expression=expression,
+        for_raise=expression.for_raise,
+        emit=emit,
+        context=context,
+    )
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/code_generation/ExpressionCTypeSelectionHelpers.py

@@ -20,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
 
@@ -84,6 +97,8 @@ _long_argument_normalization = {
     (CTypeCLong, CTypePyObjectPtr): True,
     (CTypePyObjectPtr, CTypeCLongDigit): False,
     (CTypeCLongDigit, CTypePyObjectPtr): True,
+    (CTypeNuitkaIntOrLongStruct, CTypeCLongDigit): False,
+    (CTypeCLongDigit, CTypeNuitkaIntOrLongStruct): True,
 }
 
 _str_argument_normalization = {
@@ -95,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()
@@ -104,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