Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/include/nuitka/helper/raising.h

@@ -0,0 +1,114 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_RAISING_H__
+#define __NUITKA_HELPER_RAISING_H__
+
+#if PYTHON_VERSION >= 0x300
+NUITKA_MAY_BE_UNUSED static void CHAIN_EXCEPTION(PyThreadState *tstate, PyObject *exception_value) {
+    // Implicit chain of exception already existing.
+
+    // Normalize existing published exception first.
+#if PYTHON_VERSION < 0x3b0
+    {
+        // TODO: Revert to using NORMALIZE_EXCEPTION
+        struct Nuitka_ExceptionPreservationItem *exception_state =
+            (struct Nuitka_ExceptionPreservationItem *)&EXC_TYPE(tstate);
+        NORMALIZE_EXCEPTION_STATE(tstate, exception_state);
+    }
+#endif
+
+    PyObject *old_exc_value = EXC_VALUE(tstate);
+
+    if (old_exc_value != NULL && old_exc_value != Py_None && old_exc_value != exception_value) {
+        PyObject *current = old_exc_value;
+        while (true) {
+            PyObject *context = Nuitka_Exception_GetContext(current);
+            if (context == NULL) {
+                break;
+            }
+
+            CHECK_OBJECT(context);
+
+            if (context == exception_value) {
+                Nuitka_Exception_DeleteContext(current);
+                break;
+            }
+
+            current = context;
+        }
+
+        CHECK_OBJECT(old_exc_value);
+        Nuitka_Exception_SetContext(exception_value, old_exc_value);
+
+#if PYTHON_VERSION < 0x3b0
+        CHECK_OBJECT(EXC_TRACEBACK(tstate));
+        ATTACH_TRACEBACK_TO_EXCEPTION_VALUE(old_exc_value, (PyTracebackObject *)EXC_TRACEBACK(tstate));
+#endif
+    }
+}
+#endif
+
+#if PYTHON_VERSION < 0x3c0
+extern void RAISE_EXCEPTION_WITH_TYPE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
+extern void RAISE_EXCEPTION_WITH_TYPE_AND_VALUE(PyThreadState *tstate,
+                                                struct Nuitka_ExceptionPreservationItem *exception_state);
+#else
+extern void RAISE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
+#endif
+
+#if PYTHON_VERSION < 0x300
+extern void RAISE_EXCEPTION_WITH_TRACEBACK(PyThreadState *tstate,
+                                           struct Nuitka_ExceptionPreservationItem *exception_state);
+#else
+extern void RAISE_EXCEPTION_WITH_CAUSE(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state,
+                                       PyObject *exception_cause);
+#endif
+
+extern bool RERAISE_EXCEPTION(PyThreadState *tstate, struct Nuitka_ExceptionPreservationItem *exception_state);
+
+extern void RAISE_CURRENT_EXCEPTION_NAME_ERROR(PyThreadState *tstate,
+                                               struct Nuitka_ExceptionPreservationItem *exception_state,
+                                               PyObject *variable_name);
+
+#if PYTHON_VERSION < 0x300
+extern void RAISE_CURRENT_EXCEPTION_GLOBAL_NAME_ERROR(PyThreadState *tstate,
+                                                      struct Nuitka_ExceptionPreservationItem *exception_state,
+                                                      PyObject *variable_name);
+#endif
+
+extern PyObject *NORMALIZE_EXCEPTION_VALUE_FOR_RAISE(PyThreadState *tstate, PyObject *exception_type);
+
+#if PYTHON_VERSION >= 0x300
+extern PyObject *MAKE_STOP_ITERATION_EMPTY(void);
+extern PyObject *MAKE_BASE_EXCEPTION_DERIVED_EMPTY(PyObject *exception_type);
+#endif
+
+NUITKA_MAY_BE_UNUSED static inline void
+SET_EXCEPTION_PRESERVATION_STATE_STOP_ITERATION_EMPTY(PyThreadState *tstate,
+                                                      struct Nuitka_ExceptionPreservationItem *exception_state) {
+#if PYTHON_VERSION < 0x3c0
+    SET_EXCEPTION_PRESERVATION_STATE_FROM_TYPE0(tstate, exception_state, PyExc_StopIteration);
+#else
+    exception_state->exception_value = MAKE_STOP_ITERATION_EMPTY();
+#endif
+}
+
+// Create an exception value object from type and value input.
+extern PyObject *MAKE_EXCEPTION_WITH_VALUE(PyThreadState *tstate, PyObject *exception_type, PyObject *value);
+
+#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/rangeobjects.h

@@ -0,0 +1,66 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_RANGEOBJECTS_H__
+#define __NUITKA_HELPER_RANGEOBJECTS_H__
+
+/* For built-in built-in range() functionality. */
+
+extern PyObject *BUILTIN_RANGE3(PyThreadState *tstate, PyObject *low, PyObject *high, PyObject *step);
+extern PyObject *BUILTIN_RANGE2(PyThreadState *tstate, PyObject *low, PyObject *high);
+extern PyObject *BUILTIN_RANGE(PyThreadState *tstate, PyObject *boundary);
+
+/* For built-in built-in xrange() functionality. */
+extern PyObject *BUILTIN_XRANGE1(PyThreadState *tstate, PyObject *high);
+extern PyObject *BUILTIN_XRANGE2(PyThreadState *tstate, PyObject *low, PyObject *high);
+extern PyObject *BUILTIN_XRANGE3(PyThreadState *tstate, PyObject *low, PyObject *high, PyObject *step);
+
+#if PYTHON_VERSION >= 0x300
+
+/* Python3 range objects */
+struct _rangeobject3 {
+    /* Python object folklore: */
+    PyObject_HEAD
+
+        PyObject *start;
+    PyObject *stop;
+    PyObject *step;
+    PyObject *length;
+};
+
+NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Start(PyObject *range) { return ((struct _rangeobject3 *)range)->start; }
+
+NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Stop(PyObject *range) { return ((struct _rangeobject3 *)range)->stop; }
+
+NUITKA_MAY_BE_UNUSED static PyObject *PyRange_Step(PyObject *range) { return ((struct _rangeobject3 *)range)->step; }
+
+#else
+
+struct _rangeobject2 {
+    /* Python object folklore: */
+    PyObject_HEAD
+
+        long start;
+    long step;
+    long len;
+};
+
+extern PyObject *MAKE_XRANGE(PyThreadState *tstate, long start, long stop, long step);
+
+#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/richcomparisons.h

@@ -0,0 +1,35 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_RICHCOMPARISONS_H__
+#define __NUITKA_HELPER_RICHCOMPARISONS_H__
+
+#include "nuitka/helper/comparisons_eq.h"
+#include "nuitka/helper/comparisons_ge.h"
+#include "nuitka/helper/comparisons_gt.h"
+#include "nuitka/helper/comparisons_le.h"
+#include "nuitka/helper/comparisons_lt.h"
+#include "nuitka/helper/comparisons_ne.h"
+
+#include "nuitka/helper/comparisons_dual_eq.h"
+#include "nuitka/helper/comparisons_dual_ge.h"
+#include "nuitka/helper/comparisons_dual_gt.h"
+#include "nuitka/helper/comparisons_dual_le.h"
+#include "nuitka/helper/comparisons_dual_lt.h"
+#include "nuitka/helper/comparisons_dual_ne.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/sequences.h

@@ -0,0 +1,33 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_SEQUENCES_H__
+#define __NUITKA_HELPER_SEQUENCES_H__
+
+// TODO: Provide enhanced form of PySequence_Contains with less overhead as well.
+
+extern bool SEQUENCE_SET_ITEM(PyObject *sequence, Py_ssize_t index, PyObject *value);
+
+extern Py_ssize_t Nuitka_PyObject_Size(PyObject *sequence);
+
+// Our version of "_PyObject_HasLen", a former API function.
+NUITKA_MAY_BE_UNUSED static int Nuitka_PyObject_HasLen(PyObject *o) {
+    return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||
+           (Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);
+}
+
+#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/sets.h

@@ -0,0 +1,25 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_SETS_H__
+#define __NUITKA_SETS_H__
+
+// This is not Python headers before 3.10, but we use it in our assertions.
+#if PYTHON_VERSION < 0x3a0
+#define PySet_CheckExact(op) (Py_TYPE(op) == &PySet_Type)
+#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/slices.h

@@ -0,0 +1,314 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_HELPER_SLICES_H__
+#define __NUITKA_HELPER_SLICES_H__
+
+/* 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
+
+#if PYTHON_VERSION >= 0x3a0
+extern PyObject *Nuitka_Slice_New(PyThreadState *tstate, PyObject *start, PyObject *stop, PyObject *step);
+#else
+#define Nuitka_Slice_New(tstate, start, stop, step) PySlice_New(start, stop, step)
+#endif
+
+// Note: Cannot these cannot fail, PySlice_New does not return errors.
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT3(PyThreadState *tstate, PyObject *start, PyObject *stop,
+                                                         PyObject *step) {
+    CHECK_OBJECT(start);
+    CHECK_OBJECT(stop);
+    CHECK_OBJECT(step);
+
+    return Nuitka_Slice_New(tstate, start, stop, step);
+}
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT2(PyThreadState *tstate, PyObject *start, PyObject *stop) {
+    CHECK_OBJECT(start);
+    CHECK_OBJECT(stop);
+
+    return Nuitka_Slice_New(tstate, start, stop, Py_None);
+}
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_SLICE_OBJECT1(PyThreadState *tstate, PyObject *stop) {
+    CHECK_OBJECT(stop);
+
+    return Nuitka_Slice_New(tstate, Py_None, stop, Py_None);
+}
+
+#if PYTHON_VERSION < 0x300
+// Note: It appears that Python3 has no index slicing operations anymore, but
+// uses slice objects all the time. That's fine and make sure we adhere to it by
+// guarding the presence of the helpers.
+
+static inline bool IS_INDEXABLE(PyObject *value) {
+    return value == Py_None ||
+#if PYTHON_VERSION < 0x300
+           PyInt_Check(value) ||
+#endif
+           PyLong_Check(value) || Nuitka_Index_Check(value);
+}
+
+static Py_ssize_t CONVERT_TO_INDEX(PyThreadState *tstate, PyObject *value) {
+    CHECK_OBJECT(value);
+
+    if (PyInt_Check(value)) {
+        return PyInt_AS_LONG(value);
+    } else if (Nuitka_Index_Check(value)) {
+        return PyNumber_AsSsize_t(value, NULL);
+    } else {
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError,
+                                        "slice indices must be integers or None or have an __index__ method");
+        return -1;
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_SLICE(PyThreadState *tstate, PyObject *source, PyObject *lower,
+                                                   PyObject *upper) {
+    CHECK_OBJECT(source);
+    CHECK_OBJECT(lower);
+    CHECK_OBJECT(upper);
+
+    PySequenceMethods *tp_as_sequence = Py_TYPE(source)->tp_as_sequence;
+
+    if (tp_as_sequence && tp_as_sequence->sq_slice && IS_INDEXABLE(lower) && IS_INDEXABLE(upper)) {
+        Py_ssize_t ilow = 0;
+
+        if (lower != Py_None) {
+            ilow = CONVERT_TO_INDEX(tstate, lower);
+
+            if (ilow == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return NULL;
+            }
+        }
+
+        Py_ssize_t ihigh = PY_SSIZE_T_MAX;
+
+        if (upper != Py_None) {
+            ihigh = CONVERT_TO_INDEX(tstate, upper);
+
+            if (ihigh == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return NULL;
+            }
+        }
+
+        PyObject *result = PySequence_GetSlice(source, ilow, ihigh);
+
+        if (unlikely(result == NULL)) {
+            return NULL;
+        }
+
+        return result;
+    } else {
+        PyObject *slice = PySlice_New(lower, upper, NULL);
+
+        if (unlikely(slice == NULL)) {
+            return NULL;
+        }
+
+        PyObject *result = PyObject_GetItem(source, slice);
+        Py_DECREF(slice);
+
+        if (unlikely(result == NULL)) {
+            return NULL;
+        }
+
+        return result;
+    }
+}
+
+NUITKA_MAY_BE_UNUSED static PyObject *LOOKUP_INDEX_SLICE(PyObject *source, Py_ssize_t lower, Py_ssize_t upper) {
+    CHECK_OBJECT(source);
+
+    PyObject *result = PySequence_GetSlice(source, lower, upper);
+
+    if (unlikely(result == NULL)) {
+        return NULL;
+    }
+
+    return result;
+}
+
+NUITKA_MAY_BE_UNUSED static bool SET_SLICE(PyThreadState *tstate, PyObject *target, PyObject *lower, PyObject *upper,
+                                           PyObject *value) {
+    CHECK_OBJECT(target);
+    CHECK_OBJECT(lower);
+    CHECK_OBJECT(upper);
+    CHECK_OBJECT(value);
+
+    PySequenceMethods *tp_as_sequence = Py_TYPE(target)->tp_as_sequence;
+
+    if (tp_as_sequence && tp_as_sequence->sq_ass_slice && IS_INDEXABLE(lower) && IS_INDEXABLE(upper)) {
+        Py_ssize_t lower_int = 0;
+
+        if (lower != Py_None) {
+            lower_int = CONVERT_TO_INDEX(tstate, lower);
+
+            if (lower_int == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return false;
+            }
+        }
+
+        Py_ssize_t upper_int = PY_SSIZE_T_MAX;
+
+        if (upper != Py_None) {
+            upper_int = CONVERT_TO_INDEX(tstate, upper);
+
+            if (upper_int == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return false;
+            }
+        }
+
+        int status = PySequence_SetSlice(target, lower_int, upper_int, value);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    } else {
+        PyObject *slice = PySlice_New(lower, upper, NULL);
+
+        if (unlikely(slice == NULL)) {
+            return false;
+        }
+
+        int status = PyObject_SetItem(target, slice, value);
+        Py_DECREF(slice);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+NUITKA_MAY_BE_UNUSED static bool SET_INDEX_SLICE(PyObject *target, Py_ssize_t lower, Py_ssize_t upper,
+                                                 PyObject *value) {
+    CHECK_OBJECT(target);
+    CHECK_OBJECT(value);
+
+    PySequenceMethods *tp_as_sequence = Py_TYPE(target)->tp_as_sequence;
+
+    if (tp_as_sequence && tp_as_sequence->sq_ass_slice) {
+        int status = PySequence_SetSlice(target, lower, upper, value);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    } else {
+        PyObject *slice = _PySlice_FromIndices(lower, upper);
+
+        if (unlikely(slice == NULL)) {
+            return false;
+        }
+
+        int status = PyObject_SetItem(target, slice, value);
+
+        Py_DECREF(slice);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+NUITKA_MAY_BE_UNUSED static bool DEL_SLICE(PyThreadState *tstate, PyObject *target, PyObject *lower, PyObject *upper) {
+    CHECK_OBJECT(target);
+    CHECK_OBJECT(lower);
+    CHECK_OBJECT(upper);
+
+    PySequenceMethods *tp_as_sequence = Py_TYPE(target)->tp_as_sequence;
+
+    if (tp_as_sequence && tp_as_sequence->sq_ass_slice && IS_INDEXABLE(lower) && IS_INDEXABLE(upper)) {
+        Py_ssize_t lower_int = 0;
+
+        if (lower != Py_None) {
+            lower_int = CONVERT_TO_INDEX(tstate, lower);
+
+            if (lower_int == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return false;
+            }
+        }
+
+        Py_ssize_t upper_int = PY_SSIZE_T_MAX;
+
+        if (upper != Py_None) {
+            upper_int = CONVERT_TO_INDEX(tstate, upper);
+
+            if (upper_int == -1 && HAS_ERROR_OCCURRED(tstate)) {
+                return false;
+            }
+        }
+
+        int status = PySequence_DelSlice(target, lower_int, upper_int);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    } else {
+        PyObject *slice = PySlice_New(lower, upper, NULL);
+
+        if (unlikely(slice == NULL)) {
+            return false;
+        }
+
+        int status = PyObject_DelItem(target, slice);
+        Py_DECREF(slice);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+NUITKA_MAY_BE_UNUSED static bool DEL_INDEX_SLICE(PyObject *target, Py_ssize_t lower, Py_ssize_t upper) {
+    CHECK_OBJECT(target);
+
+    PySequenceMethods *tp_as_sequence = Py_TYPE(target)->tp_as_sequence;
+
+    if (tp_as_sequence && tp_as_sequence->sq_ass_slice) {
+        int status = PySequence_DelSlice(target, lower, upper);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    } else {
+        PyObject *slice = _PySlice_FromIndices(lower, upper);
+
+        if (unlikely(slice == NULL)) {
+            return false;
+        }
+
+        int status = PyObject_DelItem(target, slice);
+
+        Py_DECREF(slice);
+
+        if (unlikely(status == -1)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#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/strings.h

@@ -0,0 +1,30 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_STRINGS_H__
+#define __NUITKA_STRINGS_H__
+
+#if PYTHON_VERSION < 0x300
+extern PyObject *STR_JOIN(PyThreadState *tstate, PyObject *str, PyObject *iterable);
+#endif
+
+extern PyObject *UNICODE_JOIN(PyThreadState *tstate, PyObject *str, PyObject *iterable);
+extern PyObject *UNICODE_PARTITION(PyThreadState *tstate, PyObject *str, PyObject *sep);
+extern PyObject *UNICODE_RPARTITION(PyThreadState *tstate, PyObject *str, PyObject *sep);
+
+extern PyObject *NuitkaUnicode_FromWideChar(wchar_t const *str, 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.