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

nuitka/build/static_src/HelpersFloats.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
+
 /* These helpers are used to work with float values.
 
 */
@@ -50,37 +35,58 @@ PyObject *TO_FLOAT(PyObject *value) {
 
 #if NUITKA_FLOAT_HAS_FREELIST
 
-static struct _Py_float_state *_Nuitka_Py_get_float_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->float_state;
-}
+static PyFloatObject *_Nuitka_AllocatePyFloatObject(PyThreadState *tstate) {
+    // This is the CPython name, spell-checker: ignore numfree
 
-static PyFloatObject *_Nuitka_AllocatePyFloatObject(void) {
-    struct _Py_float_state *state = _Nuitka_Py_get_float_state();
-
-    PyFloatObject *result_float = state->free_list;
+#if PYTHON_VERSION < 0x3d0
+    struct _Py_float_state *state = &tstate->interp->float_state;
+    PyFloatObject **free_list = &state->free_list;
+    int *numfree = &state->numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_float_freelist *state = &freelists->floats;
+    PyFloatObject **free_list = &state->items;
+    int *numfree = &state->numfree;
+#endif
+    PyFloatObject *result_float = *free_list;
 
     if (result_float) {
-        state->free_list = (PyFloatObject *)Py_TYPE(result_float);
-        state->numfree -= 1;
-
-        Py_SET_TYPE(result_float, &PyFloat_Type);
+        (*numfree) -= 1;
+        *free_list = (PyFloatObject *)Py_TYPE(result_float);
     } else {
-        result_float = (PyFloatObject *)PyObject_Malloc(sizeof(PyFloatObject));
+        result_float = (PyFloatObject *)NuitkaObject_Malloc(sizeof(PyFloatObject));
     }
 
     Py_SET_TYPE(result_float, &PyFloat_Type);
     Nuitka_Py_NewReference((PyObject *)result_float);
+
     assert(result_float != NULL);
 
     return result_float;
 }
 
 PyObject *MAKE_FLOAT_FROM_DOUBLE(double value) {
-    PyFloatObject *result = _Nuitka_AllocatePyFloatObject();
+    PyThreadState *tstate = PyThreadState_GET();
+
+    PyFloatObject *result = _Nuitka_AllocatePyFloatObject(tstate);
 
     PyFloat_SET_DOUBLE(result, value);
     return (PyObject *)result;
 }
 
 #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/HelpersHeapStorage.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
+
 /** For making "yield" and "yield from" capable of persisting current C stack.
  *
  * These copy objects pointed to into an array foreseen for this task.
@@ -43,6 +28,8 @@ void Nuitka_PreserveHeap(void *dest, ...) {
         memcpy(w, source, size);
         w += size;
     }
+
+    va_end(ap);
 }
 
 void Nuitka_RestoreHeap(void *source, ...) {
@@ -61,4 +48,21 @@ void Nuitka_RestoreHeap(void *source, ...) {
         memcpy(dest, w, size);
         w += size;
     }
+
+    va_end(ap);
 }
+
+//     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/HelpersImport.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
+
 /** For making imports work.
  *
  * These make the actual built-in importing mechanic work with Nuitka. We
@@ -187,7 +172,21 @@ bool IMPORT_MODULE_STAR(PyThreadState *tstate, PyObject *target, bool is_module,
 
         // When we are not using the "__all__", we should skip private variables.
         if (all_case == false) {
-            if (Nuitka_String_AsString_Unchecked(item)[0] == '_') {
+            PyObject *startswith_value;
+#if PYTHON_VERSION < 0x300
+            if (PyString_Check(item)) {
+                startswith_value = STR_STARTSWITH2(tstate, item, const_str_underscore);
+            } else {
+                startswith_value = UNICODE_STARTSWITH2(tstate, item, const_str_underscore);
+            }
+#else
+            startswith_value = UNICODE_STARTSWITH2(tstate, item, const_str_underscore);
+#endif
+
+            CHECK_OBJECT(startswith_value);
+            Py_DECREF(startswith_value);
+
+            if (startswith_value == Py_True) {
                 continue;
             }
         }
@@ -237,7 +236,7 @@ PyObject *IMPORT_NAME_FROM_MODULE(PyThreadState *tstate, PyObject *module, PyObj
             Py_DECREF(filename);
             Py_DECREF(name);
 
-#elif PYTHON_VERSION >= 0x340 || !defined(_NUITKA_FULL_COMPAT)
+#elif PYTHON_VERSION >= 0x300 || !defined(_NUITKA_FULL_COMPAT)
             PyErr_Format(PyExc_ImportError, "cannot import name '%s'", Nuitka_String_AsString(import_name));
 #else
             PyErr_Format(PyExc_ImportError, "cannot import name %s", Nuitka_String_AsString(import_name));
@@ -422,7 +421,7 @@ PyObject *IMPORT_NAME_OR_MODULE(PyThreadState *tstate, PyObject *module, PyObjec
             }
 
             if (level_int > 0) {
-                PyObject *fromlist = MAKE_TUPLE1(import_name);
+                PyObject *fromlist = MAKE_TUPLE1(tstate, import_name);
 
                 result = IMPORT_MODULE5(tstate, const_str_empty, globals, globals, fromlist, level);
 
@@ -472,3 +471,32 @@ PyObject *IMPORT_NAME_OR_MODULE(PyThreadState *tstate, PyObject *module, PyObjec
     return result;
 }
 #endif
+
+PyObject *IMPORT_MODULE_FIXED(PyThreadState *tstate, PyObject *module_name, PyObject *value_name) {
+    PyObject *import_result = IMPORT_MODULE1(tstate, module_name);
+
+    if (unlikely(import_result == NULL)) {
+        return import_result;
+    }
+
+    PyObject *result = Nuitka_GetModule(tstate, value_name);
+
+    Py_DECREF(import_result);
+
+    return result;
+}
+
+//     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/HelpersImportHard.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
+
 /* WARNING, this code is GENERATED. Modify the template HelperImportHard.c.j2 instead! */
 
 /* This file is included from another C file, help IDEs to still parse it on its own. */
@@ -102,6 +87,25 @@ PyObject *IMPORT_HARD__IO(void) {
     return module_import_hard__io;
 }
 
+/* C helper for hard import of module "builtins" import. */
+PyObject *IMPORT_HARD_BUILTINS(void) {
+    static PyObject *module_import_hard_builtins = NULL;
+
+    if (module_import_hard_builtins == NULL) {
+        module_import_hard_builtins = PyImport_ImportModule("builtins");
+
+        if (unlikely(module_import_hard_builtins == NULL)) {
+#ifndef __NUITKA_NO_ASSERT__
+            PyErr_PrintEx(0);
+#endif
+            NUITKA_CANNOT_GET_HERE("failed hard import of 'builtins'");
+            abort();
+        }
+    }
+
+    return module_import_hard_builtins;
+}
+
 /* C helper for hard import of module "ctypes" import. */
 PyObject *IMPORT_HARD_CTYPES(void) {
     static PyObject *module_import_hard_ctypes = NULL;
@@ -434,6 +438,21 @@ PyObject *IMPORT_HARD_SYSCONFIG(void) {
     return module_import_hard_sysconfig;
 }
 
+/* C helper for hard import of module "tensorflow" import. */
+PyObject *IMPORT_HARD_TENSORFLOW(void) {
+    static PyObject *module_import_hard_tensorflow = NULL;
+
+    if (module_import_hard_tensorflow == NULL) {
+        module_import_hard_tensorflow = PyImport_ImportModule("tensorflow");
+
+        if (unlikely(module_import_hard_tensorflow == NULL)) {
+            return NULL;
+        }
+    }
+
+    return module_import_hard_tensorflow;
+}
+
 /* C helper for hard import of module "types" import. */
 PyObject *IMPORT_HARD_TYPES(void) {
     static PyObject *module_import_hard_types = NULL;
@@ -494,6 +513,7 @@ PyObject *IMPORT_HARD_UNITTEST(void) {
 }
 
 /* C helper for hard import of module "unittest.mock" import. */
+#if PYTHON_VERSION >= 0x300
 PyObject *IMPORT_HARD_UNITTEST__MOCK(void) {
     static PyObject *module_import_hard_unittest__mock = NULL;
 
@@ -511,3 +531,19 @@ PyObject *IMPORT_HARD_UNITTEST__MOCK(void) {
 
     return module_import_hard_unittest__mock;
 }
+#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/HelpersJitSources.c

@@ -0,0 +1,46 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// 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
+
+#ifdef _NUITKA_STANDALONE
+
+static char const *uncompiled_sources_dict_attribute_name = "_uncompiled_function_sources_dict";
+
+void SET_UNCOMPILED_FUNCTION_SOURCE_DICT(PyObject *name, PyObject *source) {
+    PyObject *uncompiled_function_sources_dict =
+        PyObject_GetAttrString((PyObject *)builtin_module, uncompiled_sources_dict_attribute_name);
+
+    if (uncompiled_function_sources_dict == NULL) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        DROP_ERROR_OCCURRED(tstate);
+
+        uncompiled_function_sources_dict = MAKE_DICT_EMPTY(tstate);
+
+        PyObject_SetAttrString((PyObject *)builtin_module, uncompiled_sources_dict_attribute_name,
+                               uncompiled_function_sources_dict);
+    }
+
+    bool res = DICT_SET_ITEM(uncompiled_function_sources_dict, name, source);
+    assert(res == 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.