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

nuitka/code_generation/FrameCodes.py

@@ -307,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,
         )
     )
@@ -326,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()
 
@@ -345,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,
             )
         )
@@ -367,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()
 
@@ -410,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,
         )
     )
@@ -432,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

nuitka/code_generation/FunctionCodes.py

@@ -662,17 +662,13 @@ def _getFunctionCode(
 
     if needs_exception_exit:
         (
-            exception_type,
-            exception_value,
-            exception_tb,
+            exception_state_name,
             _exception_lineno,
         ) = context.variable_storage.getExceptionVariableDescriptions()
 
         function_exit += template_function_exception_exit % {
             "function_cleanup": indented(function_cleanup),
-            "exception_type": exception_type,
-            "exception_value": exception_value,
-            "exception_tb": exception_tb,
+            "exception_state_name": exception_state_name,
         }
 
     if context.hasTempName("return_value"):

nuitka/code_generation/GeneratorCodes.py

@@ -82,17 +82,13 @@ def getGeneratorObjectCode(
 
     if needs_exception_exit:
         (
-            exception_type,
-            exception_value,
-            exception_tb,
+            exception_state_name,
             _exception_lineno,
         ) = context.variable_storage.getExceptionVariableDescriptions()
 
         generator_exit = template_generator_exception_exit % {
             "function_cleanup": indented(function_cleanup),
-            "exception_type": exception_type,
-            "exception_value": exception_value,
-            "exception_tb": exception_tb,
+            "exception_state_name": exception_state_name,
         }
     else:
         generator_exit = template_generator_noexception_exit % {

nuitka/code_generation/GlobalConstants.py

@@ -92,6 +92,8 @@ def getConstantDefaultPopulation():
         # Meta path based loader.
         "read",
         "rb",
+        "w",
+        "b",
         # File handling
         "/",
         "\\",
@@ -105,10 +107,15 @@ def getConstantDefaultPopulation():
         "isdir",
         "isfile",
         "listdir",
+        "stat",
+        "close",
     ]
 
+    if python_version < 0x300:
+        result += ("lstat",)
+
     # Pickling of instance methods.
-    if python_version < 0x340:
+    if python_version < 0x300:
         result += ("__newobj__",)
     else:
         result += ("getattr",)
@@ -143,7 +150,6 @@ def getConstantDefaultPopulation():
         result += (
             # YIELD_FROM uses this
             "throw",
-            "close",
         )
 
     if python_version < 0x300:

nuitka/code_generation/GlobalsLocalsCodes.py

@@ -22,7 +22,7 @@ from .templates.CodeTemplatesVariables import (
 )
 from .VariableCodes import (
     getLocalVariableDeclaration,
-    getVariableReferenceCode,
+    getNonModuleVariableReferenceCode,
 )
 from .VariableDeclarations import VariableDeclaration
 
@@ -118,7 +118,7 @@ def _getVariableDictUpdateCode(
 
     access_code = SourceCodeCollector()
 
-    getVariableReferenceCode(
+    getNonModuleVariableReferenceCode(
         to_name=VariableDeclaration("PyObject *", "value", None, None),
         variable=variable,
         variable_trace=variable_trace,

nuitka/code_generation/IteratorCodes.py

@@ -26,10 +26,7 @@ from .ErrorCodes import (
 from .Indentation import indented
 from .LineNumberCodes import getErrorLineNumberUpdateCode
 from .PythonAPICodes import generateCAPIObjectCode
-from .templates.CodeTemplatesIterators import (
-    template_iterator_check,
-    template_loop_break_next,
-)
+from .templates.CodeTemplatesIterators import template_loop_break_next
 
 
 def generateBuiltinNext1Code(to_name, expression, emit, context):
@@ -37,15 +34,38 @@ def generateBuiltinNext1Code(to_name, expression, emit, context):
         expression=expression, emit=emit, context=context
     )
 
+    (
+        exception_state_name,
+        _exception_lineno,
+    ) = context.variable_storage.getExceptionVariableDescriptions()
+
     with withObjectCodeTemporaryAssignment(
         to_name, "next_value", expression, emit, context
     ) as result_name:
-        emit("%s = %s;" % (result_name, "ITERATOR_NEXT(%s)" % value_name))
+        # TODO: Make use of "ITERATOR_NEXT_ITERATOR" in case of known type shape
+        # iterator.
+        emit(
+            """\
+%(to_name)s = ITERATOR_NEXT(%(iterator_name)s);
+if (%(to_name)s == NULL) {
+    FETCH_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
+
+    if (!HAS_EXCEPTION_STATE(&%(exception_state_name)s)) {
+        SET_EXCEPTION_PRESERVATION_STATE_STOP_ITERATION_EMPTY(tstate, &%(exception_state_name)s);
+    }
+}
+"""
+            % {
+                "to_name": result_name,
+                "iterator_name": value_name,
+                "exception_state_name": exception_state_name,
+            }
+        )
 
         getErrorExitCode(
             check_name=result_name,
             release_name=value_name,
-            quick_exception="StopIteration",
+            fetched_exception=True,
             emit=emit,
             context=context,
         )
@@ -53,8 +73,11 @@ def generateBuiltinNext1Code(to_name, expression, emit, context):
         context.addCleanupTempName(result_name)
 
 
-def getBuiltinLoopBreakNextCode(to_name, value, emit, context):
-    emit("%s = %s;" % (to_name, "ITERATOR_NEXT(%s)" % value))
+def getBuiltinLoopBreakNextCode(expression, to_name, value, emit, context):
+    if expression.getTypeShape().isShapeIterator():
+        emit("%s = %s;" % (to_name, "ITERATOR_NEXT_ITERATOR(%s)" % value))
+    else:
+        emit("%s = %s;" % (to_name, "ITERATOR_NEXT(%s)" % value))
 
     getReleaseCode(release_name=value, emit=emit, context=context)
 
@@ -66,9 +89,7 @@ def getBuiltinLoopBreakNextCode(to_name, value, emit, context):
         break_indicator_code = ""
 
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
@@ -78,15 +99,13 @@ def getBuiltinLoopBreakNextCode(to_name, value, emit, context):
             "to_name": to_name,
             "break_indicator_code": break_indicator_code,
             "break_target": break_target,
-            "release_temps": indented(getErrorExitReleaseCode(context), 2),
+            "release_temps": indented(getErrorExitReleaseCode(context), 8),
             "var_description_code": indented(
-                getFrameVariableTypeDescriptionCode(context), 2
+                getFrameVariableTypeDescriptionCode(context), 8
             ),
-            "line_number_code": indented(getErrorLineNumberUpdateCode(context), 2),
+            "line_number_code": indented(getErrorLineNumberUpdateCode(context), 8),
             "exception_target": context.getExceptionEscape(),
-            "exception_type": exception_type,
-            "exception_value": exception_value,
-            "exception_tb": exception_tb,
+            "exception_state_name": exception_state_name,
         }
     )
 
@@ -111,19 +130,35 @@ def generateSpecialUnpackCode(to_name, expression, emit, context):
         if not needs_check:
             emit("%s = UNPACK_NEXT_INFALLIBLE(%s);" % (result_name, value_name))
         elif python_version < 0x350:
+            (
+                exception_state_name,
+                _exception_lineno,
+            ) = context.variable_storage.getExceptionVariableDescriptions()
+
             emit(
-                "%s = UNPACK_NEXT(tstate, %s, %s);"
-                % (result_name, value_name, expression.getCount() - 1)
+                "%s = UNPACK_NEXT(tstate, &%s, %s, %s);"
+                % (
+                    result_name,
+                    exception_state_name,
+                    value_name,
+                    expression.getCount() - 1,
+                )
             )
         else:
             starred = expression.getStarred()
             expected = expression.getExpected()
 
+            (
+                exception_state_name,
+                _exception_lineno,
+            ) = context.variable_storage.getExceptionVariableDescriptions()
+
             emit(
-                "%s = UNPACK_NEXT%s(tstate, %s, %s, %s);"
+                "%s = UNPACK_NEXT%s(tstate, &%s, %s, %s, %s);"
                 % (
                     result_name,
                     "_STARRED" if starred else "",
+                    exception_state_name,
                     value_name,
                     expression.getCount() - 1,
                     expected,
@@ -133,8 +168,8 @@ def generateSpecialUnpackCode(to_name, expression, emit, context):
         getErrorExitCode(
             check_name=result_name,
             release_name=value_name,
-            quick_exception="StopIteration",
             needs_check=needs_check,
+            fetched_exception=True,
             emit=emit,
             context=context,
         )
@@ -152,47 +187,25 @@ def generateUnpackCheckCode(statement, emit, context):
         context=context,
     )
 
-    # These variable cannot collide, as it's used very locally.
-    attempt_name = context.allocateTempName("iterator_attempt", unique=True)
-
-    release_code = getErrorExitReleaseCode(context)
-    var_description_code = getFrameVariableTypeDescriptionCode(context)
-
     with context.withCurrentSourceCodeReference(statement.getSourceReference()):
         (
-            exception_type,
-            exception_value,
-            exception_tb,
+            exception_state_name,
             _exception_lineno,
         ) = context.variable_storage.getExceptionVariableDescriptions()
 
+        res_name = context.getBoolResName()
+
         emit(
-            template_iterator_check
-            % {
-                "iterator_name": iterator_name,
-                "attempt_name": attempt_name,
-                "exception_exit": context.getExceptionEscape(),
-                "release_temps_1": indented(release_code, 3),
-                "line_number_code_1": indented(
-                    getErrorLineNumberUpdateCode(context), 3
-                ),
-                "var_description_code_1": indented(var_description_code, 3),
-                "release_temps_2": indented(release_code),
-                "var_description_code_2": indented(var_description_code),
-                "line_number_code_2": indented(getErrorLineNumberUpdateCode(context)),
-                "exception_type": exception_type,
-                "exception_value": exception_value,
-                "exception_tb": exception_tb,
-                "too_many_values_error": context.getConstantCode(
-                    "too many values to unpack"
-                    if python_version < 0x300
-                    else "too many values to unpack (expected %d)"
-                    % statement.getCount()
-                ),
-            }
+            "%s = UNPACK_ITERATOR_CHECK(tstate, &%s, %s, %d);"
+            % (res_name, exception_state_name, iterator_name, statement.getCount())
         )
 
-        getReleaseCode(release_name=iterator_name, emit=emit, context=context)
+        getErrorExitBoolCode(
+            condition="%s == false" % res_name,
+            fetched_exception=True,
+            emit=emit,
+            context=context,
+        )
 
 
 def generateUnpackCheckFromIteratedCode(statement, emit, context):

nuitka/code_generation/LineNumberCodes.py

@@ -33,9 +33,7 @@ def getLineNumberUpdateCode(context):
 
 def getErrorLineNumberUpdateCode(context):
     (
-        _exception_type,
-        _exception_value,
-        _exception_tb,
+        _exception_state,
         exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 

nuitka/code_generation/ModuleCodes.py

@@ -25,7 +25,13 @@ from .templates.CodeTemplatesModules import (
     template_module_external_entry_point,
     template_module_no_exception_exit,
 )
-from .VariableCodes import getVariableReferenceCode
+from .templates.CodeTemplatesVariables import (
+    template_module_variable_accessor_function,
+)
+from .VariableCodes import (
+    getModuleVariableAccessorCodeName,
+    getModuleVariableReferenceCode,
+)
 
 
 def getModuleAccessCode(context):
@@ -133,6 +139,22 @@ def getModuleCode(
             module_dll_entry_point_prefix + module_dll_entry_point.decode("ascii")
         )
 
+    module_variable_accessor_codes = []
+    for module_variable_name, caching in sorted(
+        context.getModuleVariableAccessors().items()
+    ):
+        module_variable_accessor_codes.append(
+            template_module_variable_accessor_function
+            % {
+                "accessor_function_name": getModuleVariableAccessorCodeName(
+                    module_identifier, module_variable_name
+                ),
+                "var_name": context.getConstantCode(constant=module_variable_name),
+                "module_identifier": module_identifier,
+                "caching": "1" if caching else "0",
+            }
+        )
+
     return template % {
         "module_name_cstr": encodePythonStringToC(
             module_name.asString().encode("utf8")
@@ -148,6 +170,8 @@ def getModuleCode(
         "module_functions_code": function_body_codes,
         "module_function_table_entries": indented(function_table_entries_decl),
         "temps_decl": indented(local_var_inits),
+        "module_variable_accessors": indented(module_variable_accessor_codes, 0),
+        "module_variable_accessors_count": len(module_variable_accessor_codes),
         "module_init_codes": indented(context.getModuleInitCodes()),
         "module_codes": indented(module_codes.codes),
         "module_exit": module_exit,
@@ -169,10 +193,10 @@ def generateModuleAttributeFileCode(to_name, expression, emit, context):
 
 
 def generateModuleAttributeCode(to_name, expression, emit, context):
-    getVariableReferenceCode(
+    getModuleVariableReferenceCode(
         to_name=to_name,
-        variable=expression.getVariable(),
-        variable_trace=None,
+        variable_name=expression.getVariable().getName(),
+        use_caching=False,
         needs_check=False,
         conversion_check=decideConversionCheckNeeded(to_name, expression),
         emit=emit,

nuitka/code_generation/OperationCodes.py

@@ -82,7 +82,7 @@ def generateOperationUnaryCode(to_name, expression, emit, context):
         expression=expression,
         operator=expression.getOperator(),
         arg_name=arg_name,
-        needs_check=expression.mayRaiseException(BaseException),
+        needs_check=expression.mayRaiseExceptionOperation(),
         emit=emit,
         context=context,
     )
@@ -113,6 +113,7 @@ def _getBinaryOperationCode(
                 else "never"
             )
         ),
+        context=context,
     )
 
     prefix = "%s_OPERATION_%s" % (
@@ -146,13 +147,13 @@ def _getBinaryOperationCode(
             # can really raise. Once we have expression for types depending on the
             # value to raise or not, this will get us into trouble, due to using a
             # fallback
+            # helper_type = CTypeBool
 
             # TODO: For now to achieve old behavior, we are going to change to
             # CBOOL for those that cannot raise later.
             if helper_type is CTypeVoid:
                 helper_type = CTypeNuitkaBoolEnum
-            # helper_type = CTypeBool
-            report_missing = False
+                report_missing = False
 
     # If a more specific C type was picked that "PyObject *" then we can use that to have the helper.
     helper_type, helper_function = selectCodeHelper(
@@ -253,9 +254,13 @@ def _getBinaryOperationCode(
         if needs_argument_swap:
             arg1_name = right_name
             arg2_name = left_name
+            arg1_c_type = right_c_type
+            arg2_c_type = left_c_type
         else:
             arg1_name = left_name
             arg2_name = right_name
+            arg1_c_type = left_c_type
+            arg2_c_type = right_c_type
 
         # May need to convert return value.
         if helper_type is not target_type:
@@ -267,36 +272,62 @@ def _getBinaryOperationCode(
         else:
             value_name = to_name
 
-        emit(
-            "%s = %s(%s, %s);"
-            % (
-                value_name,
-                helper_function,
-                arg1_name,
-                arg2_name,
+        if helper_type.isDualType():
+            res_name = context.getBoolResName()
+
+            # TODO: If possible, pass variable storage directly to avoid useless
+            # copy.
+            emit(
+                "%s = %s(&%s, %s%s, %s%s);"
+                % (
+                    res_name,
+                    helper_function,
+                    value_name,
+                    "&" if arg1_c_type.isDualType() else "",
+                    arg1_name,
+                    "&" if arg2_c_type.isDualType() else "",
+                    arg2_name,
+                )
             )
-        )
 
-        if value_name.getCType().hasErrorIndicator():
-            getErrorExitCode(
-                check_name=value_name,
+            getErrorExitBoolCode(
+                condition="%s == false" % res_name,
                 release_names=(left_name, right_name),
                 needs_check=needs_check,
                 emit=emit,
                 context=context,
             )
         else:
-            # Otherwise we picked the wrong kind of helper.
-            assert not needs_check, value_name.getCType()
-
-            getReleaseCodes(
-                release_names=(left_name, right_name), emit=emit, context=context
+            emit(
+                "%s = %s(%s, %s);"
+                % (
+                    value_name,
+                    helper_function,
+                    arg1_name,
+                    arg2_name,
+                )
             )
 
+            if value_name.getCType().hasErrorIndicator():
+                getErrorExitCode(
+                    check_name=value_name,
+                    release_names=(left_name, right_name),
+                    needs_check=needs_check,
+                    emit=emit,
+                    context=context,
+                )
+            else:
+                # Otherwise we picked the wrong kind of helper.
+                assert not needs_check, value_name.getCType()
+
+                getReleaseCodes(
+                    release_names=(left_name, right_name), emit=emit, context=context
+                )
+
         # TODO: Depending on operation, we could not produce a reference, if result *must*
         # be boolean, but then we would have some helpers that do it, and some that do not
         # do it.
-        if helper_type is CTypePyObjectPtr:
+        if helper_type.hasReleaseCode():
             context.addCleanupTempName(value_name)
 
         if value_name is not to_name:

nuitka/code_generation/PackageResourceCodes.py

@@ -939,6 +939,43 @@ def generateOsListdirCallCode(to_name, expression, emit, context):
     )
 
 
+def generateOsStatCallCode(to_name, expression, emit, context):
+    generateCAPIObjectCode(
+        to_name=to_name,
+        capi="OS_STAT",
+        tstate=True,
+        arg_desc=(
+            ("path_arg", expression.subnode_path),
+            ("dir_fd_arg", expression.subnode_dir_fd),
+            ("follow_symlinks_arg", expression.subnode_follow_symlinks),
+        ),
+        may_raise=expression.mayRaiseException(BaseException),
+        conversion_check=decideConversionCheckNeeded(to_name, expression),
+        source_ref=expression.getCompatibleSourceReference(),
+        none_null=True,
+        emit=emit,
+        context=context,
+    )
+
+
+def generateOsLstatCallCode(to_name, expression, emit, context):
+    generateCAPIObjectCode(
+        to_name=to_name,
+        capi="OS_LSTAT",
+        tstate=True,
+        arg_desc=(
+            ("path_arg", expression.subnode_path),
+            ("dir_fd_arg", expression.subnode_dir_fd),
+        ),
+        may_raise=expression.mayRaiseException(BaseException),
+        conversion_check=decideConversionCheckNeeded(to_name, expression),
+        source_ref=expression.getCompatibleSourceReference(),
+        none_null=True,
+        emit=emit,
+        context=context,
+    )
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #