Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/code_generation/c_types/CTypeBases.py

@@ -0,0 +1,177 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Base class for all C types.
+
+Defines the interface to use by code generation on C types. Different
+types then have to overload the class methods.
+"""
+
+type_indicators = {
+    "PyObject *": "o",
+    "PyObject **": "O",
+    "struct Nuitka_CellObject *": "c",
+    "nuitka_bool": "b",
+    "nuitka_ilong": "L",
+}
+
+
+class CTypeBase(object):
+    # For overload.
+    c_type = None
+
+    @classmethod
+    def getTypeIndicator(cls):
+        return type_indicators[cls.c_type]
+
+    @classmethod
+    def getInitValue(cls, init_from):
+        """Convert to init value for the type."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getInitTestConditionCode(cls, value_name, inverted):
+        """Get code to test for uninitialized."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def emitVariableAssignCode(
+        cls, value_name, needs_release, tmp_name, ref_count, inplace, emit, context
+    ):
+        """Get code to assign local variable."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getDeleteObjectCode(
+        cls, to_name, value_name, needs_check, tolerant, emit, context
+    ):
+        """Get code to delete (del) local variable."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getVariableArgReferencePassingCode(cls, variable_code_name):
+        """Get code to pass variable as reference argument."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getVariableArgDeclarationCode(cls, variable_code_name):
+        """Get variable declaration code with given name."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getCellObjectAssignmentCode(cls, target_cell_code, variable_code_name, emit):
+        """Get assignment code to given cell object from object."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def emitAssignmentCodeFromBoolCondition(cls, to_name, condition, emit):
+        """Get the assignment code from C boolean condition."""
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def emitAssignmentCodeToNuitkaIntOrLong(
+        cls, to_name, value_name, needs_check, emit, context
+    ):
+        """Get the assignment code to int or long type."""
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, to_name
+
+    @classmethod
+    def hasReleaseCode(cls):
+        return False
+
+    @classmethod
+    def getReleaseCode(cls, value_name, needs_check, emit):
+        """Get release code for given object."""
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def emitReInitCode(cls, value_name, emit):
+        """Get release code for given object."""
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def getTakeReferenceCode(cls, value_name, emit):
+        """Take reference code for given object."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, (value_name, cls.c_type)
+
+    @classmethod
+    def emitTruthCheckCode(cls, to_name, value_name, emit):
+        """Check the truth of a value and indicate exception to an int."""
+        assert to_name.c_type == "int", to_name
+
+        emit("%s = %s ? 1 : 0;" % (to_name, cls.getTruthCheckCode(value_name)))
+
+    @classmethod
+    def emitValueAssertionCode(cls, value_name, emit):
+        """Assert that the value is not unassigned."""
+
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def emitReleaseAssertionCode(cls, value_name, emit):
+        """Assert that the container of the value is not released already of unassigned."""
+        cls.emitValueAssertionCode(value_name, emit)
+
+    @classmethod
+    def emitAssignConversionCode(cls, to_name, value_name, needs_check, emit, context):
+        # Need to overload this for each type it is used for, pylint: disable=unused-argument
+        assert False, cls.c_type
+
+    @classmethod
+    def isDualType(cls):
+        return False
+
+
+class CTypeNotReferenceCountedMixin(object):
+    """Mixin for C types, that have no reference counting mechanism."""
+
+    @classmethod
+    def getReleaseCode(cls, value_name, needs_check, emit):
+        # If no check is needed, assert it for debug mode.
+        if not needs_check:
+            cls.emitValueAssertionCode(value_name, emit=emit)
+
+    @classmethod
+    def getTakeReferenceCode(cls, value_name, emit):
+        pass
+
+    @classmethod
+    def emitReleaseAssertionCode(cls, value_name, emit):
+        pass
+
+
+#     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/c_types/CTypeBooleans.py

@@ -0,0 +1,104 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" CType classes for C bool, this cannot represent unassigned, nor indicate exception.
+
+"""
+
+from .CTypeBases import CTypeBase, CTypeNotReferenceCountedMixin
+
+
+class CTypeBool(CTypeNotReferenceCountedMixin, CTypeBase):
+    c_type = "bool"
+
+    # Return value only obviously.
+    helper_code = "CBOOL"
+
+    @classmethod
+    def emitValueAccessCode(cls, value_name, emit, context):
+        # Nothing to do for this type, pylint: disable=unused-argument
+        assert False
+
+    @classmethod
+    def emitValueAssertionCode(cls, value_name, emit):
+        pass
+
+    @classmethod
+    def emitAssignConversionCode(cls, to_name, value_name, needs_check, emit, context):
+        # Conversion cannot fail really.
+        if value_name.c_type == cls.c_type:
+            emit("%s = %s;" % (to_name, value_name))
+        else:
+            emit(
+                "%s = %s;"
+                % (
+                    to_name,
+                    value_name.getCType().getTruthCheckCode(value_name=value_name),
+                )
+            )
+
+    @classmethod
+    def emitAssignmentCodeFromConstant(
+        cls, to_name, constant, may_escape, emit, context
+    ):
+        # No context needed, pylint: disable=unused-argument
+        emit("%s = %s;" % (to_name, "true" if constant else "false"))
+
+    @classmethod
+    def getInitValue(cls, init_from):
+        return "<not_possible>"
+
+    @classmethod
+    def getInitTestConditionCode(cls, value_name, inverted):
+        return "<not_possible>"
+
+    @classmethod
+    def getDeleteObjectCode(
+        cls, to_name, value_name, needs_check, tolerant, emit, context
+    ):
+        assert False
+
+    @classmethod
+    def emitAssignmentCodeToNuitkaBool(
+        cls, to_name, value_name, needs_check, emit, context
+    ):
+        # Half way, virtual method: pylint: disable=unused-argument
+        emit("%s = %s ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;" % (to_name, value_name))
+
+    @classmethod
+    def emitAssignmentCodeFromBoolCondition(cls, to_name, condition, emit):
+        emit("%s = (%s) ? true : false;" % (to_name, condition))
+
+    @classmethod
+    def emitAssignInplaceNegatedValueCode(cls, to_name, needs_check, emit, context):
+        # Half way, virtual method: pylint: disable=unused-argument
+        emit("%s = !%s;" % (to_name, to_name))
+
+    @classmethod
+    def getExceptionCheckCondition(cls, value_name):
+        # Expected to not be used, pylint: disable=unused-argument
+        assert False
+
+    @classmethod
+    def hasErrorIndicator(cls):
+        return False
+
+    @classmethod
+    def getTruthCheckCode(cls, value_name):
+        return "%s != false" % value_name
+
+
+#     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/c_types/CTypeCFloats.py

@@ -0,0 +1,57 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" CType classes for C "float" (double), (used in conjunction with PyFloatObject *)
+
+"""
+
+from math import copysign, isinf, isnan
+
+from .CTypeBases import CTypeBase
+
+
+class CTypeCFloat(CTypeBase):
+    c_type = "double"
+
+    helper_code = "CFLOAT"
+
+    @classmethod
+    def emitAssignmentCodeFromConstant(
+        cls, to_name, constant, may_escape, emit, context
+    ):
+        # No context needed, pylint: disable=unused-argument
+        if constant == 0.0:
+            if copysign(1, constant) == 1:
+                c_constant = "0.0"
+            else:
+                c_constant = "-0.0"
+        elif isnan(constant):
+            if copysign(1, constant) == 1:
+                c_constant = "NAN"
+            else:
+                c_constant = "-NAN"
+        elif isinf(constant):
+            if copysign(1, constant) == 1:
+                c_constant = "HUGE_VAL"
+            else:
+                c_constant = "-HUGE_VAL"
+        else:
+            c_constant = constant
+
+        emit("%s = %s;" % (to_name, c_constant))
+
+
+#     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/c_types/CTypeCLongs.py

@@ -0,0 +1,45 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" CType classes for C "long", and C "digit" (used in conjunction with PyLongObject *)
+
+"""
+
+from .CTypeBases import CTypeBase
+
+
+class CTypeCLongMixin(CTypeBase):
+    @classmethod
+    def emitAssignmentCodeFromConstant(
+        cls, to_name, constant, may_escape, emit, context
+    ):
+        # No context needed, pylint: disable=unused-argument
+        emit("%s = %s;" % (to_name, constant))
+
+
+class CTypeCLong(CTypeCLongMixin, CTypeBase):
+    c_type = "long"
+
+    helper_code = "CLONG"
+
+
+class CTypeCLongDigit(CTypeCLongMixin, CTypeBase):
+    c_type = "nuitka_digit"
+
+    helper_code = "DIGIT"
+
+
+#     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/c_types/CTypeModuleDictVariables.py

@@ -0,0 +1,109 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Pseudo CType for module variables, object values contained in a dictionary.
+
+    These are to integrate module variables with what is normally local
+    stuff. Going from an to "PyObject *" is mostly its trick, then put
+    into the dict.
+
+"""
+
+from nuitka.code_generation.templates.CodeTemplatesVariables import (
+    template_del_global_known,
+    template_del_global_unclear,
+    template_read_mvar_unclear,
+)
+
+from .CTypeBases import CTypeBase
+
+
+class CTypeModuleDictVariable(CTypeBase):
+    @classmethod
+    def emitVariableAssignCode(
+        cls, value_name, needs_release, tmp_name, ref_count, inplace, emit, context
+    ):
+        if inplace:
+            orig_name = context.getInplaceLeftName()
+
+            emit(
+                """\
+if (%(orig_name)s != %(tmp_name)s) {
+    UPDATE_STRING_DICT_INPLACE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(variable_name_str)s, %(tmp_name)s);
+}"""
+                % {
+                    "orig_name": orig_name,
+                    "tmp_name": tmp_name,
+                    "module_identifier": context.getModuleCodeName(),
+                    "variable_name_str": context.getConstantCode(
+                        constant=value_name.code_name
+                    ),
+                }
+            )
+
+        else:
+            emit(
+                "UPDATE_STRING_DICT%s(moduledict_%s, (Nuitka_StringObject *)%s, %s);"
+                % (
+                    ref_count,
+                    context.getModuleCodeName(),
+                    context.getConstantCode(constant=value_name.code_name),
+                    tmp_name,
+                )
+            )
+
+            if ref_count:
+                context.removeCleanupTempName(tmp_name)
+
+    @classmethod
+    def emitValueAccessCode(cls, value_name, emit, context):
+        tmp_name = context.allocateTempName("mvar_value")
+
+        emit(
+            template_read_mvar_unclear
+            % {
+                "module_identifier": context.getModuleCodeName(),
+                "tmp_name": tmp_name,
+                "var_name": context.getConstantCode(constant=value_name.code_name),
+            }
+        )
+
+        return tmp_name
+
+    @classmethod
+    def getDeleteObjectCode(
+        cls, to_name, value_name, needs_check, tolerant, emit, context
+    ):
+        if not needs_check or tolerant:
+            emit(
+                template_del_global_known
+                % {
+                    "module_identifier": context.getModuleCodeName(),
+                    "var_name": context.getConstantCode(constant=value_name.code_name),
+                }
+            )
+        else:
+            emit(
+                template_del_global_unclear
+                % {
+                    "module_identifier": context.getModuleCodeName(),
+                    "result": to_name,
+                    "var_name": context.getConstantCode(constant=value_name.code_name),
+                }
+            )
+
+
+#     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/c_types/CTypeNuitkaBooleans.py

@@ -0,0 +1,150 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" CType classes for nuitka_bool, an enum to represent True, False, unassigned.
+
+"""
+
+from nuitka.code_generation.ErrorCodes import getReleaseCode
+
+from .CTypeBases import CTypeBase, CTypeNotReferenceCountedMixin
+
+
+class CTypeNuitkaBoolEnum(CTypeNotReferenceCountedMixin, CTypeBase):
+    c_type = "nuitka_bool"
+
+    helper_code = "NBOOL"
+
+    @classmethod
+    def emitVariableAssignCode(
+        cls, value_name, needs_release, tmp_name, ref_count, inplace, emit, context
+    ):
+        assert not inplace
+
+        if tmp_name.c_type == "nuitka_bool":
+            emit("%s = %s;" % (value_name, tmp_name))
+        else:
+            if tmp_name.c_type == "PyObject *":
+                test_code = "%s == Py_True" % tmp_name
+            else:
+                assert False, tmp_name
+
+            cls.emitAssignmentCodeFromBoolCondition(
+                to_name=value_name, condition=test_code, emit=emit
+            )
+
+        if ref_count:
+            getReleaseCode(tmp_name, emit, context)
+
+    @classmethod
+    def emitAssignmentCodeToNuitkaIntOrLong(
+        cls, to_name, value_name, needs_check, emit, context
+    ):
+        assert False, to_name
+
+    @classmethod
+    def getTruthCheckCode(cls, value_name):
+        return "%s == NUITKA_BOOL_TRUE" % value_name
+
+    @classmethod
+    def emitValueAccessCode(cls, value_name, emit, context):
+        # Nothing to do for this type, pylint: disable=unused-argument
+        return value_name
+
+    @classmethod
+    def emitValueAssertionCode(cls, value_name, emit):
+        emit("assert(%s != NUITKA_BOOL_UNASSIGNED);" % value_name)
+
+    @classmethod
+    def emitAssignConversionCode(cls, to_name, value_name, needs_check, emit, context):
+        if value_name.c_type == cls.c_type:
+            emit("%s = %s;" % (to_name, value_name))
+        else:
+            value_name.getCType().emitAssignmentCodeToNuitkaBool(
+                to_name=to_name,
+                value_name=value_name,
+                needs_check=needs_check,
+                emit=emit,
+                context=context,
+            )
+
+            getReleaseCode(value_name, emit, context)
+
+    @classmethod
+    def emitAssignmentCodeFromConstant(
+        cls, to_name, constant, may_escape, emit, context
+    ):
+        # No context needed, pylint: disable=unused-argument
+        emit(
+            "%s = %s;"
+            % (to_name, "NUITKA_BOOL_TRUE" if constant else "NUITKA_BOOL_FALSE")
+        )
+
+    @classmethod
+    def getInitValue(cls, init_from):
+        if init_from is None:
+            return "NUITKA_BOOL_UNASSIGNED"
+        else:
+            assert False, init_from
+            return init_from
+
+    @classmethod
+    def getInitTestConditionCode(cls, value_name, inverted):
+        return "%s %s NUITKA_BOOL_UNASSIGNED" % (value_name, "==" if inverted else "!=")
+
+    @classmethod
+    def emitReInitCode(cls, value_name, emit):
+        emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+
+    @classmethod
+    def getDeleteObjectCode(
+        cls, to_name, value_name, needs_check, tolerant, emit, context
+    ):
+        if not needs_check:
+            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+        elif tolerant:
+            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+        else:
+            emit("%s = %s != NUITKA_BOOL_UNASSIGNED;" % (to_name, value_name))
+            emit("%s = NUITKA_BOOL_UNASSIGNED;" % value_name)
+
+    @classmethod
+    def emitAssignmentCodeFromBoolCondition(cls, to_name, condition, emit):
+        emit(
+            "%(to_name)s = (%(condition)s) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;"
+            % {"to_name": to_name, "condition": condition}
+        )
+
+    @classmethod
+    def emitAssignInplaceNegatedValueCode(cls, to_name, needs_check, emit, context):
+        # Half way, virtual method: pylint: disable=unused-argument
+        cls.emitValueAssertionCode(to_name, emit=emit)
+        emit("assert(%s != NUITKA_BOOL_EXCEPTION);" % to_name)
+
+        cls.emitAssignmentCodeFromBoolCondition(
+            to_name=to_name, condition="%s == NUITKA_BOOL_FALSE" % to_name, emit=emit
+        )
+
+    @classmethod
+    def getExceptionCheckCondition(cls, value_name):
+        return "%s == NUITKA_BOOL_EXCEPTION" % value_name
+
+    @classmethod
+    def hasErrorIndicator(cls):
+        return True
+
+
+#     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.