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

nuitka/tools/specialize/CTypeDescriptions.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ C type descriptions. For specific or general C types, provide code generation help.
 
 """
@@ -22,11 +8,15 @@
 import math
 from abc import abstractmethod
 
-from nuitka.__past__ import getMetaClassBase, long
+from nuitka.__past__ import long
+from nuitka.code_generation.BinaryOperationHelperDefinitions import (
+    isCommutativeType,
+)
 from nuitka.code_generation.Namify import namifyConstant
+from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 
-class TypeDescBase(getMetaClassBase("Type")):
+class TypeDescBase(getMetaClassBase("Type", require_slots=False)):
     # To be overloaded
     type_name = None
     type_desc = None
@@ -288,9 +278,11 @@ class TypeDescBase(getMetaClassBase("Type")):
         if self is object_desc or other is object_desc:
             return "%s == %s" % (
                 self.getTypeValueExpression(None) if self is not object_desc else type1,
-                other.getTypeValueExpression(None)
-                if other is not object_desc
-                else type2,
+                (
+                    other.getTypeValueExpression(None)
+                    if other is not object_desc
+                    else type2
+                ),
             )
         elif self is other:
             return "1"
@@ -301,9 +293,11 @@ class TypeDescBase(getMetaClassBase("Type")):
         if self is object_desc or other is object_desc:
             return "%s != %s" % (
                 self.getTypeValueExpression(None) if self is not object_desc else type1,
-                other.getTypeValueExpression(None)
-                if other is not object_desc
-                else type2,
+                (
+                    other.getTypeValueExpression(None)
+                    if other is not object_desc
+                    else type2
+                ),
             )
         elif self is other:
             return "0"
@@ -350,10 +344,10 @@ class TypeDescBase(getMetaClassBase("Type")):
             )
         elif slot == "tp_richcompare":
             # Try to detect fallbacks, this needs version specific management
-            # for at least "LONG", maybe others.
+            # for at least "LONG", maybe others. spell-checker: ignore RICHCOMPARE
 
             assert self is object_desc, self
-            return "RICHCOMPARE(%s)" % operand
+            return "TP_RICHCOMPARE(%s)" % operand
         elif slot == "tp_compare":
             return operand + "->tp_compare"
         else:
@@ -396,15 +390,21 @@ class TypeDescBase(getMetaClassBase("Type")):
         pass
 
     @staticmethod
-    def getOperationErrorMessageName(operator):
-        if operator == "%":
-            return "%%"
-        elif operator == "**":
+    def getOperationErrorMessageName(operator, inplace):
+        operator = operator.replace("%", "%%")
+
+        if operator == "**" and not inplace:
             return "** or pow()"
         elif operator == "divmod":
+            assert not inplace
             return "divmod()"
-        else:
-            return operator
+
+        assert "=" not in operator, operator
+
+        if inplace:
+            operator = operator + "="
+
+        return operator
 
     def getReturnUnorderableTypeErrorCode(
         self, operator, left, right, operand1, operand2
@@ -461,22 +461,26 @@ return %(return_value)s;""" % {
     def hasSameTypeOperationSpecializationCode(self, other, nb_slot, sq_slot):
         # Many cases, pylint: disable=too-many-branches,too-many-return-statements
 
-        cand = self if self is not object_desc else other
+        candidate = self if self is not object_desc else other
 
         # Both are objects, nothing to be done.
-        if cand is object_desc:
+        if candidate is object_desc:
             assert self is object_desc
             assert other is object_desc
             return False
 
-        # Special case for sequence concats/repeats.
-        if sq_slot is not None and not cand.hasSlot(nb_slot) and cand.hasSlot(sq_slot):
+        # Special case for sequence concat/repeats.
+        if (
+            sq_slot is not None
+            and not candidate.hasSlot(nb_slot)
+            and candidate.hasSlot(sq_slot)
+        ):
             slot = sq_slot
         else:
             slot = nb_slot
 
         if slot == "sq_repeat":
-            if cand in (
+            if candidate in (
                 list_desc,
                 tuple_desc,
                 set_desc,
@@ -489,12 +493,12 @@ return %(return_value)s;""" % {
                 return False
 
         if slot == "nb_remainder":
-            if cand in (list_desc, tuple_desc, set_desc, dict_desc):
+            if candidate in (list_desc, tuple_desc, set_desc, dict_desc):
                 # No remainder with themselves.
                 return False
 
         if slot == "nb_multiply":
-            if cand in (
+            if candidate in (
                 str_desc,
                 bytes_desc,
                 list_desc,
@@ -508,7 +512,7 @@ return %(return_value)s;""" % {
         if slot == "nb_add":
             # Tuple and list, etc. use sq_concat.
             # TODO: What about unicode_desc
-            if cand in (
+            if candidate in (
                 str_desc,
                 bytes_desc,
                 tuple_desc,
@@ -520,7 +524,7 @@ return %(return_value)s;""" % {
                 return False
 
         if slot in ("nb_and", "nb_or", "nb_xor"):
-            if cand in (
+            if candidate in (
                 str_desc,
                 bytes_desc,
                 unicode_desc,
@@ -532,7 +536,7 @@ return %(return_value)s;""" % {
                 return False
 
         if slot in ("nb_lshift", "nb_rshift"):
-            if cand in (
+            if candidate in (
                 str_desc,
                 bytes_desc,
                 unicode_desc,
@@ -561,12 +565,11 @@ return %(return_value)s;""" % {
         else:
             return object_desc
 
-    def isSimilarOrSameTypesAsOneOf(self, *others):
-        for other in others:
-            assert other is not None
+    def isSimilarOrSameTypesAsOneOf(self, other):
+        assert other is not None
 
-            if self is other or other in related_types.get(self, ()):
-                return True
+        if self is other or other in related_types.get(self, ()):
+            return True
 
         return False
 
@@ -588,26 +591,29 @@ return %(return_value)s;""" % {
     def getTypeComparisonSpecializationHelper(
         self, other, op_code, target, operand1, operand2
     ):
-        cand1 = self if self is not object_desc else other
-        cand2 = other if other is not object_desc else self
+        candidate1 = self if self is not object_desc else other
+        candidate2 = other if other is not object_desc else self
 
-        if cand1 is object_desc:
+        if candidate1 is object_desc:
             return "", None, None, None, None, None
 
-        if long_desc in (cand1, cand2) and int_desc in (cand1, cand2):
-            if cand1 == int_desc:
+        if long_desc in (candidate1, candidate2) and int_desc in (
+            candidate1,
+            candidate2,
+        ):
+            if candidate1 == int_desc:
                 operand1 = int_desc.getAsLongValueExpression(operand1)
-                cand1 = c_long_desc
-            elif cand2 == int_desc:
+                candidate1 = c_long_desc
+            elif candidate2 == int_desc:
                 operand2 = int_desc.getAsLongValueExpression(operand1)
-                cand2 = c_long_desc
+                candidate2 = c_long_desc
             else:
                 assert False
 
         if (
             target is n_bool_desc
-            and cand1 is cand2
-            and cand1 not in (tuple_desc, list_desc)
+            and candidate1 is candidate2
+            and candidate1 not in (tuple_desc, list_desc)
         ):
             target = c_bool_desc
 
@@ -616,12 +622,12 @@ return %(return_value)s;""" % {
             % (
                 op_code,
                 target.getHelperCodeName(),
-                cand1.getHelperCodeName(),
-                cand2.getHelperCodeName(),
+                candidate1.getHelperCodeName(),
+                candidate2.getHelperCodeName(),
             ),
             target,
-            cand1,
-            cand2,
+            candidate1,
+            candidate2,
             operand1,
             operand2,
         )
@@ -672,8 +678,11 @@ return %(return_value)s;""" % {
             )
 
     @staticmethod
-    def getTakeReferenceStatement(operand):
-        return "Py_INCREF(%s);" % operand
+    def getTakeReferenceStatement(operand, immortal):
+        return "%s(%s);" % (
+            ("Py_INCREF_IMMORTAL" if immortal else "Py_INCREF"),
+            operand,
+        )
 
     @classmethod
     def hasReferenceCounting(cls):
@@ -702,6 +711,10 @@ return %(return_value)s;""" % {
                 return "Py_INCREF(%s); %s = %s;" % (operand, result, operand)
             else:
                 return "%s = %s;" % (result, operand)
+        elif cls.isDualType():
+            ref_taking = "Py_INCREF(%s); " if take_ref else ""
+
+            return "%sSET_NILONG_OBJECT_VALUE(%s, %s);" % (ref_taking, result, operand)
         else:
             if take_ref:
                 return """%s = %s; """ % (
@@ -752,7 +765,7 @@ return %(return_value)s;""" % {
             # Need to not use that, but pick one.
             assert False
         elif cls.type_name == "int":
-            return "%s = PyInt_FromLong(%s);" % (result, operand)
+            return "%s = Nuitka_PyInt_FromLong(%s);" % (result, operand)
         elif cls.type_name == "long":
             return "%s = Nuitka_LongFromCLong(%s);" % (result, operand)
         elif cls.type_name == "nbool":
@@ -760,16 +773,17 @@ return %(return_value)s;""" % {
                 result,
                 cls.getToValueFromBoolExpression("%s != 0" % operand),
             )
+        elif cls.type_name == "nilong":
+            return "SET_NILONG_C_VALUE(%s, %s);" % (result, operand)
         else:
             assert False, cls
 
     @classmethod
     def getAssignFromBoolExpressionCode(cls, result, operand, give_ref):
         if cls.type_name == "object":
-            # TODO: Python3?
             code = "%s = BOOL_FROM(%s);" % (result, operand)
             if give_ref:
-                code += "Py_INCREF(%s);" % result
+                code += "Py_INCREF_IMMORTAL(%s);" % result
 
             return code
         elif cls.type_name == "nbool":
@@ -905,7 +919,7 @@ Py_INCREF(%(result)s);""" % {
     def getAssignConversionCode(cls, result, left, value):
         def _getObjectObject():
             code = "%s = %s;" % (result, value)
-            code += cls.getTakeReferenceStatement(result)
+            code += cls.getTakeReferenceStatement(result, immortal=False)
 
             return code
 
@@ -939,6 +953,14 @@ Py_INCREF(%(result)s);""" % {
             else:
                 assert False, cls.type_name
 
+    @classmethod
+    def isDualType(cls):
+        return False
+
+    @classmethod
+    def isCommutativeType(cls):
+        return isCommutativeType(cls.getHelperCodeName())
+
 
 class ConcreteTypeBase(TypeDescBase):
     type_decl = "PyObject *"
@@ -966,7 +988,7 @@ assert(%(type_name)s_CheckExact(%(operand)s));""" % {
         pass
 
     @staticmethod
-    def getTakeReferenceStatement(operand):
+    def getTakeReferenceStatement(operand, immortal):
         return ""
 
 
@@ -1378,23 +1400,23 @@ class LongDesc(ConcreteNonSequenceTypeBase):
 
     @staticmethod
     def getLongValueSizeExpression(operand):
-        return "Py_SIZE(%s_long_object)" % operand
+        return "Nuitka_LongGetSignedDigitSize(%s_long_object)" % operand
 
     @staticmethod
     def getLongValueIsNegativeTestExpression(operand):
-        return "Py_SIZE(%s_long_object) < 0" % operand
+        return "Nuitka_LongIsNegative(%s_long_object)" % operand
 
     @staticmethod
     def getLongValueDigitCountExpression(operand):
-        return "Py_ABS(Py_SIZE(%s_long_object))" % operand
+        return "Nuitka_LongGetDigitSize(%s_long_object)" % operand
 
     @staticmethod
     def getLongValueDigitExpression(operand, index):
-        return "%s_long_object->ob_digit[%s]" % (operand, index)
+        return "Nuitka_LongGetDigitPointer(%s_long_object)[%s]" % (operand, index)
 
     @staticmethod
     def getLongValueDigitsPointerExpression(operand):
-        return "%s_long_object->ob_digit" % operand
+        return "Nuitka_LongGetDigitPointer(%s_long_object)" % operand
 
     @staticmethod
     def getLongValueMediumValueExpression(operand):
@@ -1441,6 +1463,12 @@ class ObjectDesc(TypeDescBase):
     def getNoSequenceSlotAccessTestCode(self, type_name):
         return "%s->tp_as_sequence == NULL" % type_name
 
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        # Virtual method, pylint: disable=unused-argument
+        assert value_choice == "C", value_choice
+        return "false"
+
 
 object_desc = ObjectDesc()
 
@@ -1466,6 +1494,25 @@ class ConcreteCTypeBase(TypeDescBase):
     def hasPreferredSlot(right, slot):
         return False
 
+    @classmethod
+    def isDualType(cls):
+        return False
+
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        # Virtual method, pylint: disable=unused-argument
+        assert value_choice == "C", value_choice
+        return "true"
+
+    def getDualType(self, value_choice):
+        assert value_choice == "C", value_choice
+        return self
+
+    @classmethod
+    def getDualTypeAccessCode(cls, value_choice, operand):
+        assert value_choice == "C", (value_choice, cls)
+        return operand
+
 
 class CLongDesc(ConcreteCTypeBase):
     type_name = "clong"
@@ -1490,7 +1537,7 @@ class CLongDesc(ConcreteCTypeBase):
 
     @staticmethod
     def getAsObjectValueExpression(operand):
-        return "PyLong_FromLong(%s)" % operand
+        return "Nuitka_PyLong_FromLong(%s)" % operand
 
     @staticmethod
     def releaseAsObjectValueStatement(operand):
@@ -1518,6 +1565,7 @@ class CLongDesc(ConcreteCTypeBase):
 
     @staticmethod
     def getLongValueMediumValueExpression(operand):
+        # spell-checker: disable=sdigit
         return "(sdigit)%s" % (operand)
 
 
@@ -1599,7 +1647,7 @@ class CBoolDesc(ConcreteCTypeBase):
         return "CHECK_IF_TRUE(%s) == 1" % operand
 
     @staticmethod
-    def getTakeReferenceStatement(operand):
+    def getTakeReferenceStatement(operand, immortal):
         return ""
 
     @staticmethod
@@ -1645,7 +1693,7 @@ class NBoolDesc(ConcreteCTypeBase):
         return cls.getToValueFromBoolExpression("CHECK_IF_TRUE(%s)" % operand)
 
     @staticmethod
-    def getTakeReferenceStatement(operand):
+    def getTakeReferenceStatement(operand, immortal):
         return ""
 
     @staticmethod
@@ -1656,6 +1704,108 @@ class NBoolDesc(ConcreteCTypeBase):
 n_bool_desc = NBoolDesc()
 
 
+class DualTypeBase(ConcreteCTypeBase):
+    @classmethod
+    def getDualValidityCheckCode(cls, value_choice, operand):
+        if value_choice == "C":
+            helper = "IS_%s_C_VALUE_VALID" % cls.type_name.upper()
+        elif value_choice == "Python":
+            helper = "IS_%s_OBJECT_VALUE_VALID" % cls.type_name.upper()
+        else:
+            assert False
+
+        return "%s(%s)" % (helper, operand)
+
+    @classmethod
+    def getDualType(cls, value_choice):
+        if value_choice == "C":
+            return cls.type_dual_types[1]
+        elif value_choice == "Python":
+            return cls.type_dual_types[0]
+        else:
+            assert False
+
+    @classmethod
+    def getDualTypeAccessCode(cls, value_choice, operand):
+        if value_choice == "C":
+            return "%s->c_value" % operand
+        elif value_choice == "Python":
+            return "%s->python_value" % operand
+        else:
+            assert False
+
+    @classmethod
+    def getSetDualValueCode(cls, value_choice, target, value):
+        if value_choice == "C":
+            helper = "SET_%s_C_VALUE" % cls.type_name.upper()
+        elif value_choice == "Python":
+            helper = "SET_%s_OBJECT_VALUE" % cls.type_name.upper()
+        else:
+            assert False
+
+        return "%s(%s, %s);" % (helper, target, value)
+
+    @classmethod
+    def isDualType(cls):
+        return True
+
+    @classmethod
+    def getDualTypeEnsurePythonObjectCode(cls, operand):
+        return "ENFORCE_%s_OBJECT_VALUE(%s);" % (cls.type_name.upper(), operand)
+
+
+class NILongDesc(DualTypeBase):
+    type_name = "nilong"
+    type_desc = "Nuitka int/long/C long value"
+    type_decl = "nuitka_ilong *"
+
+    type_dual_types = long_desc, c_long_desc
+
+    @classmethod
+    def getCheckValueCode(cls, operand):
+        return "CHECK_NILONG_OBJECT(%s);" % operand
+
+    @classmethod
+    def getTypeValueExpression(cls, operand):
+        assert False
+        return "NULL"
+
+    @classmethod
+    def getNewStyleNumberTypeCheckExpression(cls, operand):
+        return "0"
+
+    @staticmethod
+    def getAsLongValueExpression(operand):
+        return "GET_NILONG_C_VALUE(%s)" % operand
+
+    @staticmethod
+    def getAsObjectValueExpression(operand):
+        return "GET_NILONG_OBJECT_VALUE(%s)" % operand
+
+    @staticmethod
+    def getToValueFromBoolExpression(operand):
+        assert False
+        return "%s ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE" % operand
+
+    @classmethod
+    def getToValueFromObjectExpression(cls, operand):
+        # TODO: Seems wrong, int return values only happen to match nuitka_bool here
+        return cls.getToValueFromBoolExpression("CHECK_IF_TRUE(%s)" % operand)
+
+    @staticmethod
+    def getTakeReferenceStatement(operand, immortal):
+        assert False
+        return ""
+
+    @staticmethod
+    def getExceptionResultIndicatorValue():
+        assert False
+        return "NUITKA_BOOL_EXCEPTION"
+
+
+n_ilong_desc = NILongDesc()
+
+
 class NVoidDesc(ConcreteCTypeBase):
     type_name = "nvoid"
     type_desc = "Nuitka C void value"
@@ -1696,7 +1846,7 @@ class NVoidDesc(ConcreteCTypeBase):
         return "NUITKA_VOID_OK"
 
     @staticmethod
-    def getTakeReferenceStatement(operand):
+    def getTakeReferenceStatement(operand, immortal):
         return ""
 
     @staticmethod
@@ -1748,10 +1898,31 @@ related_types = {}
 
 
 def _addRelatedTypes(type_desc_1, type_desc_2):
-    related_types[type_desc_1] = (type_desc_2,)
-    related_types[type_desc_2] = (type_desc_1,)
+    if type_desc_1 not in related_types:
+        related_types[type_desc_1] = set()
+    if type_desc_2 not in related_types:
+        related_types[type_desc_2] = set()
+
+    related_types[type_desc_1].add(type_desc_2)
+    related_types[type_desc_2].add(type_desc_1)
 
 
 _addRelatedTypes(int_desc, c_long_desc)
 _addRelatedTypes(long_desc, c_digit_desc)
+_addRelatedTypes(long_desc, c_long_desc)
 _addRelatedTypes(float_desc, c_float_desc)
+
+#     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/tools/specialize/Common.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Common helper functions for specializing code."""
 
 from nuitka.Constants import the_empty_unicode
@@ -377,3 +363,18 @@ def check():
 
 
 check()
+
+#     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.