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

nuitka/build/static_src/HelpersDeepcopy.c

@@ -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
+
 /**
  * This is responsible for deep copy and hashing of constants.
  */
@@ -41,7 +26,7 @@ PyObject *DEEP_COPY_LIST(PyThreadState *tstate, PyObject *value) {
     assert(PyList_CheckExact(value));
 
     Py_ssize_t n = PyList_GET_SIZE(value);
-    PyObject *result = MAKE_LIST_EMPTY(n);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, n);
 
     PyTypeObject *type = NULL;
     copy_func copy_function = NULL;
@@ -76,7 +61,7 @@ PyObject *DEEP_COPY_TUPLE(PyThreadState *tstate, PyObject *value) {
 
     Py_ssize_t n = PyTuple_GET_SIZE(value);
 
-    PyObject *result = MAKE_TUPLE_EMPTY_VAR(n);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, n);
 
     for (Py_ssize_t i = 0; i < n; i++) {
         PyTuple_SET_ITEM(result, i, DEEP_COPY(tstate, PyTuple_GET_ITEM(value, i)));
@@ -161,8 +146,10 @@ static void _initDeepCopy(void) {
 
 #if PYTHON_VERSION >= 0x3a0
     {
+        PyThreadState *tstate = PyThreadState_GET();
+
         PyObject *args[2] = {(PyObject *)&PyFloat_Type, (PyObject *)&PyTuple_Type};
-        PyObject *args_tuple = MAKE_TUPLE(args, 2);
+        PyObject *args_tuple = MAKE_TUPLE(tstate, args, 2);
         PyObject *union_value = MAKE_UNION_TYPE(args_tuple);
 
         Nuitka_PyUnion_Type = Py_TYPE(union_value);
@@ -376,10 +363,9 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
     } else if (PyLong_Check(value)) {
         Py_hash_t result = DEEP_HASH_INIT(tstate, value);
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         // Use string to hash the long value, which relies on that to not
         // use the object address.
@@ -387,16 +373,15 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
         result ^= DEEP_HASH(tstate, str);
         Py_DECREF(str);
 
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     } else if (PyUnicode_Check(value)) {
         Py_hash_t result = DEEP_HASH(tstate, (PyObject *)Py_TYPE(value));
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
 #if PYTHON_VERSION >= 0x300
         char const *s = (char const *)PyUnicode_DATA(value);
@@ -412,7 +397,7 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
 
         Py_DECREF(str);
 #endif
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     }
@@ -566,15 +551,15 @@ static PyObject *_DEEP_COPY_ELEMENT_GUIDED(PyThreadState *tstate, PyObject *valu
     case 'L':
         return _DEEP_COPY_LIST_GUIDED(tstate, value, guide);
     case 'l':
-        return LIST_COPY(value);
+        return LIST_COPY(tstate, value);
     case 'T':
         return _DEEP_COPY_TUPLE_GUIDED(tstate, value, guide);
     case 't':
-        return TUPLE_COPY(value);
+        return TUPLE_COPY(tstate, value);
     case 'D':
         return DEEP_COPY_DICT(tstate, value);
     case 'd':
-        return DICT_COPY(value);
+        return DICT_COPY(tstate, value);
     case 'S':
         return DEEP_COPY_SET(tstate, value);
     case 'B':
@@ -592,7 +577,7 @@ static PyObject *_DEEP_COPY_LIST_GUIDED(PyThreadState *tstate, PyObject *value,
 
     Py_ssize_t size = PyList_GET_SIZE(value);
 
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         PyObject *item = _DEEP_COPY_ELEMENT_GUIDED(tstate, PyList_GET_ITEM(value, i), guide);
@@ -609,7 +594,7 @@ static PyObject *_DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value,
     Py_ssize_t size = PyTuple_GET_SIZE(value);
 
     // We cannot have size 0, so this is safe.
-    PyObject *result = MAKE_TUPLE_EMPTY(size);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         PyObject *item = _DEEP_COPY_ELEMENT_GUIDED(tstate, PyTuple_GET_ITEM(value, i), guide);
@@ -631,3 +616,18 @@ PyObject *DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value, char co
     assert(*guide == 0);
     return result;
 }
+
+//     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/static_src/HelpersDictionaries.c

@@ -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
+
 /* These helpers are used to work with dictionaries.
 
 */
@@ -200,6 +185,12 @@ PyObject *DICT_GET_ITEM1(PyThreadState *tstate, PyObject *dict, PyObject *key) {
 #endif
 }
 
+#if PYTHON_VERSION >= 0x3c0
+static PyObject *Nuitka_CreateKeyError(PyThreadState *tstate, PyObject *key) {
+    return (PyObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_KeyError, key);
+}
+#endif
+
 static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key) {
 #if PYTHON_VERSION < 0x3c0
     /* Wrap all kinds of tuples, because normalization will later unwrap
@@ -214,7 +205,9 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
         SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_KeyError, key);
     }
 #else
-    return _MAKE_EXCEPTION_FROM_TYPE_ARG(PyExc_KeyError, key);
+    struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateKeyError(tstate, key)};
+
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
 #endif
 }
 
@@ -581,6 +574,15 @@ int DICT_HAS_ITEM(PyThreadState *tstate, PyObject *dict, PyObject *key) {
 
         return 0;
     }
+
+#if PYTHON_VERSION < 0x370 || PYTHON_VERSION >= 0x3b0
+    assert(value_addr != NULL);
+    PyObject *result = *value_addr;
+#endif
+
+    if (unlikely(result == NULL)) {
+        return 0;
+    }
 #endif
     return 1;
 #endif
@@ -602,12 +604,12 @@ PyObject *DICT_ITEMS(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         // Later populated.
-        PyObject *item = MAKE_TUPLE_EMPTY(2);
+        PyObject *item = MAKE_TUPLE_EMPTY(tstate, 2);
         CHECK_OBJECT(item);
 
         PyList_SET_ITEM(result, i, item);
@@ -656,7 +658,7 @@ PyObject *DICT_KEYS(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     if (unlikely(size != mp->ma_used)) {
@@ -701,7 +703,7 @@ PyObject *DICT_VALUES(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     if (unlikely(size != mp->ma_used)) {
@@ -1307,9 +1309,9 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
 
         // Fast path for dictionaries.
         if (PyDict_CheckExact(seq_obj)) {
-            result = DICT_COPY(seq_obj);
+            result = DICT_COPY(tstate, seq_obj);
         } else {
-            result = MAKE_DICT_EMPTY();
+            result = MAKE_DICT_EMPTY(tstate);
 
             Py_INCREF(seq_obj);
 
@@ -1337,7 +1339,7 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
             }
         }
     } else {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     }
 
     // TODO: Should specialize for dict_obj/seq_obj presence to save a bit of time
@@ -1356,19 +1358,24 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
 }
 
 #if NUITKA_DICT_HAS_FREELIST
-PyObject *MAKE_DICT_EMPTY(void) {
+PyObject *MAKE_DICT_EMPTY(PyThreadState *tstate) {
     PyDictObject *empty_dict_mp = (PyDictObject *)const_dict_empty;
 
+#if PYTHON_VERSION < 0x3c0
     empty_dict_mp->ma_keys->dk_refcnt++;
+#endif
 
-    PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+    PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
 
     result_mp->ma_keys = empty_dict_mp->ma_keys;
     result_mp->ma_values = empty_dict_mp->ma_values;
     result_mp->ma_used = 0;
+#if PYTHON_VERSION >= 0x3c0
+    result_mp->ma_version_tag = DICT_NEXT_VERSION(_PyInterpreterState_GET());
+#endif
 
-    // Key reference needs to be counted.
-#ifdef Py_REF_DEBUG
+    // Key reference needs to be counted on older Python
+#if defined(Py_REF_DEBUG) && PYTHON_VERSION < 0x3c0
     _Py_RefTotal++;
 #endif
 
@@ -1444,3 +1451,18 @@ PyObject *MAKE_DICT_X_CSTR(char const **keys, PyObject **values, Py_ssize_t size
 
     return result;
 }
+
+//     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.