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

nuitka/build/include/nuitka/helper/dictionaries.h

@@ -1,20 +1,5 @@
-//     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
+
 #ifndef __NUITKA_DICTIONARIES_H__
 #define __NUITKA_DICTIONARIES_H__
 
@@ -46,7 +31,7 @@ static PyDictEntry *GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_StringObjec
 
     // Only improvement would be to identify how to ensure that the hash is
     // computed already. Calling hash early on could do that potentially.
-    if (hash == -1) {
+    if (unlikely(hash == -1)) {
         hash = PyString_Type.tp_hash((PyObject *)key);
         key->ob_shash = hash;
     }
@@ -72,7 +57,7 @@ static PyObject *GET_STRING_DICT_VALUE(PyDictObject *dict, Nuitka_StringObject *
 
 #else
 
-// Python 3.3 or higher.
+// Python3
 
 // Quick dictionary lookup for a string value.
 
@@ -159,6 +144,8 @@ struct _dictkeysobject {
 typedef PyObject **Nuitka_DictEntryHandle;
 
 #if PYTHON_VERSION >= 0x3b0
+extern Py_ssize_t Nuitka_Py_unicodekeys_lookup_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash);
+
 extern Py_ssize_t Nuitka_PyDictLookup(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr);
 extern Py_ssize_t Nuitka_PyDictLookupStr(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr);
 #endif
@@ -203,10 +190,8 @@ static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_S
 
     if (value == NULL) {
         return NULL;
-#ifndef PY_NOGIL
     } else if (_PyDict_HasSplitTable(dict)) {
         return &dict->ma_values[ix];
-#endif
     } else {
         return &DK_ENTRIES(dict->ma_keys)[ix].me_value;
     }
@@ -214,7 +199,7 @@ static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_S
 #else
     // Will be written by Nuitka_PyDictLookupStr in all cases.
     PyObject **value;
-    Py_ssize_t found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
+    NUITKA_MAY_BE_UNUSED Py_ssize_t found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
     assert(found != DKIX_ERROR);
 
     return value;
@@ -283,6 +268,17 @@ extern int DICT_HAS_ITEM(PyThreadState *tstate, PyObject *dict, PyObject *key);
 // Convert to dictionary, helper for built-in "dict" mainly.
 extern PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj);
 
+// For 3.6 to 3.10, the dictionary version tag is used for caching purposes, so
+// we need to maintain it. However it's private value so we have to play a game
+// of having our own number space inside of their 64 bit numbers.
+#if PYTHON_VERSION >= 0x360 && PYTHON_VERSION <= 0x3c0
+#define _NUITKA_MAINTAIN_DICT_VERSION_TAG 1
+#endif
+
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+extern uint64_t nuitka_dict_version_tag_counter;
+#endif
+
 NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT0(PyDictObject *dict, Nuitka_StringObject *key, PyObject *value) {
     CHECK_OBJECT(value);
 
@@ -296,18 +292,25 @@ NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT0(PyDictObject *dict, Nuitka_
 #endif
 
     PyObject *old = GET_DICT_ENTRY_VALUE(entry);
+    CHECK_OBJECT_X(old);
 
-    // Values are more likely (more often) set than not set, in that case
-    // speculatively try the quickest access method.
-    if (likely(old != NULL)) {
-        Py_INCREF(value);
-        SET_DICT_ENTRY_VALUE(entry, value);
+    if (value != old) {
 
-        CHECK_OBJECT(old);
+        // Values are more likely (more often) set than not set, in that case
+        // speculatively try the quickest access method.
+        if (likely(old != NULL)) {
+            Py_INCREF(value);
+            SET_DICT_ENTRY_VALUE(entry, value);
 
-        Py_DECREF(old);
-    } else {
-        DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+            dict->ma_version_tag = nuitka_dict_version_tag_counter++;
+#endif
+            CHECK_OBJECT(old);
+
+            Py_DECREF(old);
+        } else {
+            DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
+        }
     }
 }
 
@@ -330,19 +333,29 @@ NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT_INPLACE(PyDictObject *dict,
 
     PyObject *old = GET_DICT_ENTRY_VALUE(entry);
 
-    // Values are more likely (more often) set than not set, in that case
-    // speculatively try the quickest access method.
-    if (likely(old != NULL)) {
-        SET_DICT_ENTRY_VALUE(entry, value);
+    if (old != value) {
+        // Values are more likely (more often) set than not set, in that case
+        // speculatively try the quickest access method.
+        if (likely(old != NULL)) {
+            SET_DICT_ENTRY_VALUE(entry, value);
+
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+            dict->ma_version_tag = nuitka_dict_version_tag_counter++;
+#endif
+        } else {
+            DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
+            Py_DECREF(value);
+
+            CHECK_OBJECT(value);
+        }
     } else {
-        DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
         Py_DECREF(value);
-
         CHECK_OBJECT(value);
     }
 }
 
 NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT1(PyDictObject *dict, Nuitka_StringObject *key, PyObject *value) {
+    CHECK_OBJECT(key);
     CHECK_OBJECT(value);
 
     Nuitka_DictEntryHandle entry = GET_STRING_DICT_ENTRY(dict, key);
@@ -359,16 +372,25 @@ NUITKA_MAY_BE_UNUSED static void UPDATE_STRING_DICT1(PyDictObject *dict, Nuitka_
 #endif
 
     PyObject *old = GET_DICT_ENTRY_VALUE(entry);
+    CHECK_OBJECT_X(old);
 
-    // Values are more likely (more often) set than not set, in that case
-    // speculatively try the quickest access method.
-    if (likely(old != NULL)) {
-        SET_DICT_ENTRY_VALUE(entry, value);
+    if (old != value) {
+        // Values are more likely (more often) set than not set, in that case
+        // speculatively try the quickest access method.
+        if (likely(old != NULL)) {
+            SET_DICT_ENTRY_VALUE(entry, value);
 
-        Py_DECREF(old);
-    } else {
-        DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+            dict->ma_version_tag = nuitka_dict_version_tag_counter++;
+#endif
+            Py_DECREF(old);
+        } else {
+            DICT_SET_ITEM((PyObject *)dict, (PyObject *)key, value);
 
+            Py_DECREF(value);
+            CHECK_OBJECT(value);
+        }
+    } else {
         Py_DECREF(value);
         CHECK_OBJECT(value);
     }
@@ -384,13 +406,13 @@ extern PyObject *DICT_ITEMS(PyObject *dict);
 #endif
 
 // Python3 dictionary keys, Python2 iterkeys returns dictionary keys iterator
-extern PyObject *DICT_ITERKEYS(PyObject *dict);
+extern PyObject *DICT_ITERKEYS(PyThreadState *tstate, PyObject *dict);
 
 // Python3 dictionary values, Python2 itervalues returns dictionary values iterator
-extern PyObject *DICT_ITERVALUES(PyObject *dict);
+extern PyObject *DICT_ITERVALUES(PyThreadState *tstate, PyObject *dict);
 
 // Python3 dictionary items, Python2 iteritems returns dictionary items iterator
-extern PyObject *DICT_ITERITEMS(PyObject *dict);
+extern PyObject *DICT_ITERITEMS(PyThreadState *tstate, PyObject *dict);
 
 // Python dictionary keys view
 extern PyObject *DICT_VIEWKEYS(PyObject *dict);
@@ -402,7 +424,7 @@ extern PyObject *DICT_VIEWVALUES(PyObject *dict);
 extern PyObject *DICT_VIEWITEMS(PyObject *dict);
 
 // Python dictionary copy, return a shallow copy of a dictionary.
-extern PyObject *DICT_COPY(PyObject *dict);
+extern PyObject *DICT_COPY(PyThreadState *tstate, PyObject *dict);
 
 // Python dictionary clear, empties the dictionary.
 extern void DICT_CLEAR(PyObject *dict);
@@ -410,14 +432,15 @@ extern void DICT_CLEAR(PyObject *dict);
 // Replacement for PyDict_Next that is faster (to call).
 extern bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObject **value_ptr);
 
-#if PYTHON_VERSION >= 0x3a0
+#if PYTHON_VERSION >= 0x3a0 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_FREELIST_ALL) &&                                  \
+    !defined(_NUITKA_EXPERIMENTAL_DISABLE_FREELIST_DICT)
 #define NUITKA_DICT_HAS_FREELIST 1
 
 // Replacement for PyDict_New that is faster
-extern PyObject *MAKE_DICT_EMPTY(void);
+extern PyObject *MAKE_DICT_EMPTY(PyThreadState *tstate);
 #else
 #define NUITKA_DICT_HAS_FREELIST 0
-#define MAKE_DICT_EMPTY PyDict_New
+#define MAKE_DICT_EMPTY(tstate) PyDict_New()
 #endif
 
 // Create a dictionary from key/value pairs.
@@ -428,3 +451,18 @@ extern PyObject *MAKE_DICT_X(PyObject **pairs, Py_ssize_t size);
 extern PyObject *MAKE_DICT_X_CSTR(char const **keys, PyObject **values, Py_ssize_t size);
 
 #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/floats.h

@@ -1,20 +1,5 @@
-//     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
+
 #ifndef __NUITKA_HELPER_FLOATS_H__
 #define __NUITKA_HELPER_FLOATS_H__
 
@@ -30,4 +15,18 @@ extern PyObject *MAKE_FLOAT_FROM_DOUBLE(double value);
 
 extern PyObject *TO_FLOAT(PyObject *value);
 
-#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/import_hard.h

@@ -1,20 +1,5 @@
-//     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
+
 /* WARNING, this code is GENERATED. Modify the template HelperImportHard.c.j2 instead! */
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
@@ -38,6 +23,9 @@ extern PyObject *IMPORT_HARD__FROZEN_IMPORTLIB_EXTERNAL(void);
 /* C helper for hard import of module "_io" import. */
 extern PyObject *IMPORT_HARD__IO(void);
 
+/* C helper for hard import of module "builtins" import. */
+extern PyObject *IMPORT_HARD_BUILTINS(void);
+
 /* C helper for hard import of module "ctypes" import. */
 extern PyObject *IMPORT_HARD_CTYPES(void);
 
@@ -98,6 +86,9 @@ extern PyObject *IMPORT_HARD_SYS(void);
 /* C helper for hard import of module "sysconfig" import. */
 extern PyObject *IMPORT_HARD_SYSCONFIG(void);
 
+/* C helper for hard import of module "tensorflow" import. */
+extern PyObject *IMPORT_HARD_TENSORFLOW(void);
+
 /* C helper for hard import of module "types" import. */
 extern PyObject *IMPORT_HARD_TYPES(void);
 
@@ -110,4 +101,21 @@ extern PyObject *IMPORT_HARD_TYPING(void);
 extern PyObject *IMPORT_HARD_UNITTEST(void);
 
 /* C helper for hard import of module "unittest.mock" import. */
+#if PYTHON_VERSION >= 0x300
 extern PyObject *IMPORT_HARD_UNITTEST__MOCK(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/indexes.h

@@ -1,20 +1,5 @@
-//     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
+
 #ifndef __NUITKA_HELPER_INDEXES_H__
 #define __NUITKA_HELPER_INDEXES_H__
 
@@ -45,4 +30,18 @@ extern PyObject *Nuitka_Number_IndexAsLong(PyObject *item);
 #define Nuitka_Number_IndexAsLong(item) Nuitka_Number_Index(item)
 #endif
 
-#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/ints.h

@@ -1,76 +1,123 @@
-//     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
+
 #ifndef __NUITKA_HELPER_INTS_H__
 #define __NUITKA_HELPER_INTS_H__
 
-typedef enum {
-    NUITKA_INT_UNASSIGNED = 0,
-    NUITKA_INT_OBJECT_VALID = 1,
-    NUITKA_INT_VALUE_VALID = 2,
-    NUITKA_INT_BOTH_VALID = 3
-} nuitka_int_validity;
-
-typedef struct {
-    nuitka_int_validity validity;
-
-    PyObject *int_object;
-    long int_value;
-} nuitka_int;
-
-typedef enum {
-    NUITKA_LONG_UNASSIGNED = 0,
-    NUITKA_LONG_OBJECT_VALID = 1,
-    NUITKA_LONG_VALUE_VALID = 2,
-    NUITKA_LONG_BOTH_VALID = 3
-} nuitka_long_validity;
+// Our "PyLong_FromLong" replacement.
+extern PyObject *Nuitka_PyLong_FromLong(long ival);
 
-typedef struct {
-    nuitka_long_validity validity;
+// Our "PyInt_FromLong" replacement, not done (yet?).
+#if PYTHON_VERSION >= 0x300
+#define Nuitka_PyInt_FromLong(ival) Nuitka_PyLong_FromLong(ival)
+#else
+#define Nuitka_PyInt_FromLong(ival) PyInt_FromLong(ival)
+#endif
 
-    PyObject *long_object;
-    long long_value;
-} nuitka_long;
+// We are using this mixed type for both Python2 and Python3, since then we
+// avoid the complexity of overflowed integers for Python2 to switch over.
 
-#if PYTHON_VERSION < 0x300
 typedef enum {
     NUITKA_ILONG_UNASSIGNED = 0,
     NUITKA_ILONG_OBJECT_VALID = 1,
-    NUITKA_ILONG_VALUE_VALID = 2,
-    NUITKA_ILONG_BOTH_VALID = 3
+    NUITKA_ILONG_CLONG_VALID = 2,
+    NUITKA_ILONG_BOTH_VALID = 3,
+    NUITKA_ILONG_EXCEPTION = 4
 } nuitka_ilong_validity;
 
 typedef struct {
     nuitka_ilong_validity validity;
 
-    PyObject *ilong_object;
-    long ilong_value;
+    PyObject *python_value;
+    long c_value;
 } nuitka_ilong;
 
-NUITKA_MAY_BE_UNUSED static void ENFORCE_ILONG_OBJECT_VALUE(nuitka_ilong *value) {
-    assert(value->validity != NUITKA_ILONG_UNASSIGNED);
+#define IS_NILONG_OBJECT_VALUE_VALID(value) (((value)->validity & NUITKA_ILONG_OBJECT_VALID) != 0)
+#define IS_NILONG_C_VALUE_VALID(value) (((value)->validity & NUITKA_ILONG_CLONG_VALID) != 0)
+
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_OBJECT_VALUE(nuitka_ilong *dual_value, PyObject *python_value) {
+    dual_value->validity = NUITKA_ILONG_OBJECT_VALID;
+    dual_value->python_value = python_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_C_VALUE(nuitka_ilong *dual_value, long c_value) {
+    dual_value->validity = NUITKA_ILONG_CLONG_VALID;
+    dual_value->c_value = c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void SET_NILONG_OBJECT_AND_C_VALUE(nuitka_ilong *dual_value, PyObject *python_value,
+                                                               long c_value) {
+    dual_value->validity = NUITKA_ILONG_BOTH_VALID;
+    dual_value->python_value = python_value;
+    dual_value->c_value = c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void RELEASE_NILONG_VALUE(nuitka_ilong *dual_value) {
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+        Py_DECREF(dual_value->python_value);
+    }
+
+    dual_value->validity = NUITKA_ILONG_UNASSIGNED;
+}
+
+NUITKA_MAY_BE_UNUSED static void INCREF_NILONG_VALUE(nuitka_ilong *dual_value) {
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+        Py_INCREF(dual_value->python_value);
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static long GET_NILONG_C_VALUE(nuitka_ilong const *dual_value) {
+    assert(IS_NILONG_C_VALUE_VALID(dual_value));
+    return dual_value->c_value;
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *GET_NILONG_OBJECT_VALUE(nuitka_ilong const *dual_value) {
+    assert(IS_NILONG_OBJECT_VALUE_VALID(dual_value));
+    return dual_value->python_value;
+}
+
+NUITKA_MAY_BE_UNUSED static void ENFORCE_NILONG_OBJECT_VALUE(nuitka_ilong *dual_value) {
+    assert(dual_value->validity != NUITKA_ILONG_UNASSIGNED);
 
-    if ((value->validity & NUITKA_ILONG_OBJECT_VALID) == 0) {
-        value->ilong_object = PyLong_FromLong(value->ilong_value);
+    if (!IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        dual_value->python_value = Nuitka_PyLong_FromLong(dual_value->c_value);
 
-        value->validity = NUITKA_ILONG_BOTH_VALID;
+        dual_value->validity = NUITKA_ILONG_BOTH_VALID;
     }
 }
 
+NUITKA_MAY_BE_UNUSED static void CHECK_NILONG_OBJECT(nuitka_ilong const *dual_value) {
+    assert(dual_value->validity != NUITKA_ILONG_UNASSIGNED);
+
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        CHECK_OBJECT(dual_value);
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static void PRINT_NILONG(nuitka_ilong const *dual_value) {
+    PRINT_FORMAT("NILONG: %d", dual_value->validity);
+    if (IS_NILONG_C_VALUE_VALID(dual_value)) {
+        PRINT_FORMAT("C=%d", dual_value->c_value);
+    }
+    if (IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        PRINT_STRING("Python=");
+        PRINT_ITEM(dual_value->python_value);
+    }
+}
+
+#if PYTHON_VERSION < 0x3c0
+// Convert single digit to sdigit (int32_t),
+// spell-checker: ignore sdigit,stwodigits
+typedef long medium_result_value_t;
+#define MEDIUM_VALUE(x)                                                                                                \
+    (Py_SIZE(x) < 0 ? -(sdigit)((PyLongObject *)(x))->ob_digit[0]                                                      \
+                    : (Py_SIZE(x) == 0 ? (sdigit)0 : (sdigit)((PyLongObject *)(x))->ob_digit[0]))
+
+#else
+typedef stwodigits medium_result_value_t;
+#define MEDIUM_VALUE(x) ((stwodigits)_PyLong_CompactValue((PyLongObject *)x))
+
 #endif
 
 // TODO: Use this from header files, although they have changed.
@@ -96,9 +143,23 @@ NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(int ival)
 #endif
 
 #else
-NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(int ival) {
+NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(medium_result_value_t ival) {
     return (PyObject *)&_PyLong_SMALL_INTS[NUITKA_TO_SMALL_VALUE_OFFSET(ival)];
 }
 #endif
 
-#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.