Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.5__cp311-cp311-win_amd64.whl

nuitka/build/static_src/OnefileBootstrap.c

@@ -813,6 +813,96 @@ extern bool checkSplashScreen(void);
 #endif
 #endif
 
+#ifdef _WIN32
+
+static bool containsWStringAny(wchar_t const *source, wchar_t const *characters) {
+    while (*characters) {
+        if (wcschr(source, *characters) != NULL) {
+            return true;
+        }
+
+        characters++;
+    }
+
+    return false;
+}
+
+static wchar_t *getCommandLineForChildProcess(void) {
+
+    wchar_t *orig_command_line = GetCommandLineW();
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+    wprintf(L"Command line was '%ls'\n", orig_command_line);
+#endif
+
+    int argc;
+    LPWSTR *argv = CommandLineToArgvW(orig_command_line, &argc);
+    assert(argv != NULL);
+    assert(argc > 0);
+
+    static wchar_t result[32768];
+    result[0] = 0;
+
+    argv[0] = getBinaryPath();
+
+    for (int i = 0; i < argc; i++) {
+        if (i >= 1) {
+            appendWCharSafeW(result, L' ', sizeof(result) / sizeof(wchar_t));
+        }
+
+        bool needs_quote = containsWStringAny(argv[i], L" \t\n\v\"");
+
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+        wprintf(L"Command line arg %d was '%ls' needs quoting %ls\n", i, argv[i], needs_quote ? L"yes" : L"no");
+#endif
+
+        if (needs_quote) {
+            appendWCharSafeW(result, L'"', sizeof(result) / sizeof(wchar_t));
+
+            wchar_t const *current = argv[i];
+
+            for (;;) {
+                int backslash_count = 0;
+
+                while (*current == L'\\') {
+                    current++;
+                    backslash_count += 1;
+                }
+
+                if (*current == 0) {
+                    for (int j = 0; j < backslash_count * 2; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+
+                    break;
+                } else if (*current == L'"') {
+                    for (int j = 0; j < backslash_count * 2 + 1; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+                } else {
+                    for (int j = 0; j < backslash_count; j++) {
+                        appendWCharSafeW(result, L'\\', sizeof(result) / sizeof(wchar_t));
+                    }
+                }
+
+                appendWCharSafeW(result, *current, sizeof(result) / sizeof(wchar_t));
+
+                current++;
+            }
+
+            appendWCharSafeW(result, L'"', sizeof(result) / sizeof(wchar_t));
+
+        } else {
+            appendWStringSafeW(result, argv[i], sizeof(result) / sizeof(wchar_t));
+        }
+    }
+
+#if defined(_NUITKA_EXPERIMENTAL_DEBUG_ONEFILE_HANDLING)
+    wprintf(L"Command line composed to '%ls'\n", result);
+#endif
+    return result;
+}
+#endif
+
 #ifdef _NUITKA_WINMAIN_ENTRY_POINT
 int __stdcall wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, wchar_t *lpCmdLine, int nCmdShow) {
     int argc = __argc;
@@ -1243,12 +1333,12 @@ int main(int argc, char **argv) {
 
     PROCESS_INFORMATION pi;
 
-    bool_res = CreateProcessW(first_filename,        // application name
-                              GetCommandLineW(),     // command line
-                              NULL,                  // process attributes
-                              NULL,                  // thread attributes
-                              TRUE,                  // inherit handles
-                              NORMAL_PRIORITY_CLASS, // creation flags
+    bool_res = CreateProcessW(first_filename,                  // application name
+                              getCommandLineForChildProcess(), // command line
+                              NULL,                            // process attributes
+                              NULL,                            // thread attributes
+                              TRUE,                            // inherit handles
+                              NORMAL_PRIORITY_CLASS,           // creation flags
                               NULL, NULL, &si, &pi);
 
     NUITKA_PRINT_TIMING("ONEFILE: Started slave process.");
@@ -1307,6 +1397,10 @@ int main(int argc, char **argv) {
         exit_code = 2;
     } else if (pid == 0) {
         // Child process
+
+        // Make sure, we use the absolute program path for argv[0]
+        argv[0] = getBinaryPath();
+
         execv(first_filename, argv);
 
         fatalErrorChild("Error, couldn't launch child (exec)", errno);

nuitka/code_generation/AttributeCodes.py

@@ -127,16 +127,18 @@ def generateAttributeLookupCode(to_name, expression, emit, context):
     with withObjectCodeTemporaryAssignment(
         to_name, "attribute_value", expression, emit, context
     ) as value_name:
-        getAttributeLookupCode(
-            to_name=value_name,
-            source_name=source_name,
-            attribute_name=attribute_name,
-            needs_check=expression.subnode_expression.mayRaiseExceptionAttributeLookup(
-                exception_type=BaseException, attribute_name=attribute_name
-            ),
-            emit=emit,
-            context=context,
-        )
+        with context.withCurrentSourceCodeReference(expression.getSourceReference()):
+
+            getAttributeLookupCode(
+                to_name=value_name,
+                source_name=source_name,
+                attribute_name=attribute_name,
+                needs_check=expression.subnode_expression.mayRaiseExceptionAttributeLookup(
+                    exception_type=BaseException, attribute_name=attribute_name
+                ),
+                emit=emit,
+                context=context,
+            )
 
 
 def getAttributeAssignmentCode(target_name, attribute_name, value_name, emit, context):

nuitka/code_generation/CodeGeneration.py

@@ -250,7 +250,6 @@ from .MatchCodes import generateMatchArgsCode
 from .ModuleCodes import (
     generateModuleAttributeCode,
     generateModuleAttributeFileCode,
-    generateNuitkaLoaderCreationCode,
     getModuleCode,
 )
 from .NetworkxCodes import generateNetworkxUtilsDecoratorsArgmapCallCode
@@ -651,8 +650,10 @@ addExpressionDispatchDict(
         "EXPRESSION_BUILTIN_ISSUBCLASS": generateBuiltinIssubclassCode,
         "EXPRESSION_TYPE_CHECK": generateTypeCheckCode,
         "EXPRESSION_SUBTYPE_CHECK": generateSubtypeCheckCode,
+        "EXPRESSION_MATCH_ARGS": generateMatchArgsCode,
         "EXPRESSION_MATCH_TYPE_CHECK_SEQUENCE": generateMatchTypeCheckSequenceCode,
         "EXPRESSION_MATCH_TYPE_CHECK_MAPPING": generateMatchTypeCheckMappingCode,
+        "EXPRESSION_MATCH_SUBSCRIPT_CHECK": generateMatchSubscriptCheckCode,
         "EXPRESSION_BUILTIN_DIR1": generateBuiltinDir1Code,
         "EXPRESSION_BUILTIN_VARS": generateBuiltinVarsCode,
         "EXPRESSION_BUILTIN_HASATTR": generateBuiltinHasattrCode,
@@ -773,6 +774,7 @@ addExpressionDispatchDict(
         "EXPRESSION_IMPORT_MODULE_HARD": generateImportModuleHardCode,
         "EXPRESSION_IMPORT_MODULE_NAME_HARD_MAYBE_EXISTS": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORT_MODULE_NAME_HARD_EXISTS": generateImportModuleNameHardCode,
+        "EXPRESSION_BUILTIN_PATCHABLE_TYPE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_IMPORT_MODULE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_IMPORTLIB_IMPORT_MODULE_CALL": generateImportlibImportCallCode,
         "EXPRESSION_IMPORT_NAME": generateImportNameCode,
@@ -843,12 +845,11 @@ addExpressionDispatchDict(
         "EXPRESSION_OPERATION_NOT": generateOperationNotCode,
         "EXPRESSION_OUTLINE_BODY": generateFunctionOutlineCode,
         "EXPRESSION_OUTLINE_FUNCTION": generateFunctionOutlineCode,
-        # TODO: Rename to make more clear it is an outline
-        "EXPRESSION_CLASS_BODY_P2": generateFunctionOutlineCode,
-        "EXPRESSION_CLASS_BODY_P3": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_MAPPING_BODY": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_DICT_BODY": generateFunctionOutlineCode,
+        "EXPRESSION_CLASS_DICT_BODY_P2": generateFunctionOutlineCode,
         "EXPRESSION_SUBSCRIPT_LOOKUP": generateSubscriptLookupCode,
         "EXPRESSION_SUBSCRIPT_LOOKUP_FOR_UNPACK": generateSubscriptLookupCode,
-        "EXPRESSION_MATCH_SUBSCRIPT_CHECK": generateMatchSubscriptCheckCode,
         "EXPRESSION_SLICE_LOOKUP": generateSliceLookupCode,
         "EXPRESSION_SET_OPERATION_UPDATE": generateSetOperationUpdateCode,
         "EXPRESSION_SIDE_EFFECTS": generateSideEffectsCode,
@@ -872,7 +873,6 @@ addExpressionDispatchDict(
         "EXPRESSION_LOCALS_VARIABLE_REF_OR_FALLBACK": generateLocalsDictVariableRefOrFallbackCode,
         "EXPRESSION_LOCALS_VARIABLE_REF": generateLocalsDictVariableRefCode,
         "EXPRESSION_RAISE_EXCEPTION": generateRaiseExpressionCode,
-        "EXPRESSION_NUITKA_LOADER_CREATION": generateNuitkaLoaderCreationCode,
         "EXPRESSION_PKGUTIL_GET_DATA_REF": generateImportModuleNameHardCode,
         "EXPRESSION_PKG_RESOURCES_REQUIRE_REF": generateImportModuleNameHardCode,
         "EXPRESSION_PKG_RESOURCES_GET_DISTRIBUTION_REF": generateImportModuleNameHardCode,
@@ -945,7 +945,6 @@ addExpressionDispatchDict(
         "EXPRESSION_OS_PATH_NORMPATH_CALL": generateOsPathNormpathCallCode,
         "EXPRESSION_OS_PATH_ISABS_CALL": generateOsPathIsabsCallCode,
         "EXPRESSION_OS_LISTDIR_CALL": generateOsListdirCallCode,
-        "EXPRESSION_MATCH_ARGS": generateMatchArgsCode,
         "EXPRESSION_TYPE_ALIAS": generateTypeAliasCode,
         "EXPRESSION_STR_OPERATION_FORMAT": generateStrFormatMethodCode,
         # TODO: Should have all of these generically or not. This one is required for now.

nuitka/code_generation/ConstantCodes.py

@@ -17,11 +17,16 @@ import os
 import sys
 
 from nuitka import Options
+from nuitka.__past__ import unicode
+from nuitka.containers.Namedtuples import makeNamedtupleClass
 from nuitka.ModuleRegistry import getRootTopModule
 from nuitka.PythonVersions import python_version
 from nuitka.Serialization import GlobalConstantAccessor
 from nuitka.utils.CStrings import encodePythonStringToC
-from nuitka.utils.Distributions import getDistributionTopLevelPackageNames
+from nuitka.utils.Distributions import (
+    getDistribution,
+    getDistributionTopLevelPackageNames,
+)
 from nuitka.Version import getNuitkaVersionTuple
 
 from .CodeHelpers import withObjectCodeTemporaryAssignment
@@ -129,7 +134,19 @@ def getConstantsDefinitionCode():
                 sys.base_exec_prefix
             )
 
-    metadata_values_code = constant_accessor.getConstantCode(metadata_values)
+    runtime_metadata_values = tuple(
+        (
+            distribution_name,
+            (
+                metadata_value.module_name,
+                metadata_value.metadata,
+                metadata_value.entry_points_data,
+            ),
+        )
+        for distribution_name, metadata_value in sorted(metadata_values.items())
+    )
+
+    metadata_values_code = constant_accessor.getConstantCode(runtime_metadata_values)
 
     lines.insert(
         0,
@@ -164,24 +181,50 @@ def getConstantsDefinitionCode():
     return header, body
 
 
+MetaDataDescription = makeNamedtupleClass(
+    "MetaDataDescription",
+    (
+        "module_name",
+        "metadata",
+        "entry_points_data",
+        "reasons",
+    ),
+)
+
 metadata_values = {}
 
 
-def addDistributionMetadataValue(name, distribution):
+def addDistributionMetadataValue(distribution_name, distribution, reason):
+    assert type(distribution_name) in (str, unicode), distribution_name
+
     # Extract what we need to from the distribution object.
-    metadata = str(
-        distribution.read_text("METADATA") or distribution.read_text("PKG-INFO") or ""
-    )
+    if distribution_name not in metadata_values:
+        # The user doesn't have this handy.
+        if distribution is None:
+            distribution = getDistribution(distribution_name)
+
+        metadata = str(
+            distribution.read_text("METADATA")
+            or distribution.read_text("PKG-INFO")
+            or ""
+        )
 
-    entry_points = str(distribution.read_text("entry_points.txt") or "")
+        entry_points_data = str(distribution.read_text("entry_points.txt") or "")
 
-    package_name = getDistributionTopLevelPackageNames(distribution)[0]
+        module_name = getDistributionTopLevelPackageNames(distribution)[0]
 
-    metadata_values[name] = (package_name, metadata, entry_points)
+        metadata_values[distribution_name] = MetaDataDescription(
+            module_name=module_name,
+            metadata=metadata,
+            entry_points_data=entry_points_data,
+            reasons=[reason],
+        )
+    else:
+        metadata_values[distribution_name].reasons.append(reason)
 
 
 def getDistributionMetadataValues():
-    return sorted(tuple(metadata_values.items()))
+    return sorted(metadata_values.items())
 
 
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and

nuitka/code_generation/Emission.py

@@ -50,7 +50,7 @@ def withSubCollector(emit, context):
             for local_declaration in local_declarations:
                 emit(indented(local_declaration))
 
-            sub_emit.emitTo(emit, level=1)
+            sub_emit.emitTo(emit, level=4)
 
             emit("}")
         else:

nuitka/code_generation/GlobalConstants.py

@@ -136,11 +136,8 @@ def getConstantDefaultPopulation():
         # Modules have that attribute starting with Python3
         result.append("__loader__")
 
-    if python_version >= 0x340:
-        result.append(
-            # YIELD_FROM uses this starting 3.4, with 3.3 other code is used.
-            "send"
-        )
+        # YIELD_FROM uses this
+        result.append("send")
 
     if python_version >= 0x300:
         result += (
@@ -175,7 +172,7 @@ def getConstantDefaultPopulation():
         if python_version < 0x300:
             result.append("long")
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         # Work with the __spec__ module attribute.
         result += ("__spec__", "_initializing", "parent")
 
@@ -215,6 +212,9 @@ def getConstantDefaultPopulation():
         result.append("__aenter__")
         result.append("__aexit__")
 
+        # Exception group split method call
+        result.append("split")
+
     if isWin32Windows():
         result.append("fileno")
 

nuitka/code_generation/Indentation.py

@@ -8,14 +8,13 @@ to be the same as in templates.
 """
 
 
-def _indentedCode(codes, count):
+def _indentedCode(codes, prefix):
     return "\n".join(
-        " " * count + line if (line and not line.startswith("#")) else line
-        for line in codes
+        prefix + line if (line and line[0] != "#") else line for line in codes
     )
 
 
-def indented(codes, level=1, vert_block=False):
+def indented(codes, level=4, vert_block=False):
     if type(codes) is str:
         codes = codes.split("\n")
 
@@ -23,7 +22,7 @@ def indented(codes, level=1, vert_block=False):
         codes.insert(0, "")
         codes.append("")
 
-    return _indentedCode(codes, level * 4)
+    return _indentedCode(codes, " " * level)
 
 
 def getCommentCode(comment, emit):

nuitka/code_generation/LoaderCodes.py

@@ -85,6 +85,9 @@ def getModuleMetaPathLoaderEntryCode(module, bytecode_accessor):
     elif module.isPythonExtensionModule():
         flags.append("NUITKA_EXTENSION_MODULE_FLAG")
 
+        if module.isExtensionModulePackage():
+            flags.append("NUITKA_PACKAGE_FLAG")
+
         return template_metapath_loader_extension_module_entry % {
             "module_name": module_c_name,
             "flags": " | ".join(flags),

nuitka/code_generation/LocalsDictCodes.py

@@ -22,7 +22,8 @@ from .PythonAPICodes import getReferenceExportCode
 from .templates.CodeTemplatesVariables import (
     template_read_locals_dict_with_fallback,
     template_read_locals_dict_without_fallback,
-    template_read_locals_mapping_with_fallback,
+    template_read_locals_mapping_with_fallback_no_ref,
+    template_read_locals_mapping_with_fallback_ref,
     template_read_locals_mapping_without_fallback,
 )
 
@@ -95,11 +96,11 @@ def generateLocalsDictSetCode(statement, emit, context):
 
     is_dict = locals_scope.hasShapeDictionaryExact()
 
-    res_name = context.getIntResName()
-
     if is_dict:
+        res_name = context.getBoolResName()
+
         emit(
-            "%s = PyDict_SetItem(%s, %s, %s);"
+            "%s = DICT_SET_ITEM(%s, %s, %s);"
             % (
                 res_name,
                 locals_declaration,
@@ -107,7 +108,17 @@ def generateLocalsDictSetCode(statement, emit, context):
                 value_arg_name,
             )
         )
+
+        getErrorExitBoolCode(
+            condition="%s == false" % res_name,
+            release_name=value_arg_name,
+            needs_check=statement.mayRaiseException(BaseException),
+            emit=emit,
+            context=context,
+        )
     else:
+        res_name = context.getIntResName()
+
         emit(
             "%s = PyObject_SetItem(%s, %s, %s);"
             % (
@@ -118,13 +129,13 @@ def generateLocalsDictSetCode(statement, emit, context):
             )
         )
 
-    getErrorExitBoolCode(
-        condition="%s != 0" % res_name,
-        release_name=value_arg_name,
-        needs_check=statement.mayRaiseException(BaseException),
-        emit=emit,
-        context=context,
-    )
+        getErrorExitBoolCode(
+            condition="%s != 0" % res_name,
+            release_name=value_arg_name,
+            needs_check=statement.mayRaiseException(BaseException),
+            emit=emit,
+            context=context,
+        )
 
 
 def generateLocalsDictDelCode(statement, emit, context):
@@ -194,7 +205,7 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
 
         is_dict = locals_scope.hasShapeDictionaryExact()
 
-        assert not context.needsCleanup(value_name)
+        needs_ref = context.needsCleanup(value_name)
 
         if is_dict:
             template = template_read_locals_dict_with_fallback
@@ -205,12 +216,22 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
                 % {
                     "to_name": value_name,
                     "locals_dict": locals_declaration,
+                    "dict_get_item": (
+                        "DICT_GET_ITEM1" if needs_ref else "DICT_GET_ITEM0"
+                    ),
                     "fallback": fallback_codes,
                     "var_name": context.getConstantCode(constant=variable_name),
                 }
             )
+
+            if needs_ref:
+                context.addCleanupTempName(value_name)
         else:
-            template = template_read_locals_mapping_with_fallback
+            if needs_ref:
+                template = template_read_locals_mapping_with_fallback_ref
+            else:
+                template = template_read_locals_mapping_with_fallback_no_ref
+
             fallback_codes = indented(fallback_emit.codes, 2)
 
             emit(
@@ -226,7 +247,8 @@ def generateLocalsDictVariableRefOrFallbackCode(to_name, expression, emit, conte
 
             # If the fallback took no reference, then make it do it
             # anyway.
-            context.addCleanupTempName(value_name)
+            if not needs_ref:
+                context.addCleanupTempName(value_name)
 
 
 def generateLocalsDictVariableRefCode(to_name, expression, emit, context):

nuitka/code_generation/MatchCodes.py

@@ -13,20 +13,39 @@ from .ErrorCodes import getErrorExitCode
 
 
 def generateMatchArgsCode(to_name, expression, emit, context):
-    (matched_name,) = generateChildExpressionsCode(
+    (matched_value_name, match_type_name) = generateChildExpressionsCode(
         expression=expression, emit=emit, context=context
     )
 
+    # TODO: Prefer "PyObject **" of course once we have that.
+    keywords = expression.getKeywordArgs()
+
+    if keywords:
+        keywords_name = context.getConstantCode(constant=keywords)
+        keywords_name = "&PyTuple_GET_ITEM(%s, 0)" % keywords_name
+    else:
+        keywords_name = "NULL"
+
     with withObjectCodeTemporaryAssignment(
         to_name, "match_args_value", expression, emit, context
     ) as value_name:
         emit(
-            "%s = MATCH_CLASS_ARGS(tstate, %s, %d);"
-            % (value_name, matched_name, expression.max_allowed)
+            "%s = MATCH_CLASS_ARGS(tstate, %s, %s, %d, %s, %d);"
+            % (
+                value_name,
+                matched_value_name,
+                match_type_name,
+                expression.getPositionalArgsCount(),
+                keywords_name,
+                len(keywords),
+            )
         )
 
         getErrorExitCode(
-            check_name=value_name, release_name=matched_name, emit=emit, context=context
+            check_name=value_name,
+            release_names=(matched_value_name, match_type_name),
+            emit=emit,
+            context=context,
         )
 
         context.addCleanupTempName(value_name)

nuitka/code_generation/ModuleCodes.py

@@ -152,7 +152,7 @@ def getModuleCode(
         "module_codes": indented(module_codes.codes),
         "module_exit": module_exit,
         "module_code_objects_decl": indented(module_code_objects_decl, 0),
-        "module_code_objects_init": indented(module_code_objects_init, 1),
+        "module_code_objects_init": indented(module_code_objects_init),
         "constants_count": context.getConstantsCount(),
         "module_const_blob_name": module_const_blob_name,
         "module_dll_entry_point": module_dll_entry_point,
@@ -180,13 +180,6 @@ def generateModuleAttributeCode(to_name, expression, emit, context):
     )
 
 
-def generateNuitkaLoaderCreationCode(to_name, expression, emit, context):
-    with withObjectCodeTemporaryAssignment(
-        to_name, "nuitka_loader_value", expression, emit, context
-    ) as result_name:
-        emit("%s = Nuitka_Loader_New(loader_entry);" % result_name)
-
-
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/code_generation/Namify.py

@@ -33,6 +33,8 @@ def namifyConstant(constant):
     if constant_type is int:
         if constant == 0:
             result = "int_0"
+        elif constant < -10000000 or constant > 10000000:
+            result = "int_hex_%s" % hex(constant)[2:]
         elif constant > 0:
             result = "int_pos_%d" % constant
         else:

nuitka/code_generation/PackageResourceCodes.py

@@ -160,7 +160,11 @@ def generateImportlibMetadataDistributionValueCode(to_name, expression, emit, co
     distribution = expression.distribution
     original_name = expression.original_name
 
-    addDistributionMetadataValue(name=original_name, distribution=distribution)
+    addDistributionMetadataValue(
+        distribution_name=original_name,
+        distribution=distribution,
+        reason="static analysis",
+    )
 
     with withObjectCodeTemporaryAssignment(
         to_name, "distribution_value", expression, emit, context