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

nuitka/code_generation/templates/CodeTemplatesFrames.py

@@ -42,7 +42,7 @@ Py_INCREF({{context_identifier}}->m_frame);
 assert(Py_REFCNT({{context_identifier}}->m_frame) == 2); // Frame stack
 {% endif %}
 
-{% if is_python34_or_later %}
+{% if is_python3 %}
 Nuitka_SetFrameGenerator({{context_identifier}}->m_frame, (PyObject *){{context_identifier}});
 {% endif %}
 
@@ -117,10 +117,15 @@ template_frame_guard_normal_exception_handler = """\
 RESTORE_FRAME_EXCEPTION(tstate, {{frame_identifier}});
 {% endif %}
 
-if ({{exception_tb}} == NULL) {
-    {{exception_tb}} = {{tb_making_code}};
-} else if ({{exception_tb}}->tb_frame != &{{frame_identifier}}->m_frame) {
-    {{exception_tb}} = ADD_TRACEBACK({{exception_tb}}, {{frame_identifier}}, {{exception_lineno}});
+{
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}});
+    if (exception_tb == NULL) {
+        exception_tb = {{tb_making_code}};
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    } else if (exception_tb->tb_frame != &{{frame_identifier}}->m_frame) {
+        exception_tb = ADD_TRACEBACK(exception_tb, {{frame_identifier}}, {{exception_lineno}});
+        SET_EXCEPTION_STATE_TRACEBACK(&{{exception_state_name}}, exception_tb);
+    }
 }
 
 {% if attach_locals_code %}
@@ -174,11 +179,14 @@ template_frame_guard_generator_exception_handler = """\
 %(frame_exception_exit)s:;
 
 // If it's not an exit exception, consider and create a traceback for it.
-if (!EXCEPTION_MATCH_GENERATOR(tstate, %(exception_type)s)) {
-    if (%(exception_tb)s == NULL) {
-        %(exception_tb)s = %(tb_making)s;
-    } else if (%(exception_tb)s->tb_frame != &%(frame_identifier)s->m_frame) {
-        %(exception_tb)s = ADD_TRACEBACK(%(exception_tb)s, %(frame_identifier)s, %(exception_lineno)s);
+if (!EXCEPTION_STATE_MATCH_GENERATOR(tstate, &%(exception_state_name)s)) {
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&%(exception_state_name)s);
+    if (exception_tb == NULL) {
+        exception_tb = %(tb_making)s;
+        SET_EXCEPTION_STATE_TRACEBACK(&%(exception_state_name)s, exception_tb);
+    } else if ((%(exception_lineno)s != 0) && (exception_tb->tb_frame != &%(frame_identifier)s->m_frame)) {
+        exception_tb = ADD_TRACEBACK(exception_tb, %(frame_identifier)s, %(exception_lineno)s);
+        SET_EXCEPTION_STATE_TRACEBACK(&%(exception_state_name)s, exception_tb);
     }
 
 %(attach_locals)s

nuitka/code_generation/templates/CodeTemplatesFunction.py

@@ -63,8 +63,8 @@ static PyObject *impl_%(function_identifier)s(PyThreadState *tstate, %(parameter
 template_function_exception_exit = """\
 function_exception_exit:
 %(function_cleanup)s
-    assert(%(exception_type)s);
-    RESTORE_ERROR_OCCURRED(tstate, %(exception_type)s, %(exception_value)s, %(exception_tb)s);
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
 
     return NULL;
 """

nuitka/code_generation/templates/CodeTemplatesGeneratorFunction.py

@@ -84,8 +84,8 @@ template_generator_exception_exit = """\
 
     function_exception_exit:
 %(function_cleanup)s
-    assert(%(exception_type)s);
-    RESTORE_ERROR_OCCURRED(tstate, %(exception_type)s, %(exception_value)s, %(exception_tb)s);
+    CHECK_EXCEPTION_STATE(&%(exception_state_name)s);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
 
     return NULL;
 """

nuitka/code_generation/templates/CodeTemplatesIterators.py

@@ -5,40 +5,6 @@
 
 """
 
-template_iterator_check = """\
-// Check if iterator has left-over elements.
-CHECK_OBJECT(%(iterator_name)s); assert(HAS_ITERNEXT(%(iterator_name)s));
-
-%(attempt_name)s = (*Py_TYPE(%(iterator_name)s)->tp_iternext)(%(iterator_name)s);
-
-if (likely(%(attempt_name)s == NULL)) {
-    PyObject *error = GET_ERROR_OCCURRED(tstate);
-
-    if (error != NULL) {
-        if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration)) {
-            CLEAR_ERROR_OCCURRED(tstate);
-        } else {
-            FETCH_ERROR_OCCURRED(tstate, &%(exception_type)s, &%(exception_value)s, &%(exception_tb)s);
-%(release_temps_1)s
-%(var_description_code_1)s
-%(line_number_code_1)s
-            goto %(exception_exit)s;
-        }
-    }
-} else {
-    Py_DECREF(%(attempt_name)s);
-
-    %(exception_type)s = PyExc_ValueError;
-    Py_INCREF(PyExc_ValueError);
-    %(exception_value)s = %(too_many_values_error)s;
-    Py_INCREF(%(exception_value)s);
-    %(exception_tb)s = NULL;
-%(release_temps_2)s
-%(var_description_code_2)s
-%(line_number_code_2)s
-    goto %(exception_exit)s;
-}"""
-
 template_loop_break_next = """\
 if (%(to_name)s == NULL) {
     if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate)) {
@@ -46,7 +12,7 @@ if (%(to_name)s == NULL) {
         goto %(break_target)s;
     } else {
 %(release_temps)s
-        FETCH_ERROR_OCCURRED(tstate, &%(exception_type)s, &%(exception_value)s, &%(exception_tb)s);
+        FETCH_ERROR_OCCURRED_STATE(tstate, &%(exception_state_name)s);
 %(var_description_code)s
 %(line_number_code)s
         goto %(exception_target)s;

nuitka/code_generation/templates/CodeTemplatesModules.py

@@ -90,6 +90,36 @@ void checkModuleConstants_%(module_identifier)s(PyThreadState *tstate) {
 }
 #endif
 
+// Helper to preserving module variables for Python3.11+
+#if %(module_variable_accessors_count)d
+#if PYTHON_VERSION >= 0x3c0
+NUITKA_MAY_BE_UNUSED static uint32_t _Nuitka_PyDictKeys_GetVersionForCurrentState(PyInterpreterState *interp, PyDictKeysObject *dk)
+{
+    if (dk->dk_version != 0) {
+        return dk->dk_version;
+    }
+    uint32_t result = interp->dict_state.next_keys_version++;
+    dk->dk_version = result;
+    return result;
+}
+#elif PYTHON_VERSION >= 0x3b0
+static uint32_t _Nuitka_next_dict_keys_version = 2;
+
+NUITKA_MAY_BE_UNUSED static uint32_t _Nuitka_PyDictKeys_GetVersionForCurrentState(PyDictKeysObject *dk)
+{
+    if (dk->dk_version != 0) {
+        return dk->dk_version;
+    }
+    uint32_t result = _Nuitka_next_dict_keys_version++;
+    dk->dk_version = result;
+    return result;
+}
+#endif
+#endif
+
+// Accessors to module variables.
+%(module_variable_accessors)s
+
 // The module code objects.
 %(module_code_objects_decl)s
 
@@ -152,7 +182,7 @@ static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObj
     PyObject *code_object_desc = Nuitka_Function_ExtractCodeObjectDescription(tstate, function);
 
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, 8);
-    PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));
+    PyTuple_SET_ITEM(result, 0, Nuitka_PyLong_FromLong(offset));
     PyTuple_SET_ITEM(result, 1, code_object_desc);
     PyTuple_SET_ITEM0(result, 2, function->m_defaults);
 #if PYTHON_VERSION >= 0x300
@@ -425,7 +455,7 @@ PyObject *modulecode_%(module_identifier)s(PyThreadState *tstate, PyObject *modu
 
     UPDATE_STRING_DICT0(moduledict_%(module_identifier)s, (Nuitka_StringObject *)const_str_plain___loader__, Nuitka_Loader_New(loader_entry));
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
 // Set the "__spec__" value
 
 #if %(is_dunder_main)s
@@ -535,7 +565,7 @@ static int Nuitka_TopLevelModule_tp_setattro(PyObject *module, PyObject *name, P
     }
 
     // Prevent "__spec__" update as well.
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     if (PyUnicode_Check(name) && PyUnicode_Compare(name, const_str_plain___spec__) == 0) {
         return 0;
     }
@@ -690,7 +720,7 @@ template_module_exception_exit = """\
 #endif
     PGO_onModuleExit("%(module_identifier)s", false);
 
-    RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
     return NULL;
 }"""
 

nuitka/code_generation/templates/CodeTemplatesVariables.py

@@ -290,6 +290,79 @@ if (%(test_code)s) {
 }
 """
 
+template_module_variable_accessor_function = """\
+static PyObject *%(accessor_function_name)s(PyThreadState *tstate) {
+#if %(caching)s
+    PyObject *result;
+
+#if PYTHON_VERSION < 0x3b0
+    static uint64_t dict_version = 0;
+    static PyObject *cache_value = NULL;
+
+    if (moduledict_%(module_identifier)s->ma_version_tag == dict_version) {
+        CHECK_OBJECT_X(cache_value);
+        result = cache_value;
+    } else {
+        dict_version = moduledict_%(module_identifier)s->ma_version_tag;
+
+        result = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
+        cache_value = result;
+    }
+#else
+    static uint32_t dict_keys_version = 0xFFFFFFFF;
+    static Py_ssize_t cache_dk_index = 0;
+
+    PyDictKeysObject *dk = moduledict_%(module_identifier)s->ma_keys;
+    assert(DK_IS_UNICODE(dk));
+
+#if PYTHON_VERSION >= 0x3c0
+    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(tstate->interp, dk);
+#else
+    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(dk);
+#endif
+
+    if (current_dk_version != dict_keys_version) {
+        dict_keys_version = current_dk_version;
+        Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+        assert(hash != -1);
+
+        cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+    }
+
+    if (cache_dk_index >= 0) {
+        assert(dk->dk_kind != DICT_KEYS_SPLIT);
+
+        PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dk);
+
+        result = entries[cache_dk_index].me_value;
+
+        if (unlikely(result == NULL)) {
+            Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+            assert(hash != -1);
+
+            cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+
+            if (cache_dk_index >= 0) {
+                result = entries[cache_dk_index].me_value;
+            }
+        }
+    } else {
+        result = NULL;
+    }
+#endif
+
+#else
+    PyObject *result = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
+#endif
+
+    if (unlikely(result == NULL)) {
+        result = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)%(var_name)s);
+    }
+
+    return result;
+}
+"""
+
 from . import TemplateDebugWrapper  # isort:skip
 
 TemplateDebugWrapper.checkDebug(globals())

nuitka/code_generation/templates_c/CodeTemplateCallsMixed.c.j2

@@ -4,11 +4,11 @@
 {% if not has_dict_values %}
 PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_VECTORCALL(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *kw_names) {
 {% elif args_count == 0 and has_dict_values %}
-PyObject *CALL_FUNCTION_WITH_NO_ARGS_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_NO_ARGS_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *kw_values, PyObject *kw_names) {
 {% elif not has_tuple_arg %}
-PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *const *args, PyObject *const *kw_values, PyObject *kw_names) {
 {% else %}
-PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}_KWSPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args, PyObject *const *kw_values, PyObject *kw_names) {
+PyObject *CALL_FUNCTION_WITH_POS_ARGS{{args_count}}_KW_SPLIT(PyThreadState *tstate, PyObject *called, PyObject *pos_args, PyObject *const *kw_values, PyObject *kw_names) {
     assert(PyTuple_CheckExact(pos_args));
     PyObject *const *args = &PyTuple_GET_ITEM(pos_args, 0);
 {% endif %}

nuitka/code_generation/templates_c/CodeTemplateCallsPositional.c.j2

@@ -8,7 +8,7 @@ PyObject *CALL_FUNCTION_WITH_SINGLE_ARG(PyThreadState *tstate, PyObject *called,
     PyObject *const *args = &arg; // For easier code compatibility.
 {% else %}
 {% if has_tuple_arg %}
-PyObject *CALL_FUNCTION_WITH_POSARGS{{args_count}}(PyThreadState *tstate, PyObject *called, PyObject *pos_args) {
+PyObject *CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(PyThreadState *tstate, PyObject *called, PyObject *pos_args) {
     assert(PyTuple_CheckExact(pos_args));
     assert(PyTuple_GET_SIZE(pos_args) == {{args_count}});
     PyObject *const *args = &PyTuple_GET_ITEM(pos_args, 0);
@@ -484,7 +484,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
                             result = Nuitka_CallMethodFunctionPosArgs(tstate, (struct Nuitka_FunctionObject const *)init_method, obj, args, {{args_count}});
                         } else {
 {% if has_tuple_arg %}
-                            result = CALL_FUNCTION_WITH_POSARGS{{args_count}}(tstate, init_method, pos_args);
+                            result = CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(tstate, init_method, pos_args);
 {% else %}
                             result = CALL_FUNCTION_WITH_ARGS{{args_count}}(tstate, init_method, args);
 {% endif %}
@@ -595,7 +595,7 @@ PyObject *CALL_FUNCTION_WITH_ARGS{{args_count}}(PyThreadState *tstate, PyObject
             result = Nuitka_CallMethodFunctionPosArgs(tstate, (struct Nuitka_FunctionObject const *)init_method, obj, args, {{args_count}});
         } else {
 {% if has_tuple_arg %}
-            result = CALL_FUNCTION_WITH_POSARGS{{args_count}}(tstate, init_method, pos_args);
+            result = CALL_FUNCTION_WITH_POS_ARGS{{args_count}}(tstate, init_method, pos_args);
 {% else %}
             result = CALL_FUNCTION_WITH_ARGS{{args_count}}(tstate, init_method, args);
 {% endif %}

nuitka/code_generation/templates_c/HelperDictionaryCopy.c.j2

@@ -36,7 +36,6 @@ else
     }
 #else
     /* Python 3 */
-#ifndef PY_NOGIL
     if (_PyDict_HasSplitTable(dict_mp)) {
         PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
         assert(result_mp != NULL);
@@ -102,7 +101,6 @@ else
 
         Nuitka_GC_Track(result_mp);
     } else
-#endif
     {# TODO: This should be working for before 3.6 as well, but posed riddles with
       crashes at release time. Need to check if the keys allocator is different
       in some API somehow, or non-split dictionaries which didn't exist then are
@@ -261,21 +259,6 @@ else
 }
 {% endmacro %}
 
-// Usable fraction of keys.
-#define DK_USABLE_FRACTION(n) (((n) << 1) / 3)
-
-#if PYTHON_VERSION < 0x3b0
-typedef PyObject * PyDictValues;
-#endif
-
-#if PYTHON_VERSION < 0x360
-#define DK_ENTRIES_SIZE(keys) (keys->dk_size)
-#elif PYTHON_VERSION < 0x3b0
-#define DK_ENTRIES_SIZE(keys) DK_USABLE_FRACTION(DK_SIZE(keys))
-#else
-#define DK_ENTRIES_SIZE(keys) (keys->dk_nentries)
-#endif
-
 // More than 2/3 of the keys are used, i.e. no space is wasted.
 #if PYTHON_VERSION < 0x360
 #define IS_COMPACT(dict_mp) (dict_mp->ma_used >= (dict_mp->ma_keys->dk_size * 2) / 3)
@@ -304,94 +287,6 @@ static inline PyDictValues *_Nuitka_PyDict_new_values(Py_ssize_t size) {
 #endif
 }
 
-#if PYTHON_VERSION >= 0x300
-static PyDictObject *_Nuitka_AllocatePyDictObject(PyThreadState *tstate) {
-    PyDictObject *result_mp;
-
-#if NUITKA_DICT_HAS_FREELIST
-    // This is the CPython name, spell-checker: ignore numfree
-
-#if PYTHON_VERSION < 0x3d0
-    PyDictObject **items = tstate->interp->dict_state.free_list;
-    int *numfree = &tstate->interp->dict_state.numfree;
-#else
-    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
-    struct _Py_dict_freelist *state = &freelists->dicts;
-    PyDictObject **items = state->items;
-    int *numfree = &state->numfree;
-#endif
-
-    if (*numfree) {
-        (*numfree) -= 1;
-        result_mp = items[*numfree];
-
-        Nuitka_Py_NewReference((PyObject *)result_mp);
-
-        assert(PyDict_CheckExact((PyObject *)result_mp));
-        assert(result_mp != NULL);
-    } else
-#endif
-    {
-        result_mp = (PyDictObject *)Nuitka_GC_New(&PyDict_Type);
-    }
-
-    return result_mp;
-}
-#endif
-
-#if PYTHON_VERSION >= 0x360
-static PyDictKeysObject *_Nuitka_AllocatePyDictKeysObject(PyThreadState *tstate, Py_ssize_t keys_size) {
-    // CPython names, spell-checker: ignore numfree,dictkeys
-    PyDictKeysObject *dk;
-
-// TODO: Cannot always use cached objects. Need to also consider
-// "log2_size == PyDict_LOG_MINSIZE && unicode" as a criterion,
-// seems it can only be used for the smallest keys type.
-#if NUITKA_DICT_HAS_FREELIST && 0
-#if PYTHON_VERSION < 0x3d0
-    PyDictKeysObject **items = tstate->interp->dict_state.keys_free_list;
-    int *numfree = &tstate->interp->dict_state.keys_numfree;
-#else
-    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
-    struct _Py_dictkeys_freelist *state = &freelists->dictkeys;
-    PyDictKeysObject **items = state->items;
-    int *numfree = &state->numfree;
-#endif
-
-    if (*numfree) {
-        (*numfree) -= 1;
-        dk = items[*numfree];
-    } else
-#endif
-    {
-        dk = (PyDictKeysObject *)NuitkaObject_Malloc(keys_size);
-    }
-
-    return dk;
-}
-#endif
-
-#if PYTHON_VERSION >= 0x360 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT)
-static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
-#if PYTHON_VERSION < 0x360
-    return sizeof(PyDictKeysObject) + (DK_SIZE(keys)-1) * sizeof(PyDictKeyEntry);
-#elif PYTHON_VERSION < 0x370
-    return (sizeof(PyDictKeysObject) -
-            Py_MEMBER_SIZE(PyDictKeysObject, dk_indices) +
-            DK_IXSIZE(keys) * DK_SIZE(keys) +
-            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
-#elif PYTHON_VERSION < 0x3b0
-    return (sizeof(PyDictKeysObject) + DK_IXSIZE(keys) * DK_SIZE(keys) +
-            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
-#else
-    size_t entry_size = keys->dk_kind == DICT_KEYS_GENERAL
-        ?  sizeof(PyDictKeyEntry) : sizeof(PyDictUnicodeEntry);
-    return (sizeof(PyDictKeysObject)
-            + ((size_t)1 << keys->dk_log2_index_bytes)
-            + DK_USABLE_FRACTION(DK_SIZE(keys)) * entry_size);
-#endif
-}
-#endif
 
 PyObject *DICT_COPY(PyThreadState *tstate, PyObject *dict_value) {
 #if _NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT

nuitka/code_generation/templates_c/HelperImportHard.c.j2

@@ -11,8 +11,7 @@
 #ifndef __NUITKA_NO_ASSERT__
             PyErr_PrintEx(0);
 #endif
-            NUITKA_CANNOT_GET_HERE("failed hard import of '{{module_name}}'");
-            abort();
+            NUITKA_ERROR_EXIT("Unexpected failure of hard import of '{{module_name}}'");
 {% else %}
             return NULL;
 {% endif %}

nuitka/code_generation/templates_c/HelperLongTools.c.j2

@@ -29,7 +29,7 @@
         }
     }
 
-    Py_ssize_t {{operand}}_size = {{operand}}_is_negative == false ? {{operand}}_digit_count : -{{operand}}_digit_count;
+    NUITKA_MAY_BE_UNUSED Py_ssize_t {{operand}}_size = {{operand}}_is_negative == false ? {{operand}}_digit_count : -{{operand}}_digit_count;
 {% elif type_desc == c_digit_desc %}
 {# Nothing to do really, banking on C compiler to optimize repeated operations. #}
 {% else %}

nuitka/code_generation/templates_c/HelperOperationBinaryDual.c.j2

@@ -0,0 +1,115 @@
+{#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file #}
+
+{% set props = {"exits": {}} %}
+{% from 'HelperSlotsInt.c.j2' import int_core with context %}
+{% set bool_mode = target and target.type_name in ("nuitka_bool", "nbool") %}
+bool BINARY_OPERATION_{{op_code}}_{{target.getHelperCodeName()}}_{{left.getHelperCodeName()}}_{{right.getHelperCodeName()}}({{ target.getVariableDecl("result") }}, {{left.getVariableDecl("operand1")}}, {{right.getVariableDecl("operand2")}}) {
+    {{ left.getCheckValueCode("operand1") }}
+    {{ right.getCheckValueCode("operand2") }}
+
+    bool left_c_usable = {{left.getDualValidityCheckCode("C", "operand1")}};
+    bool right_c_usable = {{right.getDualValidityCheckCode("C", "operand2")}};
+
+    if (left_c_usable && right_c_usable) {
+{% if target.isSimilarOrSameTypesAsOneOf(n_ilong_desc) %}
+    // Not every code path will make use of all possible results.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4101)
+#endif
+        NUITKA_MAY_BE_UNUSED bool cbool_result;
+        NUITKA_MAY_BE_UNUSED PyObject *obj_result;
+        NUITKA_MAY_BE_UNUSED long clong_result;
+        NUITKA_MAY_BE_UNUSED double cfloat_result;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+        {{int_core(props, operator, nb_slot, bool_mode, left, right, result, "operand1", "operand2", "exit_result_ok", "exit_result_exception", "exit_result_ok_cbool", "exit_result_ok_clong", "exit_result_ok_cfloat", "exit_result_object", "exit_result_ok_left", "exit_result_ok_const_int_0", "exit_result_ok_const_int_neg_1", "exit_result_ok_const_float_0_0", "exit_result_ok_const_float_minus_0_0")}}
+
+{% if props["fall_through_needed"] %}
+{% if left.isDualType() %}
+        {{left.getDualTypeEnsurePythonObjectCode("operand1")}}
+        obj_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{left.getDualType("Python").getHelperCodeName()}}_{{right.getDualType("C").getHelperCodeName()}}({{left.getDualTypeAccessCode("Python", "operand1")}}, {{right.getDualTypeAccessCode("C", "operand2")}});
+{% else %}
+        {{right.getDualTypeEnsurePythonObjectCode("operand2")}}
+        obj_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{left.getDualType("C").getHelperCodeName()}}_{{right.getDualType("Python").getHelperCodeName()}}({{left.getDualTypeAccessCode("C", "operand1")}}, {{right.getDualTypeAccessCode("Python", "operand2")}});
+{% endif %}
+
+        if (unlikely(result == NULL)) {
+            return false;
+        }
+
+        {{ target.getAssignFromObjectExpressionCode("result", "obj_result") }}
+        return true;
+
+{% else %}
+        {{ 0/0 }}
+{% endif %}
+{% endif %}
+
+{% if "exit_result_ok_clong" in props["exits"] %}
+exit_result_ok_clong:
+        {{target.getAssignFromLongExpressionCode("result", "clong_result")}}
+        return true;
+{% endif %}
+
+{% if left.isDualType() %}
+    } else if (left_c_usable == false && right_c_usable) {
+        PyObject *python_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{left.getDualType("Python").getHelperCodeName()}}_{{right.getDualType("C").getHelperCodeName()}}({{left.getDualTypeAccessCode("Python", "operand1")}}, {{right.getDualTypeAccessCode("C", "operand2")}});
+
+        if (unlikely(python_result == NULL)) {
+            return false;
+        }
+
+        {{ target.getSetDualValueCode("Python", "result", "python_result") }}
+        return true;
+{% endif %}
+{% if right.isDualType() %}
+    } else if (left_c_usable && right_c_usable == false) {
+{% if left.isCommutativeType() and right.isCommutativeType() and isCommutativeOperation(op_code) %}
+        PyObject *python_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{right.getDualType("Python").getHelperCodeName()}}_{{left.getDualType("C").getHelperCodeName()}}({{right.getDualTypeAccessCode("Python", "operand2")}}, {{left.getDualTypeAccessCode("C", "operand1")}});
+{% else %}
+        PyObject *python_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{left.getDualType("C").getHelperCodeName()}}_{{right.getDualType("Python").getHelperCodeName()}}({{left.getDualTypeAccessCode("C", "operand1")}}, {{right.getDualTypeAccessCode("Python", "operand2")}});
+{% endif %}
+
+        if (unlikely(python_result == NULL)) {
+            return false;
+        }
+
+        {{ target.getSetDualValueCode("Python", "result", "python_result") }}
+
+        return true;
+{% endif %}
+    } else {
+{% if left.isDualType() and right.isDualType() %}
+        PyObject *python_result = BINARY_OPERATION_{{op_code}}_OBJECT_{{left.getDualType("Python").getHelperCodeName()}}_{{right.getDualType("Python").getHelperCodeName()}}({{left.getDualTypeAccessCode("Python", "operand1")}}, {{right.getDualTypeAccessCode("Python", "operand1")}});
+
+        if (unlikely(python_result == NULL)) {
+            return false;
+        }
+
+        {{ target.getSetDualValueCode("Python", "result", "python_result") }}
+
+        return true;
+{% else %}
+        NUITKA_CANNOT_GET_HERE("cannot happen with types {{left.getHelperCodeName()}} {{right.getHelperCodeName()}}");
+        return false;
+{% 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/code_generation/templates_c/HelperOperationComparisonBytes.c.j2

@@ -9,7 +9,7 @@ static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName
 
     // Same object has fast path for all operations.
     if (operand1 == operand2) {
-{% if operand in ("==", ">=", "<=") %}
+{% if operator in ("==", ">=", "<=") %}
         bool r = true;
 {% else %}
         bool r = false;
@@ -24,10 +24,10 @@ static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName
     Py_ssize_t len_a = Py_SIZE(operand1);
     Py_ssize_t len_b = Py_SIZE(operand2);
 
-{% if operand in ("==", "!=") %}
+{% if operator in ("==", "!=") %}
     if (len_a != len_b) {
         {# Shortcut for equality/inequality, driven by length divergence. #}
-{% if operand == "==" %}
+{% if operator == "==" %}
         bool r = false;
 {% else %}
         bool r = true;
@@ -39,7 +39,7 @@ static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName
         return result;
     } else {
         if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
-{% if operand == "==" %}
+{% if operator == "==" %}
             bool r = true;
 {% else %}
             bool r = false;
@@ -50,7 +50,7 @@ static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName
             {{ target.getTakeReferenceStatement("result", immortal=True) }}
             return result;
         } else {
-{% if operand == "==" %}
+{% if operator == "==" %}
             bool r = false;
 {% else %}
             bool r = true;
@@ -81,13 +81,13 @@ static {{ target.getTypeDecl() }} COMPARE_{{op_code}}_{{target.getHelperCodeName
         c = (len_a < len_b) ? -1 : (len_a > len_b) ? 1 : 0;
     }
 
-{% if operand == "<" %}
+{% if operator == "<" %}
     c = c < 0;
-{% elif operand == "<=" %}
+{% elif operator == "<=" %}
     c = c <= 0;
-{% elif operand == ">" %}
+{% elif operator == ">" %}
     c = c > 0;
-{% elif operand == ">=" %}
+{% elif operator == ">=" %}
     c = c >= 0;
 {% endif %}