Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/include/nuitka/helper/ints.h

@@ -0,0 +1,165 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_INTS_H__
+#define __NUITKA_HELPER_INTS_H__
+
+// Our "PyLong_FromLong" replacement.
+extern PyObject *Nuitka_PyLong_FromLong(long ival);
+
+// 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
+
+// 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.
+
+typedef enum {
+    NUITKA_ILONG_UNASSIGNED = 0,
+    NUITKA_ILONG_OBJECT_VALID = 1,
+    NUITKA_ILONG_CLONG_VALID = 2,
+    NUITKA_ILONG_BOTH_VALID = 3,
+    NUITKA_ILONG_EXCEPTION = 4
+} nuitka_ilong_validity;
+
+typedef struct {
+    nuitka_ilong_validity validity;
+
+    PyObject *python_value;
+    long c_value;
+} nuitka_ilong;
+
+#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 (!IS_NILONG_OBJECT_VALUE_VALID(dual_value)) {
+        dual_value->python_value = Nuitka_PyLong_FromLong(dual_value->c_value);
+
+        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.
+#define NUITKA_STATIC_SMALLINT_VALUE_MIN -5
+#define NUITKA_STATIC_SMALLINT_VALUE_MAX 257
+
+#define NUITKA_TO_SMALL_VALUE_OFFSET(value) (value - NUITKA_STATIC_SMALLINT_VALUE_MIN)
+
+#if PYTHON_VERSION < 0x3b0
+
+#if PYTHON_VERSION >= 0x300
+
+#if PYTHON_VERSION >= 0x390
+extern PyObject **Nuitka_Long_SmallValues;
+#else
+extern PyObject *Nuitka_Long_SmallValues[NUITKA_STATIC_SMALLINT_VALUE_MAX - NUITKA_STATIC_SMALLINT_VALUE_MIN + 1];
+#endif
+
+NUITKA_MAY_BE_UNUSED static inline PyObject *Nuitka_Long_GetSmallValue(int ival) {
+    return Nuitka_Long_SmallValues[NUITKA_TO_SMALL_VALUE_OFFSET(ival)];
+}
+
+#endif
+
+#else
+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
+//     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/iterators.h

@@ -0,0 +1,376 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_ITERATORS_H__
+#define __NUITKA_HELPER_ITERATORS_H__
+
+#if PYTHON_VERSION >= 0x270
+// Initialize value for "tp_iternext" to compare with, needed by HAS_ITERNEXT
+// which emulates "PyCheck_Iter" but is bug free.
+extern iternextfunc default_iternext;
+extern void _initSlotIterNext(void);
+#endif
+
+// This is like "PyIter_Check" but without bugs due to shared library pointers.
+NUITKA_MAY_BE_UNUSED static inline bool HAS_ITERNEXT(PyObject *value) {
+#if PYTHON_VERSION < 0x300
+    if (!PyType_HasFeature(Py_TYPE(value), Py_TPFLAGS_HAVE_ITER)) {
+        return false;
+    }
+#endif
+
+    iternextfunc tp_iternext = Py_TYPE(value)->tp_iternext;
+
+    if (tp_iternext == NULL) {
+        return false;
+    }
+
+#if PYTHON_VERSION >= 0x270
+    return tp_iternext != default_iternext;
+#else
+    return true;
+#endif
+}
+
+// Taken from CPython implementation, so we can access and create it, needs to match
+// their definition exactly. spell-checker: ignore seqiterobject
+typedef struct {
+    PyObject_HEAD
+#if PYTHON_VERSION < 0x300
+        long it_index;
+#else
+        Py_ssize_t it_index;
+#endif
+    PyObject *it_seq;
+} seqiterobject;
+
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_ITERATOR_INFALLIBLE(PyObject *iterated) {
+    CHECK_OBJECT(iterated);
+
+#if PYTHON_VERSION < 0x300
+    getiterfunc tp_iter = NULL;
+    if (PyType_HasFeature(Py_TYPE(iterated), Py_TPFLAGS_HAVE_ITER)) {
+        tp_iter = Py_TYPE(iterated)->tp_iter;
+    }
+#else
+    getiterfunc tp_iter = Py_TYPE(iterated)->tp_iter;
+#endif
+    if (tp_iter) {
+        PyObject *result = (*tp_iter)(iterated);
+        CHECK_OBJECT(result);
+        assert(HAS_ITERNEXT(result));
+
+        return result;
+    } else {
+        assert(PySequence_Check(iterated));
+
+        seqiterobject *result = (seqiterobject *)Nuitka_GC_New(&PySeqIter_Type);
+        assert(result);
+
+        result->it_index = 0;
+        Py_INCREF(iterated);
+        result->it_seq = iterated;
+
+        Nuitka_GC_Track(result);
+
+        return (PyObject *)result;
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_ITERATOR(PyThreadState *tstate, PyObject *iterated) {
+    CHECK_OBJECT(iterated);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyObject_GetIter(iterated);
+#else
+
+#if PYTHON_VERSION < 0x300
+    getiterfunc tp_iter = NULL;
+    if (PyType_HasFeature(Py_TYPE(iterated), Py_TPFLAGS_HAVE_ITER)) {
+        tp_iter = Py_TYPE(iterated)->tp_iter;
+    }
+#else
+    getiterfunc tp_iter = Py_TYPE(iterated)->tp_iter;
+#endif
+
+    if (tp_iter) {
+        PyObject *result = (*tp_iter)(iterated);
+
+        if (unlikely(result == NULL)) {
+            return NULL;
+        } else if (unlikely(!HAS_ITERNEXT(result))) {
+            SET_CURRENT_EXCEPTION_TYPE_COMPLAINT("iter() returned non-iterator of type '%s'", result);
+
+            Py_DECREF(result);
+
+            return NULL;
+        } else {
+            return result;
+        }
+    } else if (PySequence_Check(iterated)) {
+        seqiterobject *result = (seqiterobject *)Nuitka_GC_New(&PySeqIter_Type);
+        assert(result);
+
+        result->it_index = 0;
+        Py_INCREF(iterated);
+        result->it_seq = iterated;
+
+        Nuitka_GC_Track(result);
+
+        return (PyObject *)result;
+    } else {
+        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT("'%s' object is not iterable", iterated);
+
+        return NULL;
+    }
+#endif
+}
+
+#if PYTHON_VERSION >= 0x370
+
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_UNPACK_ITERATOR(PyObject *iterated) {
+    CHECK_OBJECT(iterated);
+
+    getiterfunc tp_iter = Py_TYPE(iterated)->tp_iter;
+
+    if (tp_iter) {
+        PyObject *result = (*tp_iter)(iterated);
+
+        if (unlikely(result == NULL)) {
+            return NULL;
+        } else if (unlikely(!HAS_ITERNEXT(result))) {
+            PyErr_Format(PyExc_TypeError, "iter() returned non-iterator of type '%s'", Py_TYPE(result)->tp_name);
+
+            Py_DECREF(result);
+
+            return NULL;
+        } else {
+            return result;
+        }
+    } else if (PySequence_Check(iterated)) {
+        seqiterobject *result = (seqiterobject *)Nuitka_GC_New(&PySeqIter_Type);
+        assert(result);
+
+        result->it_index = 0;
+        Py_INCREF(iterated);
+        result->it_seq = iterated;
+
+        Nuitka_GC_Track(result);
+
+        return (PyObject *)result;
+    } else {
+        PyErr_Format(PyExc_TypeError, "cannot unpack non-iterable %s object", Py_TYPE(iterated)->tp_name);
+
+        return NULL;
+    }
+}
+
+#endif
+
+NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT_ITERATOR(PyObject *iterator) {
+    CHECK_OBJECT(iterator);
+    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+    assert(iternext != NULL);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyIter_Next(iterator);
+#else
+    PyObject *result = (*iternext)(iterator);
+    CHECK_OBJECT_X(result);
+    return result;
+#endif
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *ITERATOR_NEXT(PyObject *iterator) {
+    CHECK_OBJECT(iterator);
+
+#if _NUITKA_EXPERIMENTAL_DISABLE_ITERATOR_OPT
+    return PyIter_Next(iterator);
+#else
+    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+
+    if (unlikely(iternext == NULL)) {
+        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT(
+#if PYTHON_VERSION < 0x300 && defined(_NUITKA_FULL_COMPAT)
+            "%s object is not an iterator",
+#else
+            "'%s' object is not an iterator",
+#endif
+            iterator);
+
+        return NULL;
+    }
+
+    PyObject *result = (*iternext)(iterator);
+
+    CHECK_OBJECT_X(result);
+
+    return result;
+#endif
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *BUILTIN_NEXT2(PyThreadState *tstate, PyObject *iterator,
+                                                    PyObject *default_value) {
+    CHECK_OBJECT(iterator);
+    CHECK_OBJECT(default_value);
+
+    PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
+
+    if (unlikely(result == NULL)) {
+        bool stop_iteration_error = CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate);
+
+        if (unlikely(stop_iteration_error == false)) {
+            return NULL;
+        }
+
+        Py_INCREF(default_value);
+        return default_value;
+    }
+
+    CHECK_OBJECT(result);
+    return result;
+}
+
+// For cases, where no exception raising is needed, because we know it at compile time.
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_INFALLIBLE(PyObject *iterator) {
+    CHECK_OBJECT(iterator);
+    assert(HAS_ITERNEXT(iterator));
+
+    PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
+    CHECK_OBJECT(result);
+    return result;
+}
+
+#if PYTHON_VERSION < 0x350
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate,
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                  PyObject *iterator, int seq_size_so_far)
+#else
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT(PyThreadState *tstate,
+                                                  struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                  PyObject *iterator, int seq_size_so_far, int expected)
+#endif
+{
+    CHECK_OBJECT(iterator);
+    assert(HAS_ITERNEXT(iterator));
+
+    PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
+
+    if (unlikely(result == NULL)) {
+        bool had_stop_iteration = true;
+
+        PyObject *error = GET_ERROR_OCCURRED(tstate);
+
+        if (error != NULL) {
+            if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopIteration)) {
+                CLEAR_ERROR_OCCURRED(tstate);
+            } else {
+                had_stop_iteration = false;
+            }
+        }
+
+        if (had_stop_iteration) {
+#if PYTHON_VERSION < 0x350
+            if (seq_size_so_far == 1) {
+                SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_STR(tstate, exception_state, PyExc_ValueError,
+                                                                "need more than 1 value to unpack");
+            } else {
+                SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT1(
+                    tstate, exception_state, PyExc_ValueError, "need more than %d values to unpack", seq_size_so_far);
+            }
+#else
+            SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT2(tstate, exception_state, PyExc_ValueError,
+                                                                "not enough values to unpack (expected %d, got %d)",
+                                                                expected, seq_size_so_far);
+#endif
+        } else {
+            assert(HAS_ERROR_OCCURRED(tstate));
+            FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
+        }
+
+        return NULL;
+    }
+
+    CHECK_OBJECT(result);
+
+    return result;
+}
+
+#if PYTHON_VERSION >= 0x350
+// Different error message for starred unpacks
+NUITKA_MAY_BE_UNUSED static PyObject *UNPACK_NEXT_STARRED(PyThreadState *tstate,
+                                                          struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                          PyObject *iterator, int seq_size_so_far, int expected) {
+    CHECK_OBJECT(iterator);
+    assert(HAS_ITERNEXT(iterator));
+
+    PyObject *result = (*Py_TYPE(iterator)->tp_iternext)(iterator);
+
+    if (unlikely(result == NULL)) {
+        FETCH_ERROR_OCCURRED_STATE(tstate, exception_state);
+
+        // TODO: Specialize more for StopIteration and maybe derived ones do not
+        // count or do they?
+        if (!HAS_EXCEPTION_STATE(exception_state) ||
+            EXCEPTION_STATE_MATCH_BOOL_SINGLE(tstate, exception_state, PyExc_StopIteration)) {
+            SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT2(
+                tstate, exception_state, PyExc_ValueError, "not enough values to unpack (expected at least %d, got %d)",
+                expected, seq_size_so_far);
+        }
+
+        return NULL;
+    }
+
+    CHECK_OBJECT(result);
+
+    return result;
+}
+#endif
+
+NUITKA_MAY_BE_UNUSED static bool UNPACK_ITERATOR_CHECK(PyThreadState *tstate,
+                                                       struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                       PyObject *iterator, int expected) {
+    PyObject *attempt = (*(Py_TYPE(iterator)->tp_iternext))(iterator);
+
+    if (likely(attempt == 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_STATE(tstate, exception_state);
+                return false;
+            }
+        }
+
+        return true;
+    } else {
+        Py_DECREF(attempt);
+
+#if PYTHON_VERSION < 0x300
+        SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_STR(tstate, exception_state, PyExc_ValueError,
+                                                        "too many values to unpack");
+#else
+        SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0_FORMAT1(tstate, exception_state, PyExc_ValueError,
+                                                            "too many values to unpack (expected %d)", expected);
+#endif
+        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/build/include/nuitka/helper/lists.h

@@ -0,0 +1,94 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_LISTS_H__
+#define __NUITKA_HELPER_LISTS_H__
+
+// Like PyList_SET_ITEM but takes a reference to the item.
+#define PyList_SET_ITEM0(tuple, index, value)                                                                          \
+    {                                                                                                                  \
+        PyObject *tmp = value;                                                                                         \
+        Py_INCREF(tmp);                                                                                                \
+        PyList_SET_ITEM(tuple, index, tmp);                                                                            \
+    }
+
+#ifndef _PyList_ITEMS
+#define _PyList_ITEMS(op) (((PyListObject *)(op))->ob_item)
+#endif
+
+#if PYTHON_VERSION >= 0x3a0
+#define NUITKA_LIST_HAS_FREELIST 1
+extern PyObject *MAKE_LIST_EMPTY(PyThreadState *tstate, Py_ssize_t size);
+#else
+#define NUITKA_LIST_HAS_FREELIST 0
+
+#define MAKE_LIST_EMPTY(tstate, size) PyList_New(size)
+#endif
+
+extern bool LIST_EXTEND_FROM_ITERABLE(PyThreadState *tstate, PyObject *list, PyObject *other);
+extern bool LIST_EXTEND_FOR_UNPACK(PyThreadState *tstate, PyObject *list, PyObject *other);
+
+// Like "PyList_Append", but we get to specify the transfer of refcount ownership.
+extern bool LIST_APPEND1(PyObject *target, PyObject *item);
+extern bool LIST_APPEND0(PyObject *target, PyObject *item);
+
+// Like "list.remove"
+bool LIST_REMOVE(PyObject *target, PyObject *item);
+
+// Like list.clear
+extern void LIST_CLEAR(PyObject *target);
+
+// Like list.reverse
+extern void LIST_REVERSE(PyObject *list);
+
+// Like list.copy
+extern PyObject *LIST_COPY(PyThreadState *tstate, PyObject *list);
+
+// Like list.count
+extern PyObject *LIST_COUNT(PyObject *list, PyObject *item);
+
+// Like list.index
+extern PyObject *LIST_INDEX2(PyThreadState *tstate, PyObject *list, PyObject *item);
+extern PyObject *LIST_INDEX3(PyThreadState *tstate, PyObject *list, PyObject *item, PyObject *start);
+extern PyObject *LIST_INDEX4(PyThreadState *tstate, PyObject *list, PyObject *item, PyObject *start, PyObject *stop);
+
+// Like list.index
+extern bool LIST_INSERT(PyThreadState *tstate, PyObject *list, PyObject *index, PyObject *item);
+// Like PyList_Insert
+extern void LIST_INSERT_CONST(PyObject *list, Py_ssize_t index, PyObject *item);
+
+extern PyObject *MAKE_LIST(PyThreadState *tstate, PyObject *iterable);
+
+extern bool LIST_EXTEND_FROM_LIST(PyObject *list, PyObject *other);
+
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_LIST_REPEATED(PyThreadState *tstate, Py_ssize_t size, PyObject *element) {
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
+
+    if (unlikely(result == NULL)) {
+        return NULL;
+    }
+
+    for (Py_ssize_t i = 0; i < size; i++) {
+        Py_INCREF(element);
+        PyList_SET_ITEM(result, i, element);
+    }
+
+    return result;
+}
+
+#include "lists_generated.h"
+
+#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/lists_generated.h

@@ -0,0 +1,36 @@
+//     Copyright 2025, 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. */
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#endif
+
+extern PyObject *MAKE_LIST1(PyThreadState *tstate, PyObject *arg0);
+extern PyObject *MAKE_LIST2(PyThreadState *tstate, PyObject *arg0, PyObject *arg1);
+extern PyObject *MAKE_LIST3(PyThreadState *tstate, PyObject *arg0, PyObject *arg1, PyObject *arg2);
+extern PyObject *MAKE_LIST4(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST5(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST6(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST7(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST8(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST9(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST10(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST11(PyThreadState *tstate, PyObject *list);
+extern PyObject *MAKE_LIST12(PyThreadState *tstate, PyObject *list);
+
+//     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.