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

nuitka/build/static_src/HelpersSafeStrings.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 are used to interact safely with buffers to not overflow.
 
    Currently this is used for char and wchar_t string buffers and shared
@@ -29,6 +14,7 @@
 #include <windows.h>
 #endif
 #include <stdbool.h>
+#include <stdio.h>
 #endif
 
 #include "nuitka/safe_string_ops.h"
@@ -95,7 +81,7 @@ void appendWStringSafeW(wchar_t *target, wchar_t const *source, size_t buffer_si
     *target = 0;
 }
 
-void appendCharSafeW(wchar_t *target, char c, size_t buffer_size) {
+void appendWCharSafeW(wchar_t *target, wchar_t c, size_t buffer_size) {
     while (*target != 0) {
         target++;
         buffer_size -= 1;
@@ -105,10 +91,20 @@ void appendCharSafeW(wchar_t *target, char c, size_t buffer_size) {
         abort();
     }
 
-    target += wcslen(target);
+    *target++ = c;
+    *target = 0;
+}
+
+void appendCharSafeW(wchar_t *target, char c, size_t buffer_size) {
     char buffer_c[2] = {c, 0};
-    size_t res = mbstowcs(target, buffer_c, 2);
-    assert(res == 1);
+    wchar_t wide_buffer_c[2];
+
+    size_t res = mbstowcs(wide_buffer_c, buffer_c, 2);
+    if (res != 1) {
+        abort();
+    }
+
+    appendWCharSafeW(target, wide_buffer_c[0], buffer_size);
 }
 
 void appendStringSafeW(wchar_t *target, char const *source, size_t buffer_size) {
@@ -119,6 +115,7 @@ void appendStringSafeW(wchar_t *target, char const *source, size_t buffer_size)
 
     while (*source != 0) {
         appendCharSafeW(target, *source, buffer_size);
+        target++;
         source++;
         buffer_size -= 1;
     }
@@ -131,8 +128,23 @@ void printOSErrorMessage(char const *message, error_code_t error_code) {
     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
                   error_code, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPTSTR)&err_buffer, 0, NULL);
 
-    fprintf(stderr, "%s ([Error %d] %s)\n", message, error_code, err_buffer);
+    fprintf(stderr, "%s ([Error " ERROR_CODE_FORMAT_STR "] %s)\n", message, error_code, err_buffer);
 #else
     fprintf(stderr, "%s: %s\n", message, strerror(error_code));
 #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/static_src/HelpersSequences.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 sequence interfaces.
 
 */
@@ -66,7 +51,7 @@ Py_ssize_t Nuitka_PyObject_Size(PyObject *sequence) {
         return tp_as_sequence->sq_length(sequence);
     }
 
-    return PyMapping_Size(sequence);
+    return Nuitka_PyMapping_Size(sequence);
 }
 
 PyObject *Nuitka_Number_Index(PyObject *item) {
@@ -132,4 +117,18 @@ PyObject *Nuitka_Number_IndexAsLong(PyObject *item) {
         return NULL;
     }
 }
-#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/static_src/HelpersSlices.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
+
 /* Small helpers to work with slices their contents */
 
 // This file is included from another C file, help IDEs to still parse it on
@@ -24,14 +9,21 @@
 #endif
 
 #if PYTHON_VERSION >= 0x3a0
-PyObject *Nuitka_Slice_New(PyObject *start, PyObject *stop, PyObject *step) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
 
+PyObject *Nuitka_Slice_New(PyThreadState *tstate, PyObject *start, PyObject *stop, PyObject *step) {
     PySliceObject *result_slice;
 
-    if (interp->slice_cache != NULL) {
-        result_slice = interp->slice_cache;
-        interp->slice_cache = NULL;
+#if PYTHON_VERSION >= 0x3d0
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    PySliceObject **slice_cache_ptr = &freelists->slices.slice_cache;
+#else
+    PyInterpreterState *interp = tstate->interp;
+    PySliceObject **slice_cache_ptr = &interp->slice_cache;
+#endif
+
+    if (*slice_cache_ptr != NULL) {
+        result_slice = *slice_cache_ptr;
+        *slice_cache_ptr = NULL;
 
         Nuitka_Py_NewReference((PyObject *)result_slice);
     } else {
@@ -64,4 +56,18 @@ PyObject *Nuitka_Slice_New(PyObject *start, PyObject *stop, PyObject *step) {
     return (PyObject *)result_slice;
 }
 
-#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/static_src/HelpersStrings.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 quickly create a string object from C char.
 
    Currently this is used for string subscript code, but may also be used
@@ -146,15 +131,19 @@ PyObject *BUILTIN_ORD(PyObject *value) {
     (assert(_PyUnicode_CHECK(op)), assert(PyUnicode_IS_READY(op)),                                                     \
      PyUnicode_IS_COMPACT_ASCII(op) ? ((PyASCIIObject *)(op))->length : _PyUnicode_UTF8_LENGTH(op))
 #define _PyUnicode_WSTR(op) (((PyASCIIObject *)(op))->wstr)
+#if PYTHON_VERSION < 0x3c0
 #define _PyUnicode_WSTR_LENGTH(op) (((PyCompactUnicodeObject *)(op))->wstr_length)
+#endif
 #define _PyUnicode_LENGTH(op) (((PyASCIIObject *)(op))->length)
 #define _PyUnicode_STATE(op) (((PyASCIIObject *)(op))->state)
 #define _PyUnicode_HASH(op) (((PyASCIIObject *)(op))->hash)
 #define _PyUnicode_KIND(op) (((PyASCIIObject *)(op))->state.kind)
 #define _PyUnicode_DATA_ANY(op) (((PyUnicodeObject *)(op))->data.any)
 
+#if PYTHON_VERSION < 0x3c0
 #undef PyUnicode_READY
 #define PyUnicode_READY(op) ((PyUnicode_IS_READY(op) ? 0 : _PyUnicode_Ready(op)))
+#endif
 
 #define _PyUnicode_SHARE_UTF8(op) (assert(!PyUnicode_IS_COMPACT_ASCII(op)), (_PyUnicode_UTF8(op) == PyUnicode_DATA(op)))
 #define _PyUnicode_SHARE_WSTR(op) ((_PyUnicode_WSTR(unicode) == PyUnicode_DATA(op)))
@@ -181,7 +170,7 @@ PyObject *BUILTIN_ORD(PyObject *value) {
             _to += 4;                                                                                                  \
         }                                                                                                              \
         while (_iter < (_end))                                                                                         \
-            *_to++ = (to_type)*_iter++;                                                                                \
+            *_to++ = (to_type)(*_iter++);                                                                              \
     } while (0)
 
 extern int ucs1lib_find_max_char(const Py_UCS1 *begin, const Py_UCS1 *end);
@@ -239,12 +228,13 @@ static int _NuitkaUnicode_modifiable(PyObject *unicode) {
         return 0;
     if (_PyUnicode_HASH(unicode) != -1)
         return 0;
-    // TODO: That ought to be impossible with refcnf 1.
+    // TODO: That ought to be impossible with refcnt 1.
     if (PyUnicode_CHECK_INTERNED(unicode))
         return 0;
     return 1;
 }
 
+#if PYTHON_VERSION < 0x3c0
 static PyObject *_NuitkaUnicode_New(Py_ssize_t length) {
     assert(length != 0);
 
@@ -271,7 +261,7 @@ static PyObject *_NuitkaUnicode_New(Py_ssize_t length) {
     _PyUnicode_UTF8(unicode) = NULL;
     _PyUnicode_UTF8_LENGTH(unicode) = 0;
 
-    _PyUnicode_WSTR(unicode) = (Py_UNICODE *)PyObject_MALLOC(new_size);
+    _PyUnicode_WSTR(unicode) = (Py_UNICODE *)NuitkaObject_Malloc(new_size);
     if (!_PyUnicode_WSTR(unicode)) {
         Py_DECREF(unicode);
         PyErr_NoMemory();
@@ -307,6 +297,24 @@ static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length
     }
 }
 
+#else
+
+static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length) {
+    // TODO: We should inline this one as well, it's doable and would save a bunch
+    // for the copying case as well.
+    PyObject *copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
+
+    if (unlikely(copy == NULL)) {
+        return NULL;
+    }
+
+    Py_ssize_t copy_length = Py_MIN(length, PyUnicode_GET_LENGTH(unicode));
+    _NuitkaUnicode_FastCopyCharacters(copy, 0, unicode, 0, copy_length);
+    return copy;
+}
+
+#endif
+
 // We use older form code, make some backward compatible defines available.
 #if PYTHON_VERSION >= 0x390
 
@@ -324,6 +332,7 @@ static PyObject *_NuitkaUnicode_resize_copy(PyObject *unicode, Py_ssize_t length
 
 #endif
 
+#if PYTHON_VERSION < 0x3c0
 static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t length) {
     assert(PyUnicode_IS_COMPACT(unicode));
 
@@ -338,7 +347,7 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
 
     int share_wstr = _PyUnicode_SHARE_WSTR(unicode);
 
-    if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
+    if (unlikely(length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))) {
         PyErr_NoMemory();
         return NULL;
     }
@@ -349,6 +358,7 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
         _PyUnicode_UTF8(unicode) = NULL;
         _PyUnicode_UTF8_LENGTH(unicode) = 0;
     }
+
     _Py_DEC_REFTOTAL;
     _Py_ForgetReference(unicode);
 
@@ -359,10 +369,12 @@ static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t len
         PyErr_NoMemory();
         return NULL;
     }
+
     unicode = new_unicode;
     Nuitka_Py_NewReference(unicode);
 
     _PyUnicode_LENGTH(unicode) = length;
+
     if (share_wstr) {
         _PyUnicode_WSTR(unicode) = (wchar_t *)PyUnicode_DATA(unicode);
         if (!PyUnicode_IS_ASCII(unicode)) {
@@ -391,10 +403,11 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
         int share_wstr = _PyUnicode_SHARE_WSTR(unicode);
         int share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
 
-        if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
+        if (unlikely(length > (PY_SSIZE_T_MAX / char_size - 1))) {
             PyErr_NoMemory();
             return -1;
         }
+
         Py_ssize_t new_size = (length + 1) * char_size;
 
         if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode)) {
@@ -408,6 +421,7 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
             PyErr_NoMemory();
             return -1;
         }
+
         _PyUnicode_DATA_ANY(unicode) = data;
         if (share_wstr) {
             _PyUnicode_WSTR(unicode) = (wchar_t *)data;
@@ -446,15 +460,17 @@ static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
 }
 
 static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
+    assert(p_unicode != NULL);
+    assert(*p_unicode != NULL);
+    assert(0 <= length);
+
     PyObject *unicode = *p_unicode;
+    assert(PyUnicode_Check(unicode));
     Py_ssize_t old_length;
 
-#if PYTHON_VERSION < 0x3c0
     if (_PyUnicode_KIND(unicode) == PyUnicode_WCHAR_KIND) {
         old_length = PyUnicode_WSTR_LENGTH(unicode);
-    } else
-#endif
-    {
+    } else {
         old_length = PyUnicode_GET_LENGTH(unicode);
     }
 
@@ -470,23 +486,189 @@ static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
 
     if (!_NuitkaUnicode_modifiable(unicode)) {
         PyObject *copy = _NuitkaUnicode_resize_copy(unicode, length);
-        if (copy == NULL)
+        if (unlikely(copy == NULL)) {
             return -1;
+        }
         Py_DECREF(*p_unicode);
         *p_unicode = copy;
+
         return 0;
     }
 
     if (PyUnicode_IS_COMPACT(unicode)) {
         PyObject *new_unicode = _NuitkaUnicode_resize_compact(unicode, length);
-        if (new_unicode == NULL)
+
+        if (unlikely(new_unicode == NULL)) {
             return -1;
+        }
+
         *p_unicode = new_unicode;
         return 0;
     }
 
     return _NuitkaUnicode_resize_inplace(unicode, length);
 }
+#else
+
+#ifndef __NUITKA_NO_ASSERT__
+static void _Nuitka_unicode_fill_invalid(PyObject *unicode, Py_ssize_t old_length) {
+    int kind = PyUnicode_KIND(unicode);
+    Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
+    Py_ssize_t length = _PyUnicode_LENGTH(unicode);
+    if (length <= old_length)
+        return;
+    memset(data + old_length * kind, 0xff, (length - old_length) * kind);
+}
+#endif
+
+static PyObject *_NuitkaUnicode_resize_compact(PyObject *unicode, Py_ssize_t length) {
+    assert(PyUnicode_IS_COMPACT(unicode));
+
+    Py_ssize_t char_size = PyUnicode_KIND(unicode);
+    Py_ssize_t struct_size;
+
+    if (PyUnicode_IS_ASCII(unicode)) {
+        struct_size = sizeof(PyASCIIObject);
+    } else {
+        struct_size = sizeof(PyCompactUnicodeObject);
+    }
+
+#ifndef __NUITKA_NO_ASSERT__
+    Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
+#endif
+
+    // assert(_Nuitka_unicode_modifiable(unicode));
+
+    if (unlikely(length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    Py_ssize_t new_size = (struct_size + (length + 1) * char_size);
+
+    if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+        PyObject_DEL(_PyUnicode_UTF8(unicode));
+        _PyUnicode_UTF8(unicode) = NULL;
+        _PyUnicode_UTF8_LENGTH(unicode) = 0;
+    }
+    _Py_ForgetReference(unicode);
+
+    PyObject *new_unicode = (PyObject *)PyObject_Realloc(unicode, new_size);
+    if (unlikely(new_unicode == NULL)) {
+        Nuitka_Py_NewReferenceNoTotal(unicode);
+
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    unicode = new_unicode;
+    Nuitka_Py_NewReferenceNoTotal(unicode);
+
+    _PyUnicode_LENGTH(unicode) = length;
+
+#ifndef __NUITKA_NO_ASSERT__
+    _Nuitka_unicode_fill_invalid(unicode, old_length);
+#endif
+
+    PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode), length, 0);
+    assert(_PyUnicode_CheckConsistency(unicode, 0));
+
+    return unicode;
+}
+
+static int _NuitkaUnicode_resize_inplace(PyObject *unicode, Py_ssize_t length) {
+    assert(!PyUnicode_IS_COMPACT(unicode));
+    assert(Py_REFCNT(unicode) == 1);
+
+#ifndef __NUITKA_NO_ASSERT__
+    Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
+#endif
+
+    void *data = _PyUnicode_DATA_ANY(unicode);
+    Py_ssize_t char_size = PyUnicode_KIND(unicode);
+    int share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
+
+    if (unlikely(length > (PY_SSIZE_T_MAX / char_size - 1))) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    Py_ssize_t new_size = (length + 1) * char_size;
+
+    if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+        PyObject_DEL(_PyUnicode_UTF8(unicode));
+        _PyUnicode_UTF8(unicode) = NULL;
+        _PyUnicode_UTF8_LENGTH(unicode) = 0;
+    }
+
+    data = (PyObject *)PyObject_REALLOC(data, new_size);
+    if (data == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    _PyUnicode_DATA_ANY(unicode) = data;
+    if (share_utf8) {
+        _PyUnicode_UTF8(unicode) = data;
+        _PyUnicode_UTF8_LENGTH(unicode) = length;
+    }
+    _PyUnicode_LENGTH(unicode) = length;
+    PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);
+#ifndef __NUITKA_NO_ASSERT__
+    _Nuitka_unicode_fill_invalid(unicode, old_length);
+#endif
+
+    /* check for integer overflow */
+    if (length > PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    assert(_PyUnicode_CheckConsistency(unicode, 0));
+    return 0;
+}
+
+static int _NuitkaUnicode_resize(PyObject **p_unicode, Py_ssize_t length) {
+    assert(p_unicode != NULL);
+    assert(*p_unicode != NULL);
+    assert(0 <= length);
+
+    PyObject *unicode = *p_unicode;
+    assert(PyUnicode_Check(unicode));
+    Py_ssize_t old_length;
+
+    old_length = PyUnicode_GET_LENGTH(unicode);
+    if (old_length == length) {
+        return 0;
+    }
+
+    if (length == 0) {
+        Py_SETREF(*p_unicode, const_str_empty);
+        return 0;
+    }
+
+    if (!_NuitkaUnicode_modifiable(unicode)) {
+        PyObject *copy = _NuitkaUnicode_resize_copy(unicode, length);
+        if (unlikely(copy == NULL)) {
+            return -1;
+        }
+        Py_SETREF(*p_unicode, copy);
+
+        return 0;
+    }
+
+    if (PyUnicode_IS_COMPACT(unicode)) {
+        PyObject *new_unicode = _NuitkaUnicode_resize_compact(unicode, length);
+
+        if (unlikely(new_unicode == NULL)) {
+            return -1;
+        }
+
+        *p_unicode = new_unicode;
+        return 0;
+    }
+
+    return _NuitkaUnicode_resize_inplace(unicode, length);
+}
+#endif
 
 PyObject *UNICODE_CONCAT(PyThreadState *tstate, PyObject *left, PyObject *right) {
     if (left == const_str_empty) {
@@ -510,11 +692,11 @@ PyObject *UNICODE_CONCAT(PyThreadState *tstate, PyObject *left, PyObject *right)
     }
     Py_ssize_t new_len = left_len + right_len;
 
-    Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(left);
-    Py_UCS4 maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
-    maxchar = Py_MAX(maxchar, maxchar2);
+    Py_UCS4 max_char = PyUnicode_MAX_CHAR_VALUE(left);
+    Py_UCS4 max_char2 = PyUnicode_MAX_CHAR_VALUE(right);
+    max_char = Py_MAX(max_char, max_char2);
 
-    PyObject *result = PyUnicode_New(new_len, maxchar);
+    PyObject *result = PyUnicode_New(new_len, max_char);
     if (unlikely(result == NULL)) {
         return NULL;
     }
@@ -561,12 +743,12 @@ bool UNICODE_APPEND(PyThreadState *tstate, PyObject **p_left, PyObject *right) {
 
         _NuitkaUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len);
     } else {
-        Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(left);
-        Py_UCS4 maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
+        Py_UCS4 max_char = PyUnicode_MAX_CHAR_VALUE(left);
+        Py_UCS4 max_char2 = PyUnicode_MAX_CHAR_VALUE(right);
 
-        maxchar = Py_MAX(maxchar, maxchar2);
+        max_char = Py_MAX(max_char, max_char2);
 
-        PyObject *res = PyUnicode_New(new_len, maxchar);
+        PyObject *res = PyUnicode_New(new_len, max_char);
         if (unlikely(res == NULL)) {
             return false;
         }
@@ -617,7 +799,7 @@ PyObject *STR_JOIN(PyThreadState *tstate, PyObject *str, PyObject *iterable) {
 
 #endif
 
-PyObject *NuitkaUnicode_FromWideChar(const wchar_t *str, Py_ssize_t size) {
+PyObject *NuitkaUnicode_FromWideChar(wchar_t const *str, Py_ssize_t size) {
 #if PYTHON_VERSION < 0x300
     if (size == -1) {
         size = wcslen(str);
@@ -799,3 +981,18 @@ PyObject *BUILTIN_STR(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.