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

nuitka/build/static_src/HelpersLists.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 helpers is used to work with lists.
 
 */
@@ -29,23 +14,65 @@
 
 static PyObject *Nuitka_LongFromCLong(long ival);
 
-#if NUITKA_LIST_HAS_FREELIST
-static struct _Py_list_state *_Nuitka_Py_get_list_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->list;
+#ifdef Py_GIL_DISABLED
+typedef struct {
+    Py_ssize_t allocated;
+    PyObject *ob_item[];
+} _PyListArray;
+
+static _PyListArray *Nuitka_AllocateListArray(size_t capacity) {
+    if (unlikely(capacity > PY_SSIZE_T_MAX / sizeof(PyObject *) - 1)) {
+        return NULL;
+    }
+
+    _PyListArray *list_array = PyMem_Malloc(sizeof(_PyListArray) + capacity * sizeof(PyObject *));
+
+    if (unlikely(list_array == NULL)) {
+        return NULL;
+    }
+
+    list_array->allocated = capacity;
+    return list_array;
 }
 
-PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
+// spell-checker: ignore use_qsbr
+static void Nuitka_FreeListArray(PyObject **items, bool use_qsbr) {
+    _PyListArray *array = _Py_CONTAINER_OF(items, _PyListArray, ob_item);
+
+    if (use_qsbr) {
+        NuitkaMem_FreeDelayed(array);
+    } else {
+        NuitkaMem_Free(array);
+    }
+}
+
+#endif
+
+#if NUITKA_LIST_HAS_FREELIST
+
+PyObject *MAKE_LIST_EMPTY(PyThreadState *tstate, Py_ssize_t size) {
     assert(size >= 0);
 
-    struct _Py_list_state *state = _Nuitka_Py_get_list_state();
-    PyListObject *result_list;
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+    return PyList_New(size);
+#else
+    // This is the CPython name, spell-checker: ignore numfree
 
-    assert(state->numfree >= 0);
+#if PYTHON_VERSION < 0x3d0
+    PyListObject **items = tstate->interp->list.free_list;
+    int *numfree = &tstate->interp->list.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_list_freelist *state = &freelists->lists;
+    PyListObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+    assert(*numfree >= 0);
+    PyListObject *result_list;
 
-    if (state->numfree) {
-        state->numfree -= 1;
-        result_list = state->free_list[state->numfree];
+    if (*numfree) {
+        (*numfree) -= 1;
+        result_list = items[*numfree];
 
         Nuitka_Py_NewReference((PyObject *)result_list);
     } else {
@@ -54,12 +81,21 @@ PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
 
     // Elements are allocated separately.
     if (size > 0) {
-        result_list->ob_item = (PyObject **)PyMem_Calloc(size, sizeof(PyObject *));
+#ifdef Py_GIL_DISABLED
+        _PyListArray *list_array = Nuitka_AllocateListArray(size);
+
+        if (unlikely(list_array == NULL)) {
+            Py_DECREF(result_list);
+            return PyErr_NoMemory();
+        }
+#else
+        result_list->ob_item = (PyObject **)NuitkaMem_Calloc(size, sizeof(PyObject *));
 
         if (unlikely(result_list->ob_item == NULL)) {
             Py_DECREF(result_list);
             return PyErr_NoMemory();
         }
+#endif
     } else {
         result_list->ob_item = NULL;
     }
@@ -70,15 +106,16 @@ PyObject *MAKE_LIST_EMPTY(Py_ssize_t size) {
     Nuitka_GC_Track(result_list);
 
     return (PyObject *)result_list;
+#endif
 }
 #endif
 
-PyObject *LIST_COPY(PyObject *list) {
+PyObject *LIST_COPY(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
 
     Py_ssize_t size = PyList_GET_SIZE(list);
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -93,34 +130,67 @@ PyObject *LIST_COPY(PyObject *list) {
     return result;
 }
 
-static bool LIST_RESIZE(PyListObject *list, Py_ssize_t newsize) {
+static bool LIST_RESIZE(PyListObject *list, Py_ssize_t new_size) {
+    CHECK_OBJECT(list);
+    assert(new_size >= 0);
+
     Py_ssize_t allocated = list->allocated;
 
-    if (allocated >= newsize && newsize >= (allocated >> 1)) {
-        Py_SET_SIZE(list, newsize);
+    if (allocated >= new_size && new_size >= (allocated >> 1)) {
+        Py_SET_SIZE(list, new_size);
 
         return true;
     }
 
     size_t new_allocated;
 
-    if (newsize == 0) {
+    if (new_size == 0) {
         new_allocated = 0;
     } else {
-        new_allocated = ((size_t)newsize + (newsize >> 3) + 6) & ~(size_t)3;
+        new_allocated = ((size_t)new_size + (new_size >> 3) + 6) & ~(size_t)3;
+        assert(new_allocated >= (size_t)new_size);
     }
 
+#ifdef Py_GIL_DISABLED
+    _PyListArray *array = Nuitka_AllocateListArray(new_allocated);
+
+    if (array == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    PyObject **old_items = list->ob_item;
+    if (list->ob_item != NULL) {
+        size_t num_allocated_bytes;
+        if (new_allocated < (size_t)allocated) {
+            num_allocated_bytes = new_allocated * sizeof(PyObject *);
+        } else {
+            num_allocated_bytes = allocated * sizeof(PyObject *);
+        }
+        memcpy(array->ob_item, list->ob_item, num_allocated_bytes);
+    }
+    if (new_allocated > (size_t)allocated) {
+        memset(array->ob_item + allocated, 0, sizeof(PyObject *) * (new_allocated - allocated));
+    }
+    _Py_atomic_store_ptr_release(&list->ob_item, &array->ob_item);
+    list->allocated = new_allocated;
+    Py_SET_SIZE(list, new_size);
+    if (old_items != NULL) {
+        Nuitka_FreeListArray(old_items, _PyObject_GC_IS_SHARED(list));
+    }
+#else
     size_t num_allocated_bytes = new_allocated * sizeof(PyObject *);
 
-    PyObject **items = (PyObject **)PyMem_Realloc(list->ob_item, num_allocated_bytes);
+    // TODO: For Python3.13 No-GIL this is different code
+    PyObject **items = (PyObject **)NuitkaMem_Realloc(list->ob_item, num_allocated_bytes);
     if (unlikely(items == NULL)) {
         PyErr_NoMemory();
         return false;
     }
 
     list->ob_item = items;
-    Py_SET_SIZE(list, newsize);
+    Py_SET_SIZE(list, new_size);
     list->allocated = new_allocated;
+#endif
 
     return true;
 }
@@ -233,7 +303,7 @@ bool LIST_EXTEND_FROM_ITERABLE(PyThreadState *tstate, PyObject *target, PyObject
 
     Py_ssize_t cur_size = PyList_GET_SIZE(list);
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     // Guess a iterator size if possible
     src_size = PyObject_LengthHint(other, 8);
 
@@ -322,6 +392,8 @@ bool LIST_EXTEND_FOR_UNPACK(PyThreadState *tstate, PyObject *list, PyObject *oth
 
     PyObject *error = GET_ERROR_OCCURRED(tstate);
 
+    assert(error != NULL);
+
     if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_TypeError) &&
         (Py_TYPE(other)->tp_iter == NULL && !PySequence_Check(other))) {
         CLEAR_ERROR_OCCURRED(tstate);
@@ -333,16 +405,16 @@ bool LIST_EXTEND_FOR_UNPACK(PyThreadState *tstate, PyObject *list, PyObject *oth
 #endif
 
 bool LIST_APPEND1(PyObject *target, PyObject *item) {
-#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
-    int res = PyList_Append(target, item);
-    Py_DECREF(item);
-    return res == 0;
-#else
     CHECK_OBJECT(target);
     assert(PyList_CheckExact(target));
 
     CHECK_OBJECT(item);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+    int res = PyList_Append(target, item);
+    Py_DECREF(item);
+    return res == 0;
+#else
     PyListObject *list = (PyListObject *)target;
 
     Py_ssize_t cur_size = PyList_GET_SIZE(list);
@@ -361,15 +433,15 @@ bool LIST_APPEND1(PyObject *target, PyObject *item) {
 }
 
 bool LIST_APPEND0(PyObject *target, PyObject *item) {
-#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
-    int res = PyList_Append(target, item);
-    return res == 0;
-#else
     CHECK_OBJECT(target);
     assert(PyList_CheckExact(target));
 
     CHECK_OBJECT(item);
 
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
+    int res = PyList_Append(target, item);
+    return res == 0;
+#else
     PyListObject *list = (PyListObject *)target;
 
     Py_ssize_t cur_size = PyList_GET_SIZE(list);
@@ -387,6 +459,47 @@ bool LIST_APPEND0(PyObject *target, PyObject *item) {
 #endif
 }
 
+bool LIST_REMOVE(PyObject *target, PyObject *item) {
+    CHECK_OBJECT(target);
+    assert(PyList_CheckExact(target));
+
+    CHECK_OBJECT(item);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT && 0
+    // TODO: This is not exposed, would need to delete as slice instead.
+    int res = PyList_Remove(target, item);
+    return res == 0;
+#else
+    PyListObject *list = (PyListObject *)target;
+
+    Py_ssize_t cur_size = PyList_GET_SIZE(list);
+
+    for (Py_ssize_t i = 0; i < cur_size; i++) {
+        PyObject *element = list->ob_item[i];
+
+        Py_INCREF(element);
+        nuitka_bool cmp = RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(element, item);
+        Py_DECREF(element);
+
+        if (cmp == NUITKA_BOOL_TRUE) {
+            Py_DECREF(element);
+            Py_SET_SIZE(list, cur_size - 1);
+
+            memmove(list->ob_item + i, list->ob_item + i + 1, sizeof(PyObject *) * (cur_size - i - 1));
+
+            return true;
+        } else if (unlikely(cmp == NUITKA_BOOL_EXCEPTION)) {
+            return false;
+        }
+    }
+
+    PyThreadState *tstate = PyThreadState_GET();
+
+    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_ValueError, "list.remove(x): x not in list");
+    return false;
+#endif
+}
+
 void LIST_CLEAR(PyObject *target) {
     CHECK_OBJECT(target);
     assert(PyList_CheckExact(target));
@@ -494,7 +607,7 @@ static PyObject *_LIST_INDEX_COMMON(PyThreadState *tstate, PyListObject *list, P
 
 #if PYTHON_VERSION < 0x300
     PyObject *err_format = PyString_FromString("%r is not in list");
-    PyObject *format_tuple = MAKE_TUPLE1_0(item);
+    PyObject *format_tuple = MAKE_TUPLE1_0(tstate, item);
     PyObject *err_string = PyString_Format(err_format, format_tuple);
     Py_DECREF(format_tuple);
 
@@ -532,7 +645,18 @@ PyObject *LIST_INDEX3(PyThreadState *tstate, PyObject *list, PyObject *item, PyO
         return NULL;
     }
 
-    Py_ssize_t start_ssize = PyLong_AsSsize_t(start_index);
+    Py_ssize_t start_ssize;
+#if PYTHON_VERSION < 0x300
+    if (PyInt_CheckExact(start_index)) {
+        start_ssize = PyInt_AS_LONG(start_index);
+    } else {
+        start_ssize = PyLong_AsSsize_t(start_index);
+    }
+#else
+    start_ssize = PyLong_AsSsize_t(start_index);
+#endif
+
+    Py_DECREF(start_index);
 
     return _LIST_INDEX_COMMON(tstate, (PyListObject *)list, item, start_ssize, Py_SIZE(list));
 }
@@ -551,11 +675,24 @@ PyObject *LIST_INDEX4(PyThreadState *tstate, PyObject *list, PyObject *item, PyO
         return NULL;
     }
 
-    Py_ssize_t start_ssize = PyLong_AsSsize_t(start_index);
+    Py_ssize_t start_ssize;
+#if PYTHON_VERSION < 0x300
+    if (PyInt_CheckExact(start_index)) {
+        start_ssize = PyInt_AS_LONG(start_index);
+    } else {
+        start_ssize = PyLong_AsSsize_t(start_index);
+    }
+#else
+    start_ssize = PyLong_AsSsize_t(start_index);
+#endif
+
+    Py_DECREF(start_index);
 
     PyObject *stop_index = Nuitka_Number_IndexAsLong(stop);
 
     if (unlikely(stop_index == NULL)) {
+        Py_DECREF(start_index);
+
         CLEAR_ERROR_OCCURRED(tstate);
 
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
@@ -563,7 +700,18 @@ PyObject *LIST_INDEX4(PyThreadState *tstate, PyObject *list, PyObject *item, PyO
         return NULL;
     }
 
-    Py_ssize_t stop_ssize = PyLong_AsSsize_t(stop_index);
+    Py_ssize_t stop_ssize;
+#if PYTHON_VERSION < 0x300
+    if (PyInt_CheckExact(stop_index)) {
+        stop_ssize = PyInt_AS_LONG(stop_index);
+    } else {
+        stop_ssize = PyLong_AsSsize_t(stop_index);
+    }
+#else
+    stop_ssize = PyLong_AsSsize_t(stop_index);
+#endif
+
+    Py_DECREF(stop_index);
 
     return _LIST_INDEX_COMMON(tstate, (PyListObject *)list, item, start_ssize, stop_ssize);
 }
@@ -571,6 +719,7 @@ PyObject *LIST_INDEX4(PyThreadState *tstate, PyObject *list, PyObject *item, PyO
 bool LIST_INSERT(PyThreadState *tstate, PyObject *list, PyObject *index, PyObject *item) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
+    CHECK_OBJECT(index);
     CHECK_OBJECT(item);
 
     // TODO: Avoid the clear, by having this as a variant that doesn't set the
@@ -584,7 +733,18 @@ bool LIST_INSERT(PyThreadState *tstate, PyObject *list, PyObject *index, PyObjec
         return false;
     }
 
-    Py_ssize_t index_ssize = PyLong_AsSsize_t(index_long);
+    Py_ssize_t index_ssize;
+#if PYTHON_VERSION < 0x300
+    if (PyInt_CheckExact(index_long)) {
+        index_ssize = PyInt_AS_LONG(index_long);
+    } else {
+        index_ssize = PyLong_AsSsize_t(index_long);
+    }
+#else
+    index_ssize = PyLong_AsSsize_t(index_long);
+#endif
+
+    Py_DECREF(index_long);
 
     LIST_INSERT_CONST(list, index_ssize, item);
     return true;
@@ -654,7 +814,7 @@ void LIST_REVERSE(PyObject *list) {
     }
 }
 
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT)
 static bool allocateListItems(PyListObject *list, Py_ssize_t size) {
     PyObject **items = PyMem_New(PyObject *, size);
 
@@ -668,12 +828,13 @@ static bool allocateListItems(PyListObject *list, Py_ssize_t size) {
 
     return true;
 }
+
 #endif
 
 PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
     // Can leave the size hinting to later functions, because the list is allocated empty without
     // items, and when then extending, etc. length hints can be used.
-    PyObject *list = MAKE_LIST_EMPTY(0);
+    PyObject *list = MAKE_LIST_EMPTY(tstate, 0);
 
 #if _NUITKA_EXPERIMENTAL_DISABLE_LIST_OPT
     PyObject *result = _PyList_Extend((PyListObject *)list, iterable);
@@ -685,8 +846,10 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
         return list;
     }
 #else
-#if PYTHON_VERSION >= 0x340
-    if (_PyObject_HasLen(iterable)) {
+    Py_INCREF(iterable);
+
+#if PYTHON_VERSION >= 0x300
+    if (Nuitka_PyObject_HasLen(iterable)) {
         Py_ssize_t iter_len = Nuitka_PyObject_Size(iterable);
 
         if (unlikely(iter_len == -1)) {
@@ -707,6 +870,8 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
 
     bool res = LIST_EXTEND_FROM_ITERABLE(tstate, list, iterable);
 
+    Py_DECREF(iterable);
+
     if (unlikely(res == false)) {
         Py_DECREF(list);
         return NULL;
@@ -716,4 +881,18 @@ PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable) {
 #endif
 }
 
-#include "HelpersListsGenerated.c"
+#include "HelpersListsGenerated.c"
+//     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/HelpersListsGenerated.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
+
 /* WARNING, this code is GENERATED. Modify the template CodeTemplateMakeListSmall.c.j2 instead! */
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
@@ -22,9 +7,9 @@
 #include "nuitka/prelude.h"
 #endif
 
-PyObject *MAKE_LIST1(PyObject *arg0) {
+PyObject *MAKE_LIST1(PyThreadState *tstate, PyObject *arg0) {
 
-    PyObject *result = MAKE_LIST_EMPTY(1);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 1);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -36,9 +21,9 @@ PyObject *MAKE_LIST1(PyObject *arg0) {
 
     return result;
 }
-PyObject *MAKE_LIST2(PyObject *arg0, PyObject *arg1) {
+PyObject *MAKE_LIST2(PyThreadState *tstate, PyObject *arg0, PyObject *arg1) {
 
-    PyObject *result = MAKE_LIST_EMPTY(2);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 2);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -54,9 +39,9 @@ PyObject *MAKE_LIST2(PyObject *arg0, PyObject *arg1) {
 
     return result;
 }
-PyObject *MAKE_LIST3(PyObject *arg0, PyObject *arg1, PyObject *arg2) {
+PyObject *MAKE_LIST3(PyThreadState *tstate, PyObject *arg0, PyObject *arg1, PyObject *arg2) {
 
-    PyObject *result = MAKE_LIST_EMPTY(3);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 3);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -76,12 +61,12 @@ PyObject *MAKE_LIST3(PyObject *arg0, PyObject *arg1, PyObject *arg2) {
 
     return result;
 }
-PyObject *MAKE_LIST4(PyObject *list) {
+PyObject *MAKE_LIST4(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 4);
 
-    PyObject *result = MAKE_LIST_EMPTY(4);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 4);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -110,12 +95,12 @@ PyObject *MAKE_LIST4(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST5(PyObject *list) {
+PyObject *MAKE_LIST5(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 5);
 
-    PyObject *result = MAKE_LIST_EMPTY(5);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 5);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -149,12 +134,12 @@ PyObject *MAKE_LIST5(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST6(PyObject *list) {
+PyObject *MAKE_LIST6(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 6);
 
-    PyObject *result = MAKE_LIST_EMPTY(6);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 6);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -193,12 +178,12 @@ PyObject *MAKE_LIST6(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST7(PyObject *list) {
+PyObject *MAKE_LIST7(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 7);
 
-    PyObject *result = MAKE_LIST_EMPTY(7);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 7);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -242,12 +227,12 @@ PyObject *MAKE_LIST7(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST8(PyObject *list) {
+PyObject *MAKE_LIST8(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 8);
 
-    PyObject *result = MAKE_LIST_EMPTY(8);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 8);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -296,12 +281,12 @@ PyObject *MAKE_LIST8(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST9(PyObject *list) {
+PyObject *MAKE_LIST9(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 9);
 
-    PyObject *result = MAKE_LIST_EMPTY(9);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 9);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -355,12 +340,12 @@ PyObject *MAKE_LIST9(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST10(PyObject *list) {
+PyObject *MAKE_LIST10(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 10);
 
-    PyObject *result = MAKE_LIST_EMPTY(10);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 10);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -419,12 +404,12 @@ PyObject *MAKE_LIST10(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST11(PyObject *list) {
+PyObject *MAKE_LIST11(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 11);
 
-    PyObject *result = MAKE_LIST_EMPTY(11);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 11);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -488,12 +473,12 @@ PyObject *MAKE_LIST11(PyObject *list) {
 
     return result;
 }
-PyObject *MAKE_LIST12(PyObject *list) {
+PyObject *MAKE_LIST12(PyThreadState *tstate, PyObject *list) {
     CHECK_OBJECT(list);
     assert(PyList_CheckExact(list));
     assert(PyList_GET_SIZE(list) == 12);
 
-    PyObject *result = MAKE_LIST_EMPTY(12);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, 12);
 
     if (unlikely(result == NULL)) {
         return NULL;
@@ -562,3 +547,18 @@ PyObject *MAKE_LIST12(PyObject *list) {
 
     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.