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

nuitka/build/include/nuitka/prelude.h

@@ -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
+
 #ifndef __NUITKA_PRELUDE_H__
 #define __NUITKA_PRELUDE_H__
 
@@ -23,6 +8,8 @@
 #define NDEBUG
 #endif
 
+#include "nuitka/debug_settings.h"
+
 #if defined(_WIN32)
 // Note: Keep this separate line, must be included before other Windows headers.
 #include <windows.h>
@@ -42,9 +29,10 @@
 
 /* This is needed or else we can't create modules name "proc" or "func". For
  * Python3, the name collision can't happen, so we can limit it to Python2.
+   spell-checker: ignore initproc,initfunc
  */
-#define initproc python_initproc
-#define initfunc python_initfunc
+#define initproc python_init_proc
+#define initfunc python_init_func
 #define initstate python_initstate
 
 // Python 3.11 headers give these warnings
@@ -55,20 +43,30 @@
 #endif
 
 /* Include the relevant Python C-API header files. */
-#include "Python.h"
-#include "frameobject.h"
-#include "marshal.h"
-#include "methodobject.h"
-#include "osdefs.h"
-#include "structseq.h"
+#include <Python.h>
+#include <frameobject.h>
+#include <marshal.h>
+#include <methodobject.h>
+#include <osdefs.h>
+#include <structseq.h>
 
 #if PYTHON_VERSION < 0x3a0
 #include "pydebug.h"
 #endif
 
+/* A way to not give warnings about things that are declared, but might not
+ * be used like in-line helper functions in headers or static per module
+ * variables from headers.
+ */
+#ifdef __GNUC__
+#define NUITKA_MAY_BE_UNUSED __attribute__((__unused__))
+#else
+#define NUITKA_MAY_BE_UNUSED
+#endif
+
 // We are not following the 3.10 change to an inline function. At least
 // not immediately.
-#if PYTHON_VERSION >= 0x3a0
+#if PYTHON_VERSION >= 0x3a0 && PYTHON_VERSION < 0x3c0
 #undef Py_REFCNT
 #define Py_REFCNT(ob) (_PyObject_CAST(ob)->ob_refcnt)
 #endif
@@ -104,6 +102,37 @@
 
 extern _PyRuntimeState _PyRuntime;
 #else
+
+#if PYTHON_VERSION >= 0x3c0
+#include "internal/pycore_runtime.h"
+#include "internal/pycore_typevarobject.h"
+
+static inline size_t Nuitka_static_builtin_index_get(PyTypeObject *self) { return (size_t)self->tp_subclasses - 1; }
+
+// Changed internal type access for Python3.13
+#if PYTHON_VERSION < 0x3d0
+#define managed_static_type_state static_builtin_state
+
+static inline managed_static_type_state *Nuitka_static_builtin_state_get(PyInterpreterState *interp,
+                                                                         PyTypeObject *self) {
+    return &(interp->types.builtins[Nuitka_static_builtin_index_get(self)]);
+}
+#else
+static inline managed_static_type_state *Nuitka_static_builtin_state_get(PyInterpreterState *interp,
+                                                                         PyTypeObject *self) {
+    return &(interp->types.builtins.initialized[Nuitka_static_builtin_index_get(self)]);
+}
+#endif
+
+NUITKA_MAY_BE_UNUSED static inline managed_static_type_state *Nuitka_PyStaticType_GetState(PyInterpreterState *interp,
+                                                                                           PyTypeObject *self) {
+    assert(self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);
+    return Nuitka_static_builtin_state_get(interp, self);
+}
+
+#define _PyStaticType_GetState(interp, self) Nuitka_PyStaticType_GetState(interp, self)
+#endif
+
 #include "internal/pycore_pystate.h"
 #endif
 
@@ -126,18 +155,29 @@ extern _PyRuntimeState _PyRuntime;
 #endif
 
 #if PYTHON_VERSION >= 0x3b0
+#include <internal/pycore_dict.h>
 #include <internal/pycore_frame.h>
 #include <internal/pycore_gc.h>
 #endif
 
 // Uncompiled generator integration requires these.
 #if PYTHON_VERSION >= 0x3b0
+#if PYTHON_VERSION >= 0x3d0
+#include <internal/pycore_opcode_utils.h>
+#include <opcode_ids.h>
+#else
 #include <internal/pycore_opcode.h>
+#endif
 // Clashes with our helper names.
 #undef CALL_FUNCTION
 #endif
 
-#if !defined(PY_NOGIL) && PYTHON_VERSION < 0x3c0
+#if PYTHON_VERSION >= 0x3c0
+#include <cpython/code.h>
+#endif
+
+#if PYTHON_VERSION < 0x3c0
+// Make sure we go the really fast variant, spell-checker: ignore gilstate
 #undef PyThreadState_GET
 #define _PyThreadState_Current _PyRuntime.gilstate.tstate_current
 #define PyThreadState_GET() ((PyThreadState *)_Py_atomic_load_relaxed(&_PyThreadState_Current))
@@ -150,6 +190,15 @@ extern _PyRuntimeState _PyRuntime;
 #include <objimpl.h>
 #endif
 
+#if PYTHON_VERSION >= 0x3d0
+#include <internal/pycore_freelist.h>
+#include <internal/pycore_intrinsics.h>
+#include <internal/pycore_modsupport.h>
+#include <internal/pycore_parking_lot.h>
+#include <internal/pycore_setobject.h>
+#include <internal/pycore_time.h>
+#endif
+
 #undef Py_BUILD_CORE
 
 #endif
@@ -188,26 +237,19 @@ extern _PyRuntimeState _PyRuntime;
 
 #define NUITKA_NO_RETURN HEDLEY_NO_RETURN
 
-/* A way to not give warnings about things that are declared, but might not
- * be used like in-line helper functions in headers or static per module
- * variables from headers.
- */
-#ifdef __GNUC__
-#define NUITKA_MAY_BE_UNUSED __attribute__((__unused__))
-#else
-#define NUITKA_MAY_BE_UNUSED
-#endif
-
 /* This is used to indicate code control flows we know cannot happen. */
 #ifndef __NUITKA_NO_ASSERT__
 #define NUITKA_CANNOT_GET_HERE(NAME)                                                                                   \
     PRINT_FORMAT("%s : %s\n", __FUNCTION__, #NAME);                                                                    \
-    assert(false);                                                                                                     \
     abort();
 #else
 #define NUITKA_CANNOT_GET_HERE(NAME) abort();
 #endif
 
+#define NUITKA_ERROR_EXIT(NAME)                                                                                        \
+    PRINT_FORMAT("%s : %s\n", __FUNCTION__, #NAME);                                                                    \
+    abort();
+
 #ifdef _MSC_VER
 /* Using "_alloca" extension due to MSVC restrictions for array variables
  * on the local stack.
@@ -219,16 +261,10 @@ extern _PyRuntimeState _PyRuntime;
 #define NUITKA_DYNAMIC_ARRAY_DECL(VARIABLE_NAME, ELEMENT_TYPE, COUNT) ELEMENT_TYPE VARIABLE_NAME[COUNT];
 #endif
 
-// Stringizing, to make strings out of defines use XSTRINGIZED(SOME_DEFINE) needs
-// to level of defines to work.
-#define _STRINGIZED(ARG) #ARG
-#define STRINGIZED(ARG) _STRINGIZED(ARG)
-
 /* Python3 removed PyInt instead of renaming PyLong, and PyObject_Str instead
  * of renaming PyObject_Unicode. Define this to be easily portable.
  */
 #if PYTHON_VERSION >= 0x300
-#define PyInt_FromLong PyLong_FromLong
 #define PyInt_AsLong PyLong_AsLong
 #define PyInt_FromSsize_t PyLong_FromSsize_t
 
@@ -242,35 +278,62 @@ extern _PyRuntimeState _PyRuntime;
  * which makes it easier to write portable code.
  */
 #if PYTHON_VERSION < 0x300
+#define PyUnicode_GET_LENGTH(x) (PyUnicode_GET_SIZE(x))
 #define Nuitka_String_AsString PyString_AsString
 #define Nuitka_String_AsString_Unchecked PyString_AS_STRING
 #define Nuitka_String_Check PyString_Check
 #define Nuitka_String_CheckExact PyString_CheckExact
+NUITKA_MAY_BE_UNUSED static inline bool Nuitka_StringOrUnicode_CheckExact(PyObject *value) {
+    return PyString_CheckExact(value) || PyUnicode_CheckExact(value);
+}
 #define Nuitka_StringObject PyStringObject
 #define Nuitka_String_FromString PyString_FromString
 #define Nuitka_String_FromStringAndSize PyString_FromStringAndSize
 #define Nuitka_String_FromFormat PyString_FromFormat
 #define PyUnicode_CHECK_INTERNED (0)
+NUITKA_MAY_BE_UNUSED static Py_UNICODE *Nuitka_UnicodeAsWideString(PyObject *str, Py_ssize_t *size) {
+    PyObject *unicode;
+
+    if (!PyUnicode_Check(str)) {
+        // Leaking memory, but for usages its acceptable to
+        // achieve that the pointer remains valid.
+        unicode = PyObject_Unicode(str);
+    } else {
+        unicode = str;
+    }
+
+    if (size != NULL) {
+        *size = (Py_ssize_t)PyUnicode_GET_LENGTH(unicode);
+    }
+
+    return PyUnicode_AsUnicode(unicode);
+}
 #else
 #define Nuitka_String_AsString _PyUnicode_AsString
 
-/* Note: This is from unicodeobject.c */
+// Note: This private stuff from file "Objects/unicodeobject.c"
+// spell-checker: ignore unicodeobject
 #define _PyUnicode_UTF8(op) (((PyCompactUnicodeObject *)(op))->utf8)
 #define PyUnicode_UTF8(op)                                                                                             \
     (assert(PyUnicode_IS_READY(op)),                                                                                   \
      PyUnicode_IS_COMPACT_ASCII(op) ? ((char *)((PyASCIIObject *)(op) + 1)) : _PyUnicode_UTF8(op))
+#ifdef __NUITKA_NO_ASSERT__
 #define Nuitka_String_AsString_Unchecked PyUnicode_UTF8
-
+#else
+NUITKA_MAY_BE_UNUSED static char const *Nuitka_String_AsString_Unchecked(PyObject *object) {
+    char const *result = PyUnicode_UTF8(object);
+    assert(result != NULL);
+    return result;
+}
+#endif
 #define Nuitka_String_Check PyUnicode_Check
 #define Nuitka_String_CheckExact PyUnicode_CheckExact
+#define Nuitka_StringOrUnicode_CheckExact PyUnicode_CheckExact
 #define Nuitka_StringObject PyUnicodeObject
 #define Nuitka_String_FromString PyUnicode_FromString
 #define Nuitka_String_FromStringAndSize PyUnicode_FromStringAndSize
 #define Nuitka_String_FromFormat PyUnicode_FromFormat
-#endif
-
-#if PYTHON_VERSION < 0x300
-#define PyUnicode_GET_LENGTH(x) (PyUnicode_GET_SIZE(x))
+#define Nuitka_UnicodeAsWideString PyUnicode_AsWideCharString
 #endif
 
 // Wrap the type lookup for debug mode, to identify errors, and potentially
@@ -296,22 +359,6 @@ NUITKA_MAY_BE_UNUSED static PyObject *Nuitka_TypeLookup(PyTypeObject *type, PyOb
 #define NUITKA_MODULE_ENTRY_FUNCTION PyObject *
 #endif
 
-/* Avoid gcc warnings about using an integer as a bool. This is a cherry-pick.
- *
- * This might apply to more versions. I am seeing this on 3.3.2, and it was
- * fixed for Python 2.x only later. We could include more versions. This is
- * only a problem with debug mode and therefore not too important maybe.
- */
-#if PYTHON_VERSION >= 0x300 && PYTHON_VERSION < 0x340
-
-#undef PyMem_MALLOC
-#define PyMem_MALLOC(n) ((size_t)(n) > (size_t)PY_SSIZE_T_MAX ? NULL : malloc(((n) != 0) ? (n) : 1))
-
-#undef PyMem_REALLOC
-#define PyMem_REALLOC(p, n) ((size_t)(n) > (size_t)PY_SSIZE_T_MAX ? NULL : realloc((p), ((n) != 0) ? (n) : 1))
-
-#endif
-
 #if PYTHON_VERSION < 0x300
 typedef long Py_hash_t;
 #endif
@@ -372,9 +419,9 @@ extern PyThreadState *_PyThreadState_Current;
 #endif
 
 #if PYTHON_VERSION < 0x300
-#define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) ? (t)->tp_richcompare : NULL)
+#define TP_RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) ? (t)->tp_richcompare : NULL)
 #else
-#define RICHCOMPARE(t) ((t)->tp_richcompare)
+#define TP_RICHCOMPARE(t) ((t)->tp_richcompare)
 #endif
 
 // For older Python we need to define this ourselves.
@@ -398,6 +445,21 @@ extern PyThreadState *_PyThreadState_Current;
 #define PyFloat_SET_DOUBLE(op, value) ((PyFloatObject *)(op))->ob_fval = value
 #endif
 
+#ifndef Py_NewRef
+static inline PyObject *_Py_NewRef(PyObject *obj) {
+    Py_INCREF(obj);
+    return obj;
+}
+
+static inline PyObject *_Py_XNewRef(PyObject *obj) {
+    Py_XINCREF(obj);
+    return obj;
+}
+
+#define Py_NewRef(obj) _Py_NewRef((PyObject *)(obj))
+#define Py_XNewRef(obj) _Py_XNewRef((PyObject *)(obj))
+#endif
+
 // For older Python, we don't have a feature "CLASS" anymore, that's implied now.
 #if PYTHON_VERSION < 0x300
 #define NuitkaType_HasFeatureClass(descr) (PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))
@@ -416,7 +478,7 @@ extern bool Nuitka_Type_IsSubtype(PyTypeObject *a, PyTypeObject *b);
 #include <longintrepr.h>
 
 #if PYTHON_VERSION < 0x270
-// Not present in Python2.6 yet
+// Not present in Python2.6 yet, spell-checker: ignore sdigit
 typedef signed int sdigit;
 #endif
 #endif
@@ -433,7 +495,7 @@ typedef long nuitka_digit;
 #include "nuitka/compiled_function.h"
 
 /* Sentinel PyObject to be used for all our call iterator endings. */
-extern PyObject *_sentinel_value;
+extern PyObject *Nuitka_sentinel_value;
 
 /* Value to use for __compiled__ value of all modules. */
 extern PyObject *Nuitka_dunder_compiled_value;
@@ -453,11 +515,13 @@ extern PyObject *Nuitka_dunder_compiled_value;
 #include "nuitka/filesystem_paths.h"
 #include "nuitka/safe_string_ops.h"
 
+#include "nuitka/jit_sources.h"
+
 #if _NUITKA_EXPERIMENTAL_WRITEABLE_CONSTANTS
 #include "nuitka_data_decoder.h"
 #else
 #define DECODE(x) assert(x)
-#define UNTRANSLATE(x) (x)
+#define UN_TRANSLATE(x) (x)
 #endif
 
 #if _NUITKA_EXPERIMENTAL_FILE_TRACING
@@ -476,6 +540,8 @@ extern PyObject *Nuitka_dunder_compiled_value;
 
 #define TRACE_FILE_LISTDIR(tstate, x, y) (false)
 
+#define TRACE_FILE_STAT(tstate, x, y, z, r) (false)
+
 #endif
 
 #if _NUITKA_EXPERIMENTAL_INIT_PROGRAM
@@ -485,9 +551,35 @@ extern PyObject *Nuitka_dunder_compiled_value;
 #define NUITKA_INIT_PROGRAM_LATE(module_name)
 #endif
 
+#if _NUITKA_EXPERIMENTAL_EXIT_PROGRAM
+#include "nuitka_exit_program.h"
+#else
+#define NUITKA_FINALIZE_PROGRAM(tstate)
+#endif
+
 // Only Python3.9+ has a more precise check, while making the old one slow.
 #ifndef PyCFunction_CheckExact
 #define PyCFunction_CheckExact PyCFunction_Check
 #endif
 
+#ifdef _NUITKA_EXPERIMENTAL_DUMP_C_TRACEBACKS
+extern void INIT_C_BACKTRACES(void);
+extern void DUMP_C_BACKTRACE(void);
 #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/printing.h

@@ -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
+
 #ifndef __NUITKA_PRINTING_H__
 #define __NUITKA_PRINTING_H__
 
@@ -23,7 +8,9 @@
 
 extern bool PRINT_NEW_LINE(void);
 extern bool PRINT_ITEM(PyObject *object);
+extern bool PRINT_ITEM_LINE(PyObject *object);
 extern bool PRINT_STRING(char const *str);
+extern bool PRINT_STRING_W(wchar_t const *str);
 extern bool PRINT_FORMAT(char const *fmt, ...);
 extern bool PRINT_ITEM_TO(PyObject *file, PyObject *object);
 extern bool PRINT_NEW_LINE_TO(PyObject *file);
@@ -46,13 +33,18 @@ extern void PRINT_TRACEBACK(PyTracebackObject *traceback);
 #endif
 
 // Print the exception state, including NULL values.
-#if PYTHON_VERSION < 0x3b0
+extern void _PRINT_EXCEPTION3(PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb);
+extern void _PRINT_EXCEPTION1(PyObject *exception_value);
+
+#if PYTHON_VERSION < 0x3c0
 #define PRINT_EXCEPTION(exception_type, exception_value, exception_tb)                                                 \
-    _PRINT_EXCEPTION(exception_type, exception_value, exception_tb)
-extern void _PRINT_EXCEPTION(PyObject *exception_type, PyObject *exception_value, PyTracebackObject *exception_tb);
+    _PRINT_EXCEPTION3(exception_type, exception_value, exception_tb)
+#define PRINT_EXCEPTION_STATE(exception_state)                                                                         \
+    _PRINT_EXCEPTION3((exception_state)->exception_type, (exception_state)->exception_value,                           \
+                      (exception_state)->exception_tb)
 #else
-#define PRINT_EXCEPTION(exception_type, exception_value, exception_tb) _PRINT_EXCEPTION(exception_value)
-extern void _PRINT_EXCEPTION(PyObject *exception_value);
+#define PRINT_EXCEPTION(exception_type, exception_value, exception_tb) _PRINT_EXCEPTION1(exception_value)
+#define PRINT_EXCEPTION_STATE(exception_state) _PRINT_EXCEPTION1((exception_state)->exception_value)
 #endif
 
 // Print the current exception state, including NULL values.
@@ -71,3 +63,18 @@ extern bool PRINT_NULL(void);
 extern bool PRINT_TYPE(PyObject *object);
 
 #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/python_pgo.h

@@ -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
+
 #ifndef __NUITKA_PYTHON_PGO_H__
 #define __NUITKA_PYTHON_PGO_H__
 
@@ -26,6 +11,8 @@
 
 #if _NUITKA_PGO_PYTHON
 
+#include <stdint.h>
+
 // Initialize PGO data collection.
 extern void PGO_Initialize(void);
 
@@ -53,4 +40,18 @@ extern void PGO_onTechnicalModule(char const *module_name);
 
 #endif
 
-#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/safe_string_ops.h

@@ -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
+
 #ifndef __NUITKA_SAFE_STRING_OPS_H__
 #define __NUITKA_SAFE_STRING_OPS_H__
 
@@ -34,17 +19,34 @@ extern void appendStringSafe(char *target, char const *source, size_t buffer_siz
 
 /* Safe to use functions to append a wide char string, will abort program for overflow. */
 extern void appendCharSafeW(wchar_t *target, char c, size_t buffer_size);
+extern void appendWCharSafeW(wchar_t *target, wchar_t c, size_t buffer_size);
 extern void appendStringSafeW(wchar_t *target, char const *source, size_t buffer_size);
 extern void appendWStringSafeW(wchar_t *target, wchar_t const *source, size_t buffer_size);
 
 /* Get OS error code and print it to stderr. */
 #ifdef _WIN32
 typedef DWORD error_code_t;
+#define ERROR_CODE_FORMAT_STR "%ld"
 static inline error_code_t getCurrentErrorCode(void) { return GetLastError(); }
 #else
 typedef int error_code_t;
+#define ERROR_CODE_FORMAT_STR "%d"
 static inline error_code_t getCurrentErrorCode(void) { return errno; }
 #endif
 extern void printOSErrorMessage(char const *message, error_code_t error_code);
 
-#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.