Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/build/include/nuitka/python_pgo.h

@@ -0,0 +1,57 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_PYTHON_PGO_H__
+#define __NUITKA_PYTHON_PGO_H__
+
+// In Visual Code, evaluate the code for PGO so we see errors of it sooner.
+#ifdef __IDE_ONLY__
+#define _NUITKA_PGO_PYTHON 1
+#include "nuitka/prelude.h"
+#endif
+
+#if _NUITKA_PGO_PYTHON
+
+#include <stdint.h>
+
+// Initialize PGO data collection.
+extern void PGO_Initialize(void);
+
+// At end of program, write tables.
+extern void PGO_Finalize(void);
+
+// When a module is entered.
+extern void PGO_onModuleEntered(char const *module_name);
+// When a module is exited.
+extern void PGO_onModuleExit(char const *module_name, bool had_error);
+
+extern void PGO_onProbePassed(char const *module_name, char const *probe_id, uint32_t probe_arg);
+
+extern void PGO_onTechnicalModule(char const *module_name);
+
+#else
+
+#define PGO_Initialize()
+#define PGO_Finalize()
+
+#define PGO_onModuleEntered(module_name) ;
+#define PGO_onModuleExit(module_name, had_error) ;
+
+#define PGO_onProbePassed(module_name, probe_id, probe_arg) ;
+
+#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

@@ -0,0 +1,57 @@
+//     Copyright 2025, 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__
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/* Safe to use function to copy a string, will abort program for overflow. */
+extern void copyStringSafe(char *buffer, char const *source, size_t buffer_size);
+extern void copyStringSafeN(char *buffer, char const *source, size_t n, size_t buffer_size);
+extern void copyStringSafeW(wchar_t *buffer, wchar_t const *source, size_t buffer_size);
+
+/* Safe to use function to append a string, will abort program for overflow. */
+extern void appendCharSafe(char *target, char c, size_t buffer_size);
+extern void appendStringSafe(char *target, char const *source, size_t buffer_size);
+
+/* 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);
+
+// Check that a string value is actually a number, used to prevent path
+// injections with inherited environment variables.
+void checkWStringNumber(wchar_t const *value);
+void checkStringNumber(char const *value);
+
+/* 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
+//     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/threading.h

@@ -0,0 +1,142 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_THREADING_H__
+#define __NUITKA_THREADING_H__
+
+#if PYTHON_VERSION < 0x300
+// We share this with CPython bytecode main loop.
+PyAPI_DATA(volatile int) _Py_Ticker;
+#else
+extern volatile int _Py_Ticker;
+#define _Py_CheckInterval 20
+#endif
+
+#ifdef NUITKA_USE_PYCORE_THREAD_STATE
+
+#if PYTHON_VERSION < 0x380
+
+// Signals pending got their own indicator only in 3.8, covered by calls to do before.
+#define HAS_WORK_TO_DO(ceval, ceval2) (ceval2->pending.calls_to_do._value)
+#elif PYTHON_VERSION < 0x3d0
+#define HAS_WORK_TO_DO(ceval, ceval2) (ceval->signals_pending._value || ceval2->pending.calls_to_do._value)
+#else
+#define HAS_WORK_TO_DO(ceval, ceval2) _Py_eval_breaker_bit_is_set(tstate, _PY_SIGNALS_PENDING_BIT | _PY_CALLS_TO_DO_BIT)
+#endif
+
+#ifndef Py_GIL_DISABLED
+NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate) {
+#if PYTHON_VERSION < 0x390
+    _PyRuntimeState *const runtime = &_PyRuntime;
+#elif PYTHON_VERSION < 0x3d0
+    _PyRuntimeState *const runtime = tstate->interp->runtime;
+#endif
+
+#if PYTHON_VERSION < 0x3d0
+    // This was split in 2 parts in 3.9 or higher.
+    struct _ceval_runtime_state *ceval = &runtime->ceval;
+#if PYTHON_VERSION >= 0x390
+    struct _ceval_state *ceval2 = &tstate->interp->ceval;
+#else
+    struct _ceval_runtime_state *ceval2 = ceval;
+#endif
+#endif
+    // Pending signals or calls to do
+    if (HAS_WORK_TO_DO(ceval, ceval2)) {
+        int res = Py_MakePendingCalls();
+
+        if (unlikely(res < 0 && HAS_ERROR_OCCURRED(tstate))) {
+            return false;
+        }
+    }
+
+#if PYTHON_VERSION >= 0x3d0
+    /* GIL drop request */
+    if (_Py_eval_breaker_bit_is_set(tstate, _PY_GIL_DROP_REQUEST_BIT)) {
+#else
+    /* GIL drop request */
+    if (ceval2->gil_drop_request._value) {
+#endif
+        /* Give another thread a chance */
+        PyEval_SaveThread();
+        PyEval_AcquireThread(tstate);
+    }
+
+    if (unlikely(tstate->async_exc != NULL)) {
+        PyObject *async_exc = tstate->async_exc;
+        tstate->async_exc = NULL;
+
+        SET_CURRENT_EXCEPTION_TYPE0(tstate, async_exc);
+
+        return false;
+    }
+
+    return true;
+}
+#else
+NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate) {
+    if (unlikely(tstate->async_exc != NULL)) {
+        PyObject *async_exc = tstate->async_exc;
+        tstate->async_exc = NULL;
+
+        SET_CURRENT_EXCEPTION_TYPE0(tstate, async_exc);
+
+        return false;
+    }
+
+    return true;
+}
+
+#endif
+
+#else
+
+NUITKA_MAY_BE_UNUSED static inline bool CONSIDER_THREADING(PyThreadState *tstate) {
+    // Decrease ticker
+    if (--_Py_Ticker < 0) {
+        _Py_Ticker = _Py_CheckInterval;
+
+        int res = Py_MakePendingCalls();
+
+        if (unlikely(res < 0 && HAS_ERROR_OCCURRED(tstate))) {
+            return false;
+        }
+
+        if (PyEval_ThreadsInitialized()) {
+            // Release and acquire the GIL, it's very inefficient, because we
+            // don't even know if it makes sense to do it. A controlling thread
+            // should be used to determine if it's needed at all.
+            PyEval_SaveThread();
+            PyEval_AcquireThread(tstate);
+        }
+
+        if (unlikely(tstate->async_exc != NULL)) {
+            PyObject *async_exc = tstate->async_exc;
+            tstate->async_exc = NULL;
+
+            SET_CURRENT_EXCEPTION_TYPE0(tstate, async_exc);
+
+            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/tracing.h

@@ -0,0 +1,82 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_TRACING_H__
+#define __NUITKA_TRACING_H__
+
+/* Stupid tracing, intended to help where debugging is not an option
+ * and to give kind of progress record of startup and the running of
+ * the program.
+ */
+
+#ifdef _NUITKA_TRACE
+
+#define NUITKA_PRINT_TRACE(value)                                                                                      \
+    {                                                                                                                  \
+        puts(value);                                                                                                   \
+        fflush(stdout);                                                                                                \
+    }
+#define NUITKA_PRINTF_TRACE(...)                                                                                       \
+    {                                                                                                                  \
+        printf(__VA_ARGS__);                                                                                           \
+        fflush(stdout);                                                                                                \
+    }
+
+#else
+#define NUITKA_PRINT_TRACE(value)
+#define NUITKA_PRINTF_TRACE(...)
+
+#endif
+
+#if defined(_NUITKA_EXPERIMENTAL_SHOW_STARTUP_TIME)
+
+#if defined(_WIN32)
+
+#include <windows.h>
+static void inline PRINT_TIME_STAMP(void) {
+    SYSTEMTIME t;
+    GetSystemTime(&t); // or GetLocalTime(&t)
+    printf("%02d:%02d:%02d.%03d:", t.wHour, t.wMinute, t.wSecond, t.wMilliseconds);
+}
+#else
+static void inline PRINT_TIME_STAMP(void) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+
+    time_t now_time = tv.tv_sec;
+    struct tm *now_tm = localtime(&now_time);
+
+    char tm_buf[64];
+    strftime(tm_buf, sizeof(tm_buf), "%Y-%m-%d %H:%M:%S", now_tm);
+    printf("%s.%03ld ", tm_buf, tv.tv_usec / 1000);
+}
+#endif
+
+#define NUITKA_PRINT_TIMING(value)                                                                                     \
+    {                                                                                                                  \
+        PRINT_TIME_STAMP();                                                                                            \
+        puts(value);                                                                                                   \
+        fflush(stdout);                                                                                                \
+    }
+
+#else
+
+#define NUITKA_PRINT_TIMING(value) NUITKA_PRINT_TRACE(value)
+
+#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/type_aliases.h

@@ -0,0 +1,30 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_TYPE_ALIASES_H__
+#define __NUITKA_TYPE_ALIASES_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
+
+// Helpers for type aliases, type variables, and generic base classes.
+extern PyObject *MAKE_TYPE_ALIAS(PyObject *name, PyObject *type_params, PyObject *value, PyObject *module_name);
+extern PyObject *MAKE_TYPE_VAR(PyThreadState *tstate, PyObject *name);
+extern PyObject *MAKE_TYPE_GENERIC(PyThreadState *tstate, PyObject *params);
+
+#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/unfreezing.h

@@ -0,0 +1,91 @@
+//     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+#ifndef __NUITKA_UNFREEZING_H__
+#define __NUITKA_UNFREEZING_H__
+
+#include <stdbool.h>
+
+/* Modes for loading modules, can be compiled, external shared library, or
+ * bytecode. */
+#define NUITKA_COMPILED_MODULE 0
+#define NUITKA_EXTENSION_MODULE_FLAG 1
+#define NUITKA_PACKAGE_FLAG 2
+#define NUITKA_BYTECODE_FLAG 4
+
+#define NUITKA_ABORT_MODULE_FLAG 8
+
+#define NUITKA_TRANSLATED_FLAG 16
+
+struct Nuitka_MetaPathBasedLoaderEntry;
+
+typedef PyObject *(*module_init_func)(PyThreadState *tstate, PyObject *module,
+                                      struct Nuitka_MetaPathBasedLoaderEntry const *loader_entry);
+
+#if PYTHON_VERSION >= 0x370 && _NUITKA_EXE_MODE && !_NUITKA_STANDALONE_MODE &&                                         \
+    defined(_NUITKA_FILE_REFERENCE_ORIGINAL_MODE)
+#define _NUITKA_FREEZER_HAS_FILE_PATH
+#endif
+
+struct Nuitka_MetaPathBasedLoaderEntry {
+    // Full module name, including package name.
+    char const *name;
+
+    // Entry function if compiled module, otherwise NULL.
+    module_init_func python_init_func;
+
+    // For bytecode modules, start and size inside the constants blob.
+    int bytecode_index;
+    int bytecode_size;
+
+    // Flags: Indicators if this is compiled, bytecode or shared library.
+    int flags;
+
+    // For accelerated mode, we need to be able to tell where the module "__file__"
+    // lives, so we can resolve resource reader paths, not relative to the binary
+    // but to code location without loading it.
+#if defined(_NUITKA_FREEZER_HAS_FILE_PATH)
+#if defined _WIN32
+    wchar_t const *file_path;
+#else
+    char const *file_path;
+#endif
+#endif
+};
+
+/* For embedded modules, register the meta path based loader. Used by main
+ * program/package only.
+ */
+extern void registerMetaPathBasedLoader(struct Nuitka_MetaPathBasedLoaderEntry *loader_entries,
+                                        unsigned char **bytecode_data);
+
+// For module mode, embedded modules may have to be shifted to below the
+// namespace they are loaded into.
+#if _NUITKA_MODULE_MODE
+extern void updateMetaPathBasedLoaderModuleRoot(char const *module_root_name);
+#endif
+
+/* Create a loader object responsible for a package. */
+extern PyObject *Nuitka_Loader_New(struct Nuitka_MetaPathBasedLoaderEntry const *entry);
+
+// Create a distribution object from the given metadata.
+extern PyObject *Nuitka_Distribution_New(PyThreadState *tstate, PyObject *name);
+
+// Check if we provide a distribution object ourselves.
+extern bool Nuitka_DistributionNext(Py_ssize_t *pos, PyObject **distribution_name_ptr);
+
+#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/inline_copy/appdirs/LICENSE.txt

@@ -0,0 +1,23 @@
+# This is the MIT license
+
+Copyright (c) 2010 ActiveState Software Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+