Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/include/nuitka/helper/attributes.h

@@ -0,0 +1,90 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_ATTRIBUTES_H__
+#define __NUITKA_HELPER_ATTRIBUTES_H__
+
+// Attribute lookup except special slots below.
+extern PyObject *LOOKUP_ATTRIBUTE(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+
+// Attribute lookup of attribute slot "__dict__".
+extern PyObject *LOOKUP_ATTRIBUTE_DICT_SLOT(PyThreadState *tstate, PyObject *source);
+
+// Attribute lookup of attribute slot "__class__".
+extern PyObject *LOOKUP_ATTRIBUTE_CLASS_SLOT(PyThreadState *tstate, PyObject *source);
+
+// For built-in "hasattr" functionality.
+extern int BUILTIN_HASATTR_BOOL(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+
+// Check for an attribute, cannot raise an exception.
+extern bool HAS_ATTR_BOOL(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+
+// Check for an attribute, can raise an exception.
+extern int HAS_ATTR_BOOL2(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+
+// Set an attribute except for attribute slots below.
+extern bool SET_ATTRIBUTE(PyThreadState *tstate, PyObject *target, PyObject *attr_name, PyObject *value);
+
+// Set the "__dict__" special attribute slot.
+extern bool SET_ATTRIBUTE_DICT_SLOT(PyThreadState *tstate, PyObject *target, PyObject *value);
+
+// Set the "__class__" special attribute slot.
+extern bool SET_ATTRIBUTE_CLASS_SLOT(PyThreadState *tstate, PyObject *target, PyObject *value);
+
+// Special attribute lookups, e.g. "__enter__".
+extern PyObject *LOOKUP_SPECIAL(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+
+// Find an attribute in a class, Python2 only.
+#if PYTHON_VERSION < 0x300
+extern PyObject *FIND_ATTRIBUTE_IN_CLASS(PyClassObject *class_object, PyObject *attr_name);
+#endif
+
+extern PyObject *LOOKUP_MODULE_VALUE(PyDictObject *module_dict, PyObject *var_name);
+
+// In case of DLL usage, this avoids looking up the symbol from it.
+extern getattrofunc PyObject_GenericGetAttr_resolved;
+
+// Avoid repeated code, this checks if a type has the standard implementation, then
+// we can just try and do the same in slightly faster ways.
+static inline bool hasTypeGenericGetAttr(PyTypeObject *type) {
+#if PYTHON_VERSION >= 0x3b0
+    // TODO: Big performance loss here
+    return false;
+#else
+    return type->tp_getattro == PyObject_GenericGetAttr_resolved;
+#endif
+}
+
+// In case of DLL usage, this avoids looking up the symbol from it.
+extern setattrofunc PyObject_GenericSetAttr_resolved;
+
+static inline bool hasTypeGenericSetAttr(PyTypeObject *type) {
+#if PYTHON_VERSION >= 0x3b0
+    // TODO: Big performance loss here
+    return false;
+#else
+    return type->tp_setattro == PyObject_GenericSetAttr_resolved;
+#endif
+}
+
+#if PYTHON_VERSION >= 0x3a0
+static inline bool Nuitka_Descr_IsData(PyObject *object) { return Py_TYPE(object)->tp_descr_set != NULL; }
+#else
+#define Nuitka_Descr_IsData(object) PyDescr_IsData(object)
+#endif
+
+#endif
+
+//     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/build/include/nuitka/helper/boolean.h

@@ -0,0 +1,86 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_BOOLEAN_H__
+#define __NUITKA_HELPER_BOOLEAN_H__
+
+// The slot in Python3 got renamed, compensate it like this.
+#if PYTHON_VERSION >= 0x300
+#define nb_nonzero nb_bool
+#endif
+
+NUITKA_MAY_BE_UNUSED static int CHECK_IF_TRUE(PyObject *object) {
+    CHECK_OBJECT(object);
+
+    if (object == Py_True) {
+        return 1;
+    } else if (object == Py_False || object == Py_None) {
+        return 0;
+    } else {
+        Py_ssize_t result;
+
+        if (Py_TYPE(object)->tp_as_number != NULL && Py_TYPE(object)->tp_as_number->nb_nonzero != NULL) {
+            result = (*Py_TYPE(object)->tp_as_number->nb_nonzero)(object);
+        } else if (Py_TYPE(object)->tp_as_mapping != NULL && Py_TYPE(object)->tp_as_mapping->mp_length != NULL) {
+            result = (*Py_TYPE(object)->tp_as_mapping->mp_length)(object);
+        } else if (Py_TYPE(object)->tp_as_sequence != NULL && Py_TYPE(object)->tp_as_sequence->sq_length != NULL) {
+            result = (*Py_TYPE(object)->tp_as_sequence->sq_length)(object);
+        } else {
+            return 1;
+        }
+
+        if (result > 0) {
+            return 1;
+        } else if (result == 0) {
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static int CHECK_IF_FALSE(PyObject *object) {
+    int result = CHECK_IF_TRUE(object);
+
+    if (result == 0) {
+        return 1;
+    }
+    if (result == 1) {
+        return 0;
+    }
+    return -1;
+}
+
+NUITKA_MAY_BE_UNUSED static inline PyObject *BOOL_FROM(bool value) {
+    CHECK_OBJECT(Py_True);
+    CHECK_OBJECT(Py_False);
+
+    return value ? Py_True : Py_False;
+}
+
+#undef nb_nonzero
+
+typedef enum {
+    NUITKA_BOOL_FALSE = 0,
+    NUITKA_BOOL_TRUE = 1,
+    NUITKA_BOOL_UNASSIGNED = 2,
+    NUITKA_BOOL_EXCEPTION = -1
+} nuitka_bool;
+
+typedef enum { NUITKA_VOID_OK = 0, NUITKA_VOID_EXCEPTION = 1 } nuitka_void;
+
+#endif
+
+//     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/build/include/nuitka/helper/bytearrays.h

@@ -0,0 +1,34 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_BYTEARRAYS_H__
+#define __NUITKA_HELPER_BYTEARRAYS_H__
+
+NUITKA_MAY_BE_UNUSED static PyObject *BYTEARRAY_COPY(PyThreadState *tstate, PyObject *bytearray) {
+    CHECK_OBJECT(bytearray);
+    assert(PyByteArray_CheckExact(bytearray));
+
+    PyObject *result = PyByteArray_FromObject(bytearray);
+
+    if (unlikely(result == NULL)) {
+        return NULL;
+    }
+
+    return result;
+}
+
+#endif
+
+//     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/build/include/nuitka/helper/bytes.h

@@ -0,0 +1,28 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_BYTES_H__
+#define __NUITKA_HELPER_BYTES_H__
+
+#if PYTHON_VERSION >= 0x3a0
+#define NUITKA_BYTES_HAS_FREELIST 1
+extern PyObject *Nuitka_Bytes_FromStringAndSize(const char *data, Py_ssize_t size);
+#else
+#define NUITKA_BYTES_HAS_FREELIST 0
+#define Nuitka_Bytes_FromStringAndSize PyBytes_FromStringAndSize
+#endif
+
+#endif
+//     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/build/include/nuitka/helper/calling_generated.h

@@ -0,0 +1,132 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template CodeTemplateCallsPositional.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+extern PyObject *CALL_FUNCTION_NO_ARGS(PyThreadState *tstate, PyObject *called);
+extern PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called, PyObject *arg);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS1(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS2(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS3(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS4(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS5(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS5(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS6(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS6(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS7(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS7(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS8(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS8(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS9(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS9(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_ARGS10(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS10(PyThreadState *tstate, PyObject *called, PyObject *pos_args);
+extern PyObject *CALL_FUNCTION_WITH_NO_ARGS_KW_SPLIT(PyThreadState *tstate, PyObject *called,
+                                                     PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS1_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS1_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS1_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS2_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS2_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS2_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS3_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS3_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS3_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS4_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS4_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS4_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS5_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS5_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS5_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS6_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS6_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS6_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS7_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS7_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS7_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS8_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS8_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS8_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS9_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                     PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS9_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                   PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS9_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                       PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS10_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                      PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_ARGS10_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args,
+                                                    PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_FUNCTION_WITH_POS_ARGS10_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args,
+                                                        PyObject *const *kw_values, PyObject *kw_names);
+extern PyObject *CALL_METHODDESCR_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called, PyObject *arg);
+extern PyObject *CALL_METHODDESCR_WITH_ARGS2(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_METHODDESCR_WITH_ARGS3(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_METHODDESCR_WITH_ARGS4(PyThreadState *tstate, PyObject *called, PyObject *const *args);
+extern PyObject *CALL_METHOD_NO_ARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name);
+extern PyObject *CALL_METHOD_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                             PyObject *arg);
+extern PyObject *CALL_METHOD_WITH_ARGS2(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS3(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS4(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS5(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS6(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS7(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS8(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS9(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                        PyObject *const *args);
+extern PyObject *CALL_METHOD_WITH_ARGS10(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
+                                         PyObject *const *args);
+
+//     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/build/include/nuitka/helper/comparisons_dual_eq.h

@@ -0,0 +1,47 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized "==" (EQ) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern bool RICH_COMPARE_EQ_CBOOL_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_EQ_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_EQ_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_EQ_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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/build/include/nuitka/helper/comparisons_dual_ge.h

@@ -0,0 +1,39 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized ">=" (GE) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_GE_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_GE_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_GE_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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/build/include/nuitka/helper/comparisons_dual_gt.h

@@ -0,0 +1,39 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized ">" (GT) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_GT_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_GT_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_GT_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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/build/include/nuitka/helper/comparisons_dual_le.h

@@ -0,0 +1,47 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized "<=" (LE) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern PyObject *RICH_COMPARE_LE_OBJECT_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern bool RICH_COMPARE_LE_CBOOL_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_LE_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_LE_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_LE_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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/build/include/nuitka/helper/comparisons_dual_lt.h

@@ -0,0 +1,47 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized "<" (LT) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern PyObject *RICH_COMPARE_LT_OBJECT_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "NILONG" to Nuitka int/long/C long value.
+ */
+extern bool RICH_COMPARE_LT_CBOOL_NILONG_NILONG(nuitka_ilong *operand1, nuitka_ilong *operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_LT_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_LT_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_LT_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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/build/include/nuitka/helper/comparisons_dual_ne.h

@@ -0,0 +1,39 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+/* WARNING, this code is GENERATED. Modify the template HelperOperationComparisonDual.c.j2 instead! */
+
+/* This file is included from another C file, help IDEs to still parse it on its own. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+/* C helpers for type specialized "!=" (NE) comparisons */
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "CLONG" to C platform long value. */
+extern bool RICH_COMPARE_NE_CBOOL_NILONG_CLONG(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern PyObject *RICH_COMPARE_NE_OBJECT_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+/* Code referring to "NILONG" corresponds to Nuitka int/long/C long value and "DIGIT" to C platform digit value for long
+ * Python objects. */
+extern bool RICH_COMPARE_NE_CBOOL_NILONG_DIGIT(nuitka_ilong *operand1, long operand2);
+
+//     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.